LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10858
movq %rbx, %rdi
callq 0x108ae
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 0x18150
leaq 0xbc55(%rip), %rsi      # 0x1c495
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_O3/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 0x1615c
movq %fs:-0x28, %r12
subq %fs:-0x30, %r12
shrq $0x3, %r12
testl %r12d, %r12d
je 0x11918
callq 0xc132
movq %rax, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5290
testl %r12d, %r12d
jle 0x118fa
leaq 0x18(%rsp), %r14
addq $0x8, %rbx
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
movq 0x28(%rsp), %rax
movq (%rax,%r13,8), %rdi
movq (%rdi), %rax
leaq 0x60(%rsp), %rsi
callq *0x10(%rax)
movq %r14, 0x8(%rsp)
movq %r15, %rdi
leaq 0xa847(%rip), %rsi      # 0x1c081
leaq 0xa844(%rip), %rdx      # 0x1c085
callq 0x16a64
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107d8
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
leaq 0x68(%rsp), %rsi
callq 0x5560
movq %rsp, %rdi
movq %rbp, %rsi
movl $0x1, %edx
callq 0x116e4
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x11893
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53d0
movq (%rsp), %rdi
callq 0x106a8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x118b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %r14, 0x8(%rsp)
movq %r15, %rdi
leaq 0x9d56(%rip), %rdx      # 0x1b618
movq %rdx, %rsi
callq 0x16a64
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x5530
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x118ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53d0
incq %r13
cmpq %r13, %r12
jne 0x11817
movq 0x1468f(%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 0x11972
jmp 0x11972
movq %rax, %r15
movq %rbx, %rdi
callq 0x106be
jmp 0x1197a
movq %rax, %rdi
callq 0x16173
movq %rax, %r15
jmp 0x11967
movq %rax, %r15
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x11967
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53d0
movq (%rsp), %rdi
callq 0x106a8
jmp 0x1197a
movq %rax, %r15
jmp 0x11991
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x11991
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x145f8(%rip), %rsi     # 0x25f90
leaq 0x50(%rsp), %rdi
callq 0x52c0
leaq 0xd0(%rsp), %rdi
callq 0x5120
movq %r15, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8cbd(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x8cc5(%rip), %xmm0     # 0x1b2c0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd 0x8cc1(%rip), %xmm1     # 0x1b2d0
movapd %xmm1, %xmm0
cmpltsd 0x8cd4(%rip), %xmm0     # 0x1b2f0
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 0x1847a
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x13430
leaq 0x48(%rsp), %rdi
callq 0x1687a
movq 0x80(%r15), %rsi
movq %r12, %rdi
callq 0x18430
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 0x126af
movq (%r14), %rdi
callq 0x6d92
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x16a26
movq 0x20(%r14), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x16a26
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1308a
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12706
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53d0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12721
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 0x12752
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0x12752
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12781
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0x12781
movq %rax, %rbx
jmp 0x12781
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1687a
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x187f6
movq $0x0, 0x30(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15741
movq 0x60(%rbx), %rax
cmpb $0x1, 0x6c(%rax)
jne 0x1574b
movq 0x68(%rbx), %rax
cmpb $0x0, 0x3a(%rax)
je 0x15751
popq %rbx
popq %r14
popq %r15
retq
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x5520
testl %eax, %eax
jne 0x157b7
movq %rbx, %rdi
callq 0x15c2e
movq 0x10(%r15), %rsi
movl 0x18(%r15), %edx
movq (%rbx), %rax
leaq 0x6d1b(%rip), %rcx      # 0x1c496
movq %rbx, %rdi
callq *0x70(%rax)
movzbl 0x28(%r15), %esi
movl 0x8(%r15), %edx
movq 0x8(%rbx), %rdi
xorl $0x1, %esi
callq 0x15fd8
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x137c0
movq %rbx, %rdi
callq 0x16076
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x157ef
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 0x158e5
movq %r14, %rdi
callq 0x15c2e
movq 0x18(%r15), %rsi
movl 0x20(%r15), %edx
movq (%r14), %rax
leaq 0x6c73(%rip), %rcx      # 0x1c496
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 0x6904
movl 0x24(%r15), %eax
testb $0x1, %al
jne 0x15865
testb $0x2, %al
jne 0x1586e
testb $0x4, %al
leaq 0x5dc0(%rip), %rax      # 0x1b618
leaq 0x5cdb(%rip), %r13      # 0x1b53a
cmoveq %rax, %r13
jmp 0x15875
leaq 0x7b9a(%rip), %r13      # 0x1d406
jmp 0x15875
leaq 0x5ccb(%rip), %r13      # 0x1b540
movq %r13, %rdi
callq 0x5170
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5410
leaq 0x7b55(%rip), %rsi      # 0x1d3e7
movl $0x2, %edx
movq %r12, %rdi
callq 0x5410
movq 0x8(%r14), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x6904
movq %r12, %rdi
movq %r15, %rsi
callq 0x68b2
leaq 0x72a2(%rip), %rsi      # 0x1cb61
movl $0x1, %edx
movq %r12, %rdi
callq 0x5410
movq %r14, %rdi
callq 0x16076
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_O3/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 0x1615c
movq %fs:-0x28, %r12
subq %fs:-0x30, %r12
shrq $0x3, %r12
testl %r12d, %r12d
je 0x16139
callq 0xc132
movq %rax, %r14
movq 0x8(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x6904
leaq 0x612c(%rip), %rsi      # 0x1c1f1
movl $0xa, %edx
movq %r15, %rdi
callq 0x5410
testl %r12d, %r12d
jle 0x16139
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq 0x63a5(%rip), %rbp      # 0x1c48d
leaq 0x6a72(%rip), %r15      # 0x1cb61
testq %r13, %r13
movq %rbp, %rsi
leaq 0x551c(%rip), %rax      # 0x1b618
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 0x160ef
movq 0x8(%rbx), %rdi
leaq 0x6a1d(%rip), %rsi      # 0x1cb61
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_O3/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 0x2e555
movq %rsi, %r15
leal -0x1(%rdx), %r12d
movl %edx, %r13d
movl $0x1, %r14d
movsbl %cl, %ebp
movq (%r15,%r14,8), %rsi
movq %rbx, %rdi
callq 0x21d0
cmpq %r12, %r14
jae 0x2e54d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x20f0
incq %r14
cmpq %r14, %r13
jne 0x2e532
movq (%rbx), %r15
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x2e57d
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x2170
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x2e564
movq (%rbx), %r15
movq (%rsp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
leaq 0x10(%rbx), %rdx
cmpq %rdx, %r15
je 0x2e59d
movq %r15, (%rax)
movq (%rdx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2e5a3
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rdx, (%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_O3/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 0x2e681
movq %rsi, %r14
movl %edi, %ebx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe6ba(%rip), %rdx      # 0x3ccad
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x2dd82
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
movl $0x20, %ecx
movq %r15, %r8
callq 0x2e508
leaq 0x22aef(%rip), %rdi     # 0x51110
leaq 0x28(%rsp), %rsi
callq 0x2e728
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e649
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2130
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2e660
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
testq %rbx, %rbx
je 0x2e696
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq 0x22964(%rip), %rdi     # 0x50fd8
callq 0x2150
movq %rax, %rbx
movq (%rax), %rax
jmp 0x2e6b4
movq 0x22950(%rip), %rbx     # 0x50fd8
leaq 0x141d3(%rip), %rsi     # 0x42862
movl $0x43, %edx
jmp 0x2e6a9
movq 0x2293b(%rip), %rbx     # 0x50fd8
leaq 0x1419c(%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 0x2e709
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x2e709
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2e720
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3e06
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
jne 0x3dfa
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 0x3de5
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x3dda
movb %al, (%rsi)
incq 0x50(%rbx)
jmp 0x3de5
movq %r14, %rdi
movq %r12, %rdx
callq 0x4c62
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
je 0x3db6
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 0x3e24
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9d60(%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 0x618f(%rip), %rcx      # 0xa06c
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3360
movq 0x30(%r15), %rdx
leaq 0x6174(%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 0x3f2d
callq 0x3210
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x3f3a
callq 0x3210
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3f47
callq 0x3210
movq %r15, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3cbe
movq (%r14), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x3ff0
cmpl $0xa, %eax
jne 0x400c
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x30b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3160
jmp 0x3fe0
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 0x402a
callq 0x3210
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4d54
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x4990
cmpq $0x11, -0x30(%rbp)
jb 0x409f
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x409f
callq 0x32c0
movq (%rbx), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x414f
movl $0x1, %r13d
xorl %r12d, %r12d
leaq -0x60(%rbp), %r14
leaq -0x80(%rbp), %r15
shlq $0x5, %r12
movq 0x8(%rsi,%r12), %rdx
testq %rdx, %rdx
jne 0x40de
addq %r12, %rsi
movq %rbx, %rdi
callq 0x693c
movq (%rbx), %rsi
movq 0x8(%rsi,%r12), %rdx
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rsi,%r12), %rsi
addq %rsi, %rdx
movq %r14, %rdi
callq 0x3cbe
movq %r15, %rdi
movq %r14, %rdx
callq 0x3fba
addq (%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x32b0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x4120
callq 0x3210
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4132
callq 0x3210
movl %r13d, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
incl %r13d
cmpq %r12, %rax
ja 0x40bd
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 0x4199
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4199
callq 0x32c0
jmp 0x4199
jmp 0x417f
jmp 0x417f
movq %rax, %r14
jmp 0x4199
movq %rax, %r14
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4199
callq 0x3210
movq %rbx, %rdi
callq 0x4b12
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4d54
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rdx
movq %r14, %rsi
movl $0x1, %ecx
callq 0x4990
cmpq $0x11, -0x70(%rbp)
jb 0x421f
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x421f
callq 0x32c0
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %r13
cmpq %r14, %r13
je 0x42e3
movl $0x1, %ebx
xorl %r15d, %r15d
leaq -0x68(%rbp), %r12
shlq $0x5, %r15
movq 0x8(%r14,%r15), %rdx
testq %rdx, %rdx
jne 0x4262
addq %r15, %r14
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x693c
movq -0x40(%rbp), %r14
movq 0x8(%r14,%r15), %rdx
leaq -0x90(%rbp), %r13
movq %r13, -0xa0(%rbp)
movq (%r14,%r15), %rsi
addq %rsi, %rdx
leaq -0xa0(%rbp), %r14
movq %r14, %rdi
callq 0x3cbe
movq %r12, %rdi
movq %r14, %rdx
callq 0x3fba
addq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x32b0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x42b2
callq 0x3210
movq -0xa0(%rbp), %rdi
cmpq %r13, %rdi
je 0x42c3
callq 0x3210
movl %ebx, %r15d
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %r13
movq %r13, %rax
subq %r14, %rax
sarq $0x5, %rax
incl %ebx
cmpq %r15, %rax
ja 0x423c
leaq -0x58(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
cmpq %r13, %r14
je 0x4343
leaq -0x68(%rbp), %r15
leaq 0x5d67(%rip), %r12      # 0xa06d
movq %r15, %rdi
movq %r14, %rsi
callq 0x3160
movq %r15, %rdi
movq %r12, %rsi
callq 0x30f0
testl %eax, %eax
je 0x432c
movq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x4b6a
addq $0x20, %r14
cmpq %r13, %r14
jne 0x4306
movq -0x68(%rbp), %rdi
cmpq %rbx, %rdi
je 0x4343
callq 0x3210
leaq -0x40(%rbp), %rdi
callq 0x4b12
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 0x43a6
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x43a6
callq 0x32c0
jmp 0x43a6
jmp 0x438d
jmp 0x438d
jmp 0x437f
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %rbx, %rdi
jne 0x43a1
jmp 0x43a6
movq %rax, %r14
jmp 0x43a6
movq %rax, %r14
movq -0xa0(%rbp), %rdi
cmpq %r13, %rdi
je 0x43a6
callq 0x3210
movq -0x48(%rbp), %rdi
callq 0x4b12
leaq -0x40(%rbp), %rdi
callq 0x4b12
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4d54
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x4990
cmpq $0x11, -0x30(%rbp)
jb 0x442c
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x442c
callq 0x32c0
movq (%rbx), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x44dc
movl $0x1, %r13d
xorl %r12d, %r12d
leaq -0x60(%rbp), %r14
leaq -0x80(%rbp), %r15
shlq $0x5, %r12
movq 0x8(%rsi,%r12), %rdx
testq %rdx, %rdx
jne 0x446b
addq %r12, %rsi
movq %rbx, %rdi
callq 0x693c
movq (%rbx), %rsi
movq 0x8(%rsi,%r12), %rdx
leaq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rsi,%r12), %rsi
addq %rsi, %rdx
movq %r14, %rdi
callq 0x3cbe
movq %r15, %rdi
movq %r14, %rdx
callq 0x3fba
addq (%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x32b0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x44ad
callq 0x3210
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x44bf
callq 0x3210
movl %r13d, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
incl %r13d
cmpq %r12, %rax
ja 0x444a
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 0x4526
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4526
callq 0x32c0
jmp 0x4526
jmp 0x450c
jmp 0x450c
movq %rax, %r14
jmp 0x4526
movq %rax, %r14
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4526
callq 0x3210
movq %rbx, %rdi
callq 0x4b12
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3cbe
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5afd(%rip), %rsi      # 0xa076
leaq 0x5af8(%rip), %rdx      # 0xa078
leaq -0x90(%rbp), %rdi
callq 0x4bc4
leaq -0x30(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
leaq -0x90(%rbp), %rcx
callq 0x43c0
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x45b4
callq 0x3210
movq -0xb0(%rbp), %rdi
cmpq %r14, %rdi
jne 0x45f5
jmp 0x45fa
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x45db
callq 0x3210
jmp 0x45db
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
cmpq %r14, %rdi
je 0x46c9
callq 0x3210
jmp 0x46c9
callq 0x3210
movq -0x28(%rbp), %rax
movq -0x18(%rax), %rdx
testq %rdx, %rdx
jne 0x4621
leaq -0x20(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
movq %rcx, %rax
jne 0x45f5
jmp 0x45fe
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x20(%rax), %rsi
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x3cbe
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x3cbe
leaq -0x70(%rbp), %rdx
movq %rbx, %rdi
callq 0x3fba
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x466f
callq 0x3210
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x467d
callq 0x3210
leaq -0x30(%rbp), %rdi
callq 0x4b12
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 0x46ad
callq 0x3210
jmp 0x46ad
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x46c0
callq 0x3210
jmp 0x46c0
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4b12
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x472e
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 0x471d
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 0x4704
incq %r10
movl %r10d, %r11d
cmpq %r11, %rax
ja 0x46f6
popq %rbx
popq %r14
popq %rbp
jmp 0x4731
xorl %r9d, %r9d
cmpl %edx, %r9d
setge %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x47de
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 0x3cbe
movq -0x38(%rbp), %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x46d2
movl %eax, %r14d
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x47af
callq 0x3210
testb %r14b, %r14b
je 0x47c2
addq (%rbx), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x693c
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 0x4769
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
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x8(%rsi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x483f
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpb $0x2f, (%rdx,%rsi)
sete %dil
addl %edi, %eax
incq %rsi
movl %esi, %edi
cmpq %rdi, %rcx
ja 0x4822
cmpl $0x1, %eax
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 -0x88(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0x3cbe
movq (%r14), %rdi
movq 0x8(%r14), %rax
xorl %r14d, %r14d
testq %rax, %rax
je 0x48a6
xorl %ecx, %ecx
xorl %edx, %edx
cmpb $0x2f, (%rdi,%rcx)
sete %dl
addl %edx, %r14d
incq %rcx
movl %ecx, %edx
cmpq %rdx, %rax
ja 0x4888
cmpl $0x1, %r14d
sete %r14b
cmpq %r15, %rdi
je 0x48b0
callq 0x3210
testb %r14b, %r14b
je 0x494e
leaq -0x68(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x3cbe
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5791(%rip), %rsi      # 0xa074
leaq 0x578b(%rip), %rdx      # 0xa075
leaq -0x58(%rbp), %rdi
callq 0x4bc4
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x43c0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x4912
callq 0x3210
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x4920
callq 0x3210
movq -0x30(%rbp), %rax
subq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
cmpq $0x40, %rax
je 0x4939
movss 0x571f(%rip), %xmm0     # 0xa058
movss %xmm0, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4b12
movss -0x1c(%rbp), %xmm0
jmp 0x4956
movss 0x5702(%rip), %xmm0     # 0xa058
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x497a
callq 0x3210
jmp 0x497a
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x4988
callq 0x3210
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x7a01
pushq %rbp
movq %rsp, %rbp
sarq $0x2, %rcx
movq 0x38(%rdi), %rdx
xorps %xmm0, %xmm0
xorl %esi, %esi
movl (%rax,%rsi,4), %edi
addss (%rdx,%rdi,4), %xmm0
incq %rsi
movl %esi, %edi
cmpq %rdi, %rcx
ja 0x79ed
popq %rbp
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11a3f6
movq %rax, %r14
leaq 0x8(%r12), %r13
cmpq %r13, %rax
jne 0x117f2e
movq %r12, %rdi
movq %r15, %rsi
callq 0x11a37a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x11a882
cmpq %r13, %r14
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
leaq 0x18(%rsp), %r12
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x117e5e
leaq 0x48(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x11b292
addq $0x50, %rbx
cmpq %rbx, %rax
jne 0x11acd5
leaq 0x58(%rsp), %rax
pxor %xmm0, %xmm0
movdqa %xmm0, -0x8(%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x8(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
callq 0x117ef4
movl %eax, %ebp
leaq 0x50(%rsp), %rdi
callq 0x2a2ea4
pxor %xmm0, %xmm0
testb %bpl, %bpl
je 0x11ad2c
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x11a734
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x11a3f6
leaq 0x40(%rax), %rcx
xorl %r14d, %r14d
cmpq %rbx, %rax
cmovneq %rcx, %r14
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x11ad27
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x114090
movq %r14, %xmm0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11ad4f
movq 0x18(%rsp), %rsi
incq %rsi
movq %xmm0, 0x28(%rsp)
callq 0x114090
movq 0x28(%rsp), %xmm0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2a2ea4
jmp 0x11ad8f
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x11ad8f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x114090
jmp 0x11ad8f
jmp 0x11ad8c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11ada6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x114090
movq %rbx, %rdi
callq 0x1142e0
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::get<double>::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, exprtk::type_store<double>::parameter_list)
inline T operator() (std::string& result, parameter_list_t parameters) override
   {
      const auto ptr = scalar_t(parameters[0])();
      const int index = static_cast<int>(scalar_t(parameters[1])());

      assert(ptr != T(0));

      auto& set = *make_set_handle<strgrps_cllctn::set_t>(ptr);

      if (
           (index >= 0) &&
           (static_cast<std::size_t>(index) >= set.size())
         )
      {
         return T(0);
      }

      auto itr = set.begin();
      std::advance(itr,index);
      result = *itr;
      return T(1);
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdx), %rax
movq (%rax), %rcx
movq 0x18(%rax), %rdx
movq (%rcx), %rax
cvttsd2si (%rdx), %ecx
testl %ecx, %ecx
js 0x11b6fd
movl %ecx, %r14d
xorps %xmm0, %xmm0
cmpq %r14, 0x28(%rax)
jbe 0x11b728
movq 0x18(%rax), %rax
testl %ecx, %ecx
je 0x11b711
movq %rax, %rdi
callq 0x114470
decq %r14
jne 0x11b6ee
jmp 0x11b711
movq 0x18(%rax), %rax
movslq %ecx, %r14
movq %rax, %rdi
callq 0x1144e0
incq %r14
jne 0x11b704
addq $0x20, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x114530
movsd 0x187980(%rip), %xmm0   # 0x2a30a8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::erase<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator() (parameter_list_t parameters) override
   {
      auto ptr = scalar_t(parameters[0])();
      assert(ptr != T(0));
      auto& set = *make_set_handle<strgrps_cllctn::set_t>(ptr);
      return process(set,parameters);
   }

// Assembly:
pushq %rax
movq %rsp, %rdx
movq %rsi, (%rdx)
movq (%rsi), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x11b786
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::erase<double>::process(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>>>>&, exprtk::type_store<double>::parameter_list&)
inline T process(strgrps_cllctn::set_t& set, parameter_list_t& parameters)
   {
      std::size_t count = 0;
      for (std::size_t i = 1; i < parameters.size(); ++i)
      {
         count += set.erase(to_str(string_t(parameters[i])));
      }

      return T(count);
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, (%rsp)
movq (%rdx), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
xorpd %xmm0, %xmm0
cmpq $0x2, %rcx
jb 0x11b88a
movq %rsi, %r14
movl $0x1, %ebp
movl $0x20, %r12d
leaq 0x18(%rsp), %r13
xorl %ebx, %ebx
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
addq %rsi, %rdx
movq %r13, %r15
movq %r13, 0x8(%rsp)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x117e5e
movq %r14, %rdi
movq %r13, %rsi
callq 0x11b8bc
movq 0x28(%r14), %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x11b970
addq %r13, %rbx
subq 0x28(%r14), %rbx
movq 0x8(%rsp), %rdi
movq %r15, %r13
cmpq %r15, %rdi
je 0x11b836
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x114090
incq %rbp
movq (%rsp), %rax
movq (%rax), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
addq $0x18, %r12
cmpq %rcx, %rbp
jb 0x11b7da
movq %rbx, %xmm1
punpckldq 0x1877aa(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1877b2(%rip), %xmm1   # 0x2a3030
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x11b8b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x114090
movq %rbx, %rdi
callq 0x1142e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yayuntian[P]user_agent/test_ua.cpp
// Function: BenchmarkUserAgent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void BenchmarkUserAgent(string str, int loop) {

    printf("loop cout: %u\n", loop);
    int i;
    struct timeval start, end;
    UserAgent ua;

    gettimeofday(&start, NULL);
    for (i = 0; i < loop; i++) {
        Parse(ua, str, str.size());
        if (i == 0) echo_ua(ua);
    }
    gettimeofday(&end, NULL);

    long time_cost = ((end.tv_sec - start.tv_sec) * 1000000 + \
            end.tv_usec - start.tv_usec);
    printf("cost time: %ld us, %.2f pps\n", time_cost, loop / (time_cost * 1.0) * 1000000);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movl %esi, %ebx
movq %rdi, %r14
leaq 0x25481(%rip), %rdi     # 0x313c5
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x6070
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, -0x8(%rax)
movb %r13b, (%rax)
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, -0x8(%rax)
movb %r13b, (%rax)
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, -0x8(%rax)
movb %r13b, (%rax)
leaq 0xb0(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, -0x8(%rax)
movb %r13b, (%rax)
leaq 0xd0(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, -0x8(%rax)
movb %r13b, (%rax)
leaq 0xf0(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, -0x8(%rax)
movb %r13b, (%rax)
leaq 0x110(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, -0x8(%rax)
movb %r13b, (%rax)
leaq 0x130(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, -0x8(%rax)
movb %r13b, (%rax)
leaq 0x150(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, -0x8(%rax)
movb %r13b, (%rax)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x6590
testl %ebx, %ebx
jle 0xc060
leaq 0x10(%rsp), %rbp
movq %rsp, %r15
leaq 0x40(%rsp), %r12
movq %rbp, (%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xc5fa
movl 0x8(%r14), %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0xcd6e
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0xc04b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6340
testl %r13d, %r13d
jne 0xc058
movq %r12, %rdi
callq 0xcf59
incl %r13d
cmpl %r13d, %ebx
jne 0xc010
leaq 0x30(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x6590
movq (%r14), %rax
subq 0x20(%rsp), %rax
imulq $0xf4240, %rax, %rsi    # imm = 0xF4240
addq 0x8(%r14), %rsi
subq 0x28(%rsp), %rsi
cvtsi2sd %ebx, %xmm0
cvtsi2sd %rsi, %xmm1
divsd %xmm1, %xmm0
mulsd 0x20f6c(%rip), %xmm0    # 0x2d008
leaq 0x25331(%rip), %rdi     # 0x313d4
movb $0x1, %al
callq 0x6070
leaq 0x40(%rsp), %rdi
callq 0xc4f2
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0xc0e4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6340
jmp 0xc0e4
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xc4f2
movq %rbx, %rdi
callq 0x6630
// File: /workspace/github_cpp_makefile_star2_O3/yayuntian[P]user_agent/userAgent.cpp
// Function: getSubStr(char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void getSubStr(char *sub, const string ua, int start, int end) {
    size_t len = end - start;
    if (len > 0) {
        const char *p = ua.c_str();
        strncpy(sub, p + start, len);
    }
}

// Assembly:
subl %edx, %ecx
jne 0xc969
retq
movslq %edx, %rax
addq (%rsi), %rax
movslq %ecx, %rdx
movq %rax, %rsi
jmp 0x61d0