LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/plugin/service_info.h
// Function: Boss::Private::ServiceInfo<Boss::ILocalServiceInfo, true>::AddCoClassIds(Boss::RefObjPtr<Boss::IEnum>)
void AddCoClassIds(RefObjPtr<IEnum> coClassIds)
      {
        if (!coClassIds.Get())
          return;
        if (!CoClassIds.Get())
          CoClassIds = Base<Enum>::Create();
        coClassIds->Reset();
        for (RefObjPtr<IBase> i ; coClassIds->Next(i.GetPPtr()) == Status::Ok ; i.Release())
          CoClassIds->AddItem(i);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1def8
movq %rsi, %rbx
cmpq $0x0, 0x18(%r14)
jne 0x1de76
movq %rsp, %rdi
callq 0x1e282
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x1de6b
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rsp), %rax
movq %rax, 0x18(%r14)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rsp, %r15
leaq 0x8(%rsp), %r12
movq $0x0, (%rsp)
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x28(%rax)
testl %eax, %eax
jne 0x1dee9
movq 0x18(%r14), %r13
movq (%rsp), %rdi
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x1deb4
movq (%rdi), %rax
callq *0x10(%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x2414e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1decf
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1de84
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1de84
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1def8
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1df52
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x1df52
jmp 0x1df5a
jmp 0x1df5a
jmp 0x1df5a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1df33
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x1df43
jmp 0x1df5a
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1df52
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xd47f0
movq %rax, %rdi
callq 0x1e4f5
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/xml_property_bag.h
// Function: Boss::XmlPropertyBag::GetProperty(char const*, Boss::IBase**) const
virtual RetCode BOSS_CALL GetProperty(char const *name, IBase **value) const
    {
      if (!name || !*name || !value || *value)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        auto Iter = Props.find(name);
        if (Iter == std::end(Props))
          return Status::NotFound;
        return Iter->second.QueryInterface(value);
      }
      catch (...)
      {
        return Status::Fail;
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x5, %ebp
testq %rsi, %rsi
je 0x1f4fc
movq %rdx, %r14
testq %rdx, %rdx
je 0x1f4fc
movq %rsi, %r12
cmpb $0x0, (%rsi)
je 0x1f4fc
cmpq $0x0, (%r14)
jne 0x1f4fc
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x19620
testl %eax, %eax
jne 0x1f50d
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r12, %rdi
callq 0x192e0
leaq (%rax,%r12), %rdx
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1ff5e
addq $0x48, %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2022a
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1f4c8
callq 0x29fe0
testq %r15, %r15
je 0x1f4e8
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x1f4ef
movq (%rdi), %rax
movl $0x2cc77d66, %esi       # imm = 0x2CC77D66
movq %r14, %rdx
callq *0x20(%rax)
movl %eax, %ebp
jmp 0x1f4f4
movl $0x3, %ebp
jmp 0x1f4f4
movl $0x2, %ebp
movq %rbx, %rdi
callq 0x19680
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1b2b1
jmp 0x1f52a
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1f52d
callq 0x29fe0
jmp 0x1f52d
movq %rax, %r14
movq %rbx, %rdi
callq 0x19680
jmp 0x1f53a
movq %rax, %r14
movq %r14, %rdi
callq 0x2a440
callq 0x2a4b0
movl $0x2, %ebp
jmp 0x1f4fc
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/xml_property_bag.h
// Function: Boss::XmlPropertyBag::SetProperty(char const*, Boss::IBase*)
virtual RetCode BOSS_CALL SetProperty(char const *name, IBase *value)
    {
      if (!name || !*name || !value)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        Props[name] = value;
        return Status::Ok;
      }
      catch (...)
      {
        return Status::Fail;
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl $0x5, %eax
testq %rsi, %rsi
je 0x1f5da
movq %rdx, %r14
testq %rdx, %rdx
je 0x1f5da
movq %rsi, %r12
cmpb $0x0, (%rsi)
je 0x1f5da
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x19620
testl %eax, %eax
jne 0x1f5e8
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r12, %rdi
callq 0x192e0
leaq (%rax,%r12), %rdx
movq %rsp, %rdi
movq %r12, %rsi
callq 0x1ff5e
addq $0x48, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x2037e
movq %rax, %rdi
movq %r14, %rsi
callq 0x20342
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1f5d0
callq 0x29fe0
movq %rbx, %rdi
callq 0x19680
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x1b2b1
movq %rax, %r14
jmp 0x1f60a
movq %rax, %r14
jmp 0x1f612
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1f60a
callq 0x29fe0
movq %rbx, %rdi
callq 0x19680
movq %r14, %rdi
callq 0x2a440
callq 0x2a4b0
movl $0x2, %eax
jmp 0x1f5da
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/xml_property_bag.h
// Function: Boss::XmlPropertyBag::EnumProperties(Boss::IEnum**)
virtual RetCode BOSS_CALL EnumProperties(IEnum **props)
    {
      if (!props || *props)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        auto PropEnum = Base<Enum>::Create();
        for (auto &prop : Props)
          PropEnum->AddItem(Base<NamedValue>::Create(prop.first, prop.second));
        return PropEnum.QueryInterface(props);
      }
      catch (...)
      {
        return Status::Fail;
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x5, %ebp
testq %rsi, %rsi
je 0x1f6f9
movq %rsi, %r14
cmpq $0x0, (%rsi)
jne 0x1f6f9
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x19620
testl %eax, %eax
jne 0x1f70a
leaq 0x10(%rsp), %rdi
callq 0x1e282
movq 0x58(%r15), %r13
testq %r13, %r13
je 0x1f6c0
leaq 0x8(%rsp), %r15
leaq 0x8(%r13), %rsi
movq 0x10(%rsp), %r12
leaq 0x28(%r13), %rdx
movq %r15, %rdi
callq 0x20726
movq %r12, %rdi
movq %r15, %rsi
callq 0x2068e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1f6ae
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x8(%rsp)
movq (%r13), %r13
testq %r13, %r13
jne 0x1f67e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1f6ec
movq (%rdi), %rax
movl $0xe2cd2d56, %esi       # imm = 0xE2CD2D56
movq %r14, %rdx
callq *0x28(%rax)
movl %eax, %ebp
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1f6f1
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x1f6f1
movl $0x2, %ebp
movq %rbx, %rdi
callq 0x19680
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1b2b1
jmp 0x1f71f
jmp 0x1f727
movq %rax, %r14
jmp 0x1f758
movq %rax, %r14
jmp 0x1f760
movq %rax, %rdi
callq 0x1e4f5
movq %rax, %r14
jmp 0x1f748
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1f73f
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1f758
movq (%rdi), %rax
callq *0x20(%rax)
movq %rbx, %rdi
callq 0x19680
movq %r14, %rdi
callq 0x2a440
callq 0x2a4b0
movl $0x2, %ebp
jmp 0x1f6f9
jmp 0x1f71f
jmp 0x1f71f
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml.hpp
// Function: rapidxml::memory_pool<char>::allocate_node(rapidxml::node_type, char const*, char const*, unsigned long, unsigned long)
xml_node<Ch> *allocate_node(node_type type, 
                                    const Ch *name = 0, const Ch *value = 0, 
                                    std::size_t name_size = 0, std::size_t value_size = 0)
        {
            void *memory = allocate_aligned(sizeof(xml_node<Ch>));
            xml_node<Ch> *node = new(memory) xml_node<Ch>(type);
            if (name)
            {
                if (name_size > 0)
                    node->name(name, name_size);
                else
                    node->name(name);
            }
            if (value)
            {
                if (value_size > 0)
                    node->value(value, value_size);
                else
                    node->value(value);
            }
            return node;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r14
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movl $0x60, %esi
callq 0x2379e
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ebp, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rcx, 0x40(%rax)
testq %r15, %r15
je 0x233ba
testq %r12, %r12
jne 0x233b3
movq $-0x1, %rcx
leaq 0x1(%rcx), %r12
cmpb $0x0, 0x1(%r15,%rcx)
movq %r12, %rcx
jne 0x233a4
movq %r15, (%rax)
movq %r12, 0x10(%rax)
testq %rbx, %rbx
je 0x233e1
testq %r14, %r14
jne 0x233d9
movq $-0x1, %rcx
leaq 0x1(%rcx), %r14
cmpb $0x0, 0x1(%rbx,%rcx)
movq %r14, %rcx
jne 0x233cb
movq %rbx, 0x8(%rax)
movq %r14, 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml.hpp
// Function: rapidxml::memory_pool<char>::allocate_attribute(char const*, char const*, unsigned long, unsigned long)
xml_attribute<Ch> *allocate_attribute(const Ch *name = 0, const Ch *value = 0, 
                                              std::size_t name_size = 0, std::size_t value_size = 0)
        {
            void *memory = allocate_aligned(sizeof(xml_attribute<Ch>));
            xml_attribute<Ch> *attribute = new(memory) xml_attribute<Ch>;
            if (name)
            {
                if (name_size > 0)
                    attribute->name(name, name_size);
                else
                    attribute->name(name);
            }
            if (value)
            {
                if (value_size > 0)
                    attribute->value(value, value_size);
                else
                    attribute->value(value);
            }
            return attribute;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movl $0x38, %esi
callq 0x2379e
movq $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
testq %r15, %r15
je 0x238af
testq %r12, %r12
jne 0x238a8
movq $-0x1, %rcx
leaq 0x1(%rcx), %r12
cmpb $0x0, 0x1(%r15,%rcx)
movq %r12, %rcx
jne 0x23899
movq %r15, (%rax)
movq %r12, 0x10(%rax)
testq %rbx, %rbx
je 0x238d6
testq %r14, %r14
jne 0x238ce
movq $-0x1, %rcx
leaq 0x1(%rcx), %r14
cmpb $0x0, 0x1(%rbx,%rcx)
movq %r14, %rcx
jne 0x238c0
movq %rbx, 0x8(%rax)
movq %r14, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml.hpp
// Function: rapidxml::memory_pool<char>::allocate_string(char const*, unsigned long)
Ch *allocate_string(const Ch *source = 0, std::size_t size = 0)
        {
            assert(source || size);     // Either source or size (or both) must be specified
            if (size == 0)
                size = internal::measure(source) + 1;
            Ch *result = static_cast<Ch *>(allocate_aligned(size * sizeof(Ch)));
            if (source)
                for (std::size_t i = 0; i < size; ++i)
                    result[i] = source[i];
            return result;
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
orq %rdx, %rax
je 0x24edd
movq %rdx, %r14
movq %rsi, %rbx
testq %rdx, %rdx
jne 0x24eae
xorl %eax, %eax
leaq 0x1(%rax), %r14
cmpb $0x0, (%rbx,%rax)
movq %r14, %rax
jne 0x24ea1
testq %rbx, %rbx
sete %bpl
movq %r14, %rsi
callq 0x2379e
testq %r14, %r14
sete %cl
orb %bpl, %cl
jne 0x24ed8
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0x24eca
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb2a09(%rip), %rdi     # 0xd78ed
leaq 0xb25ed(%rip), %rsi     # 0xd74d8
leaq 0xb2a0a(%rip), %rcx     # 0xd78fc
movl $0x1de, %edx            # imm = 0x1DE
callq 0x19150
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/common/xml_property_bag.h
// Function: Boss::XmlPropertyBag::GetString[abi:cxx11](Boss::IString*) const
std::string GetString(IString *str) const
    {
      RefObjPtr<IBuffer> StrBuffer;
      if (str->GetString(IString::AnsiString, StrBuffer.GetPPtr()) != Status::Ok)
        throw std::runtime_error("Failed to get string.");
      UInt StrLen = 0;
      if (StrBuffer->GetSize(&StrLen) != Status::Ok)
        throw std::runtime_error("Failed to get string length.");
      void const *StrData = 0;
      if (StrLen && StrBuffer->GetData(&StrData) != Status::Ok)
        throw std::runtime_error("Failed to get string data.");
      return std::move(std::string(reinterpret_cast<char const *>(StrData), StrLen));
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movq (%rax), %rcx
movq %rax, %rdi
movl $0x1, %esi
callq *0x38(%rcx)
testl %eax, %eax
jne 0x24fe0
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testl %eax, %eax
jne 0x25014
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x24f7c
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0x28(%rax)
testl %eax, %eax
jne 0x25048
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %edx
jmp 0x24f80
xorl %edx, %edx
xorl %esi, %esi
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x1ff5e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rcx
cmpq %r14, %rcx
je 0x24fb5
movq %rcx, (%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x24fbc
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x24fd5
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2a2e0
movq %rax, %r14
leaq 0xb295a(%rip), %rsi     # 0xd794e
movq %rax, %rdi
callq 0x3dae0
leaq 0xf506d(%rip), %rsi     # 0x11a070
leaq 0xf156(%rip), %rdx      # 0x34160
movq %r14, %rdi
callq 0x2b330
jmp 0x2507a
movl $0x10, %edi
callq 0x2a2e0
movq %rax, %r14
leaq 0xb293c(%rip), %rsi     # 0xd7964
movq %rax, %rdi
callq 0x3dae0
leaq 0xf5039(%rip), %rsi     # 0x11a070
leaq 0xf122(%rip), %rdx      # 0x34160
movq %r14, %rdi
callq 0x2b330
jmp 0x2507a
movl $0x10, %edi
callq 0x2a2e0
movq %rax, %r14
leaq 0xb2925(%rip), %rsi     # 0xd7981
movq %rax, %rdi
callq 0x3dae0
leaq 0xf5005(%rip), %rsi     # 0x11a070
leaq 0xf0ee(%rip), %rdx      # 0x34160
movq %r14, %rdi
callq 0x2b330
jmp 0x2507e
jmp 0x2507e
movq %rax, %rbx
movq %r14, %rdi
callq 0x2a340
jmp 0x25096
jmp 0x250ae
jmp 0x25093
jmp 0x25093
jmp 0x25093
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x250a6
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xd47f0
movq %rax, %rdi
callq 0x1e4f5
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml_print.hpp
// Function: std::ostream_iterator<char, char, std::char_traits<char>> rapidxml::internal::print_declaration_node<std::ostream_iterator<char, char, std::char_traits<char>>, char>(std::ostream_iterator<char, char, std::char_traits<char>>, rapidxml::xml_node<char> const*, int, int)
inline OutIt print_declaration_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            // Print declaration start
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'), ++out;
            *out = Ch('?'), ++out;
            *out = Ch('x'), ++out;
            *out = Ch('m'), ++out;
            *out = Ch('l'), ++out;

            // Print attributes
            out = print_attributes(out, node, flags);
            
            // Print declaration end
            *out = Ch('?'), ++out;
            *out = Ch('>'), ++out;
            
            return out;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %bpl
jne 0x2599f
movl %r8d, %r12d
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r14), %rcx
movq %rcx, 0x20(%rsp)
movb $0x9, 0x8(%rsp)
testl %r8d, %r8d
jle 0x25998
movq %r13, 0x28(%rsp)
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x25f82
decl %r12d
jne 0x25979
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r13
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
leaq 0x8(%rsp), %r15
movb $0x3c, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x25f82
movb $0x3f, %r12b
movb %r12b, (%r15)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x25f82
movb $0x78, (%r15)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x25f82
movb $0x6d, (%r15)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x25f82
movb $0x6c, (%r15)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x25f82
movups (%r14), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r13, %rdx
movl %ebp, %ecx
callq 0x25fd3
movups (%r15), %xmm0
movups %xmm0, (%r14)
movb %r12b, (%r15)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x25f82
movb $0x3e, (%r15)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x25f82
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml_print.hpp
// Function: std::ostream_iterator<char, char, std::char_traits<char>> rapidxml::internal::print_comment_node<std::ostream_iterator<char, char, std::char_traits<char>>, char>(std::ostream_iterator<char, char, std::char_traits<char>>, rapidxml::xml_node<char> const*, int, int)
inline OutIt print_comment_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_comment);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'), ++out;
            *out = Ch('!'), ++out;
            *out = Ch('-'), ++out;
            *out = Ch('-'), ++out;
            out = copy_chars(node->value(), node->value() + node->value_size(), out);
            *out = Ch('-'), ++out;
            *out = Ch('-'), ++out;
            *out = Ch('>'), ++out;
            return out;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x4, 0x28(%rdx)
jne 0x25bd1
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %cl
jne 0x25ad3
movl %r8d, %ebp
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r14), %rcx
movq %rcx, 0x20(%rsp)
movb $0x9, 0x7(%rsp)
testl %r8d, %r8d
jle 0x25acc
leaq 0x18(%rsp), %r12
leaq 0x7(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x25f82
decl %ebp
jne 0x25ab3
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
leaq 0x7(%rsp), %r12
movb $0x3c, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x25f82
movb $0x21, (%r12)
leaq 0x7(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x25f82
movb $0x2d, %bpl
movb %bpl, (%r12)
leaq 0x7(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x25f82
movb %bpl, (%r12)
leaq 0x7(%rsp), %rsi
movq %r14, %rdi
callq 0x25f82
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x25b37
movq %r12, %rsi
movq 0x18(%r15), %r12
jmp 0x25b3e
leaq 0xfa9c3(%rip), %rsi     # 0x120501
movq (%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rcx
movq %rcx, 0x10(%rsp)
testq %r12, %r12
je 0x25b77
leaq 0x8(%rsp), %r15
leaq 0x1(%rsi), %r13
movq %r15, %rdi
callq 0x25f82
movq %r13, %rsi
decq %r12
jne 0x25b59
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
movb $0x2d, %bpl
leaq 0x7(%rsp), %r15
movb %bpl, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x25f82
movb %bpl, (%r15)
leaq 0x7(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x25f82
movb $0x3e, (%r15)
leaq 0x7(%rsp), %rsi
movq %r14, %rdi
callq 0x25f82
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb1fb7(%rip), %rdi     # 0xd7b8f
leaq 0xb1dbf(%rip), %rsi     # 0xd799e
leaq 0xb1fc6(%rip), %rcx     # 0xd7bac
movl $0x163, %edx            # imm = 0x163
callq 0x19150
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/other/rapidxml-1.13/rapidxml_print.hpp
// Function: std::ostream_iterator<char, char, std::char_traits<char>> rapidxml::internal::print_pi_node<std::ostream_iterator<char, char, std::char_traits<char>>, char>(std::ostream_iterator<char, char, std::char_traits<char>>, rapidxml::xml_node<char> const*, int, int)
inline OutIt print_pi_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_pi);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'), ++out;
            *out = Ch('?'), ++out;
            out = copy_chars(node->name(), node->name() + node->name_size(), out);
            *out = Ch(' '), ++out;
            out = copy_chars(node->value(), node->value() + node->value_size(), out);
            *out = Ch('?'), ++out;
            *out = Ch('>'), ++out;
            return out;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x7, 0x28(%rdx)
jne 0x25f62
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %cl
jne 0x25e3c
movl %r8d, %ebp
movq (%r14), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%r14), %rcx
movq %rcx, 0x30(%rsp)
movb $0x9, 0x7(%rsp)
testl %r8d, %r8d
jle 0x25e35
leaq 0x28(%rsp), %r12
leaq 0x7(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x25f82
decl %ebp
jne 0x25e1c
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
leaq 0x7(%rsp), %r12
movb $0x3c, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x25f82
movb $0x3f, (%r12)
leaq 0x7(%rsp), %rsi
movq %r14, %rdi
callq 0x25f82
movq (%r15), %r13
testq %r13, %r13
je 0x25e74
movq %r13, %rsi
movq 0x10(%r15), %r13
jmp 0x25e7b
leaq 0xfa686(%rip), %rsi     # 0x120501
movq (%r14), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%r14), %rcx
movq %rcx, 0x20(%rsp)
testq %r13, %r13
je 0x25eb4
leaq 0x18(%rsp), %r12
leaq 0x1(%rsi), %rbp
movq %r12, %rdi
callq 0x25f82
movq %rbp, %rsi
decq %r13
jne 0x25e96
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movq %r14, %rdi
callq 0x25f82
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x25edd
movq %r12, %rsi
movq 0x18(%r15), %r12
jmp 0x25ee4
leaq 0xfa61d(%rip), %rsi     # 0x120501
movq (%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rcx
movq %rcx, 0x10(%rsp)
testq %r12, %r12
je 0x25f1d
leaq 0x8(%rsp), %r15
leaq 0x1(%rsi), %r13
movq %r15, %rdi
callq 0x25f82
movq %r13, %rsi
decq %r12
jne 0x25eff
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
leaq 0x7(%rsp), %r15
movb $0x3f, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x25f82
movb $0x3e, (%r15)
leaq 0x7(%rsp), %rsi
movq %r14, %rdi
callq 0x25f82
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb1d6a(%rip), %rdi     # 0xd7cd3
leaq 0xb1a2e(%rip), %rsi     # 0xd799e
leaq 0xb1d74(%rip), %rcx     # 0xd7ceb
movl $0x18b, %edx            # imm = 0x18B
callq 0x19150
nop
// File: /workspace/github_cpp_makefile_star2_O3/tdv[P]boss/boss/include/plugin/module_holder.h
// Function: Boss::ModuleHolder::GetServiceId() const
ServiceId const GetServiceId() const
    {
      typedef RetCode (*PFNBossGetServiceId)(ServiceId *);
      auto *BossGetServiceId = Dll.GetProc<PFNBossGetServiceId>("BossGetServiceId");
      ServiceId SrvId = 0;
      if (BossGetServiceId(&SrvId) != Status::Ok)
        throw ModuleHolderException("Failed to call BossGetServiceId.");
      return SrvId;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xb0ed6(%rip), %rsi     # 0xd8e42
leaq 0xb0edf(%rip), %rdx     # 0xd8e52
leaq 0x8(%rsp), %rdi
callq 0x1ff5e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x283a6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x27f9c
callq 0x29fe0
leaq 0x8(%rsp), %rdi
movl $0x0, (%rdi)
callq *%rbx
testl %eax, %eax
jne 0x27fb9
movl 0x8(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2a2e0
movq %rax, %r14
leaq 0xb0e86(%rip), %rsi     # 0xd8e53
movq %rax, %rdi
callq 0x28508
leaq 0xf1174(%rip), %rsi     # 0x119150
leaq 0xc17d(%rip), %rdx      # 0x34160
movq %r14, %rdi
callq 0x2b330
movq %rax, %rbx
movq %r14, %rdi
callq 0x2a340
jmp 0x2800f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2800f
callq 0x29fe0
jmp 0x2800f
movq %rax, %rbx
movq %rbx, %rdi
callq 0xd47f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/khashpp/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	klib::KHash<aux_t, aux_hash, aux_eq> h;
	for (i = 0, x = x0; i < n; ++i) {
		aux_t a;
		size_t k;
		int absent;
		x = hash32(x);
		a.key = get_key(n, x), a.cnt = 0;
		k = h.put(a, &absent);
		z += ++h.at(k).cnt;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r12d
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
xorl %esi, %esi
movl $0x0, %ebx
testl %edi, %edi
je 0x1664
movl %edi, %ebp
movl %edi, %r14d
shrl $0x2, %r14d
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x34(%rsp), %r13
movl %r12d, %eax
shll $0xf, %eax
notl %eax
addl %r12d, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %r12d
shrl $0x10, %r12d
xorl %eax, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl %r14d
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
xorl %eax, %ecx
movl %ecx, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x16aa
movq 0x28(%rsp), %rcx
movl %eax, %eax
movl 0x4(%rcx,%rax,8), %edx
leal 0x1(%rdx), %esi
movl %esi, 0x4(%rcx,%rax,8)
addl %edx, %ebx
incl %ebx
decl %ebp
jne 0x15c5
movl 0x14(%rsp), %esi
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %r14
movl %ebx, %edx
movq %r14, %rcx
callq 0x13d8
movl (%r14), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
callq 0x1070
movq 0x28(%rsp), %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/qmmlib[P]QmmLibrary/predict.c
// Function: main
int main(int argc, char **argv)
{
	FILE *input, *output;
	int i;

	// parse options
	for(i=1;i<argc;i++)
	{
		if(argv[i][0] != '-') break;
		++i;
		switch(argv[i-1][1])
		{
			case 'b':
				flag_predict_probability = atoi(argv[i]);
				break;

			default:
				fprintf(stderr,"unknown option: -%c\n", argv[i-1][1]);
				exit_with_help();
				break;
		}
	}
	if(i>=argc)
		exit_with_help();

	input = fopen(argv[i],"r");
	if(input == NULL)
	{
		fprintf(stderr,"can't open input file %s\n",argv[i]);
		exit(1);
	}

	output = fopen(argv[i+2],"w");
	if(output == NULL)
	{
		fprintf(stderr,"can't open output file %s\n",argv[i+2]);
		exit(1);
	}

	if((model_=load_model(argv[i+1]))==0)
	{
		fprintf(stderr,"can't open model file %s\n",argv[i+1]);
		exit(1);
	}

	x = (struct feature_node *) malloc(max_nr_attr*sizeof(struct feature_node));
	do_predict(input, output);
	free_and_destroy_model(&model_);
	free(line);
	free(x);
	fclose(input);
	fclose(output);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x41c1
movq %rsi, %rbx
movl %edi, %ebp
movl $0x1, %r14d
movq (%rbx,%r14,8), %rax
cmpb $0x2d, (%rax)
jne 0x41d7
movb 0x1(%rax), %al
cmpb $0x62, %al
jne 0x428d
movq 0x8(%rbx,%r14,8), %rdi
callq 0x3320
movl %eax, 0x18098(%rip)     # 0x1c250
addq $0x2, %r14
cmpl %ebp, %r14d
jl 0x4194
leaq 0x12fa3(%rip), %rdi     # 0x1716b
callq 0x3310
movl $0x1, %edi
callq 0x3260
movl %r14d, %eax
leaq (%rbx,%rax,8), %r15
movq (%r15), %rdi
leaq 0x12f30(%rip), %rsi     # 0x17118
callq 0x3240
testq %rax, %rax
je 0x4295
movq %rax, %rbx
movq 0x10(%r15), %rdi
leaq 0x12f30(%rip), %rsi     # 0x17134
callq 0x3240
testq %rax, %rax
je 0x429d
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0x141f1
movq %rax, 0x18023(%rip)     # 0x1c248
testq %rax, %rax
je 0x42a9
movslq 0x17fef(%rip), %rdi     # 0x1c220
shlq $0x4, %rdi
callq 0x32b0
movq %rax, 0x17fff(%rip)     # 0x1c240
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b21
leaq 0x17ff5(%rip), %rdi     # 0x1c248
callq 0x13aeb
movq 0x17ff9(%rip), %rdi     # 0x1c258
callq 0x3250
movq 0x17fd5(%rip), %rdi     # 0x1c240
callq 0x3250
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x31c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %al, %edi
callq 0x355e
movq %r15, %rdi
callq 0x3537
addq $0x10, %r15
movq %r15, %rdi
callq 0x3510
addq $0x8, %r15
movq %r15, %rdi
callq 0x34e9
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/maxgodfrey2004[P]gss/main.cc
// Function: cli::CheckArgv(char**, char**)
void CheckArgv(char **arg_start, char **arg_end) {
  if (HasOption(arg_start, arg_end, "-h") ||
      HasOption(arg_start, arg_end, "--help") ||
      arg_end - arg_start == 1) {
    PrintHelpUtil();
    exit(EXIT_SUCCESS);
  }
  if (arg_end - arg_start != 3) {
    std::cerr << "ERROR: incorrect number of arguments.\n"
              << "Execute `gss --help` for more info."
              << std::endl;
    exit(EXIT_FAILURE);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1bd3(%rip), %rsi      # 0x4004
leaq 0x1bce(%rip), %rdx      # 0x4006
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x2964
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x27d5
movb $0x1, %bpl
cmpq %rbx, %rax
jne 0x24bb
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1b9c(%rip), %rsi      # 0x4007
leaq 0x1b9b(%rip), %rdx      # 0x400d
leaq 0x8(%rsp), %rdi
callq 0x2964
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27d5
cmpq %rbx, %rax
setne %r13b
movq %rbx, %rax
subq %r14, %rax
cmpq $0x8, %rax
sete %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x24b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
orb %r13b, %bpl
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x24d2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
testb %bpl, %bpl
jne 0x24ef
subq %r14, %rbx
cmpq $0x18, %rbx
jne 0x24fb
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2755
xorl %edi, %edi
callq 0x2170
movq 0x3aee(%rip), %rdi      # 0x5ff0
leaq 0x1b05(%rip), %rsi      # 0x400e
callq 0x2130
leaq 0x1b20(%rip), %rsi      # 0x4035
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
movl $0x1, %edi
callq 0x2170
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2550
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x2550
jmp 0x254d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x2567
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/maxgodfrey2004[P]gss/main.cc
// Function: main
int main(int argc, char *argv[]) {
  // Optimize std::cout - this will (hopefully) help us run faster than grep.
  std::ios::sync_with_stdio(false);
  std::cout.tie(nullptr);

  cli::CheckArgv(argv, argv + argc);

  std::string filename(argv[1]);
  std::string search_pattern(argv[2]);
  gss::fileutils::Match(filename, search_pattern);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movl %edi, %ebp
xorl %edi, %edi
callq 0x2070
movq 0x3a41(%rip), %rax      # 0x5fd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x0, 0xd8(%rax,%rcx)
movslq %ebp, %rax
leaq (%rbx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x240c
movq 0x8(%rbx), %rsi
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2718
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2718
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x28ce
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x28ce
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x29fc
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x263d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x2654
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x266f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x268a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2150
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x26b9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x26b9
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x26d5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x26d5
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26f5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x26f5
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2710
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/maxgodfrey2004[P]gss/src/kmp.cc
// Function: gss::kmp::ComputePrefix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<int> ComputePrefix(std::string search) {
  std::vector<int> prefix_vals(search.length());
  prefix_vals[0] = 0;
  int current_prefix = 0;

  for (int i = 1; i < static_cast<int>(search.length()); ++i) {
    // Jump by prefix values to try smaller prefixes. This process stops when
    // we either find a match, or reach zero.
    while (current_prefix > 0 && search[i] != search[current_prefix]) {
      current_prefix = prefix_vals[current_prefix - 1];
    }
    if (search[i] == search[current_prefix]) {
      ++current_prefix;
    }
    prefix_vals[i] = current_prefix;
  }

  return prefix_vals;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x7(%rsp), %rdx
callq 0x30ca
movq (%rbx), %rax
movl $0x0, (%rax)
movq 0x8(%r14), %rcx
cmpl $0x2, %ecx
jl 0x2ef6
movq (%r14), %rdx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edi, %edi
movl $0x1, %esi
movb (%rdx,%rsi), %r8b
testl %edi, %edi
jle 0x2eda
movl %edi, %r9d
cmpb (%rdx,%r9), %r8b
je 0x2eda
movl -0x4(%rax,%r9,4), %edi
jmp 0x2ec6
movslq %edi, %rdi
xorl %r9d, %r9d
cmpb (%rdx,%rdi), %r8b
sete %r9b
addl %r9d, %edi
movl %edi, (%rax,%rsi,4)
incq %rsi
cmpq %rcx, %rsi
jne 0x2ec2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_maze_generator.cpp
// Function: shuffle<double>::shuffle()
shuffle()
   : exprtk::igeneric_function<T>("V")
   {
      std::random_device device;
      std::array<unsigned int,std::mt19937::state_size> seed;
      std::generate_n(seed.data(), seed.size(), std::ref(device));
      std::seed_seq seq(std::begin(seed), std::end(seed));
      generator.seed(seq);
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d68, %rsp           # imm = 0x1D68
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x198666(%rip), %rsi    # 0x2b4a6e
leaq 0x198660(%rip), %rdx    # 0x2b4a6f
leaq 0x20(%rsp), %rdi
callq 0x11c22c
movw $0x100, 0x8(%rbx)       # imm = 0x100
movq $0x0, 0x10(%rbx)
movq $-0x1, 0x18(%rbx)
leaq 0x29121a(%rip), %r13    # 0x3ad650
movq %r13, (%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %r12
movq %r12, 0x20(%rbx)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
callq 0x11eb86
movl $0x0, 0x40(%rbx)
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x11c475
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x117090
leaq 0x291144(%rip), %rax    # 0x3ad5c0
movq %rax, (%rbx)
leaq 0x48(%rbx), %r14
movq $0x1571, 0x48(%rbx)     # imm = 0x1571
movl $0x1571, %ecx           # imm = 0x1571
movl $0xa, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0x9, %ecx
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq $0x279, %rax            # imm = 0x279
jne 0x11c495
movq $0x270, 0x13c8(%rbx) # imm = 0x270
xorps %xmm0, %xmm0
movhps 0x192c03(%rip), %xmm0   # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, 0x13d0(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x11e948
xorl %ebp, %ebp
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x117140
movl %eax, 0x13a8(%rsp,%rbp,4)
incq %rbp
cmpq $0x270, %rbp            # imm = 0x270
jne 0x11c4e5
leaq 0x1d68(%rsp), %rdx
leaq 0x8(%rsp), %rdi
leaq 0x13a8(%rsp), %rsi
callq 0x11e9c2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x11ea58
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x11c53e
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x117090
leaq 0x20(%rsp), %rdi
callq 0x117110
addq $0x1d68, %rsp           # imm = 0x1D68
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11c5c5
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x11c59b
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x117090
jmp 0x11c59b
jmp 0x11c598
movq %rax, %r14
jmp 0x11c5a5
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x11c5bd
movq 0x30(%rsp), %rsi
jmp 0x11c5b5
movq %rax, %r14
jmp 0x11c5bd
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x117110
movq %r13, (%rbx)
movq 0x20(%rbx), %rdi
cmpq %r12, %rdi
je 0x11c5bd
movq (%r12), %rsi
incq %rsi
callq 0x117090
movq %r14, %rdi
callq 0x117300
movq %rax, %rdi
callq 0x11c220
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/src/CPU.cc
// Function: CPU::~CPU()
CPU::~CPU() {
  // Free up Mapped Opcode Execute Methods
  for (auto key: this->oMap) {
    delete key.second;
  }
  for (auto key: this->pMap) {
    delete key.second;
  }
  delete this->ppu;
  cpuExecDump.close();

  // Clean up Debug Data
  for (auto &p : this->instr_iters) {
    delete p.second;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8(%rdi), %r15
testq %r15, %r15
je 0x2fe81
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x2fe6f
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x2fe57
leaq 0x30(%r14), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x2fe6f
movq (%rax), %rsi
incq %rsi
callq 0xc0d0
movl $0x50, %esi
movq %r14, %rdi
callq 0xc0d0
movq (%r15), %r15
jmp 0x2fe32
movq 0xf0(%rbx), %r15
testq %r15, %r15
je 0x2fed7
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x2fec5
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x2fead
leaq 0x30(%r14), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x2fec5
movq (%rax), %rsi
incq %rsi
callq 0xc0d0
movl $0x50, %esi
movq %r14, %rdi
callq 0xc0d0
movq (%r15), %r15
jmp 0x2fe88
movq (%rbx), %rdi
movl $0x28, %esi
callq 0xc0d0
leaq 0x10158(%rbx), %rdi
callq 0xc7a0
movq 0x80(%rbx), %r14
testq %r14, %r14
je 0x2ff0f
movq 0x10(%r14), %rdi
movl $0x10, %esi
callq 0xc0d0
movq (%r14), %r14
jmp 0x2fef7
movq 0xc6fc2(%rip), %rax     # 0xf6ed8
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x10158(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x10158(%rbx,%rcx)
leaq 0x10160(%rbx), %rdi
callq 0xc550
leaq 0x10250(%rbx), %rdi
callq 0xc5e0
movq 0x138(%rbx), %rdi
testq %rdi, %rdi
je 0x2ff63
movq 0x148(%rbx), %rsi
subq %rdi, %rsi
callq 0xc0d0
leaq 0x70(%rbx), %r14
leaq 0xe0(%rbx), %rdi
leaq 0xa8(%rbx), %r15
callq 0x3a0cc
movq %r15, %rdi
callq 0x3a0cc
movq %r14, %rdi
callq 0x3a154
addq $0x10, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x39d70
jmp 0x2ffa4
jmp 0x2ffa4
movq %rax, %rdi
callq 0x39dbe
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/src/CPU.cc
// Function: CPU::tick()
void CPU::tick() {
  if (!halted)
    ppu->execute();
  else
    handleInterrupt();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x12a(%rdi)
je 0x2ffbf
popq %rbp
jmp 0x2ffc8
movq (%rdi), %rdi
popq %rbp
jmp 0x3ce40
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/src/CPU.cc
// Function: CPU::handleInterrupt()
void CPU::handleInterrupt() {
  if (this->IME) {
    std::cout << "CPU INTERRUPTED!\n";

    // Memory Registers Required
    uint8_t IE = this->memory.read(0xFFFF);
    uint8_t IF = this->memory.read(0xFF0F);
    uint8_t IH = (IE & IF) & 0x1F;

    // Least Significant bit gets highest priority
    if (IH & 0x01) {          // Bit0: V-Blank
      // Basically CALL without the offset
      this->PUSH(&PC);
      PC = 0x0040;

      // Consume CPU Cycles + 2 (internal timing NOPs)
      cyclesLeft -= 5;
      updateTimers(5);

      // Unset Handled Bit
      IF &= ~0x01;

      // Dispatch Handled
      IME = false;
    } else if (IH & 0x02) {   // Bit1: LCD STAT
      this->PUSH(&PC);
      PC = 0x0048;
      cyclesLeft -= 5;
      updateTimers(5);
      IF &= ~0x02;
      IME = false;
    } else if (IH & 0x04) {   // Bit2: Timer
      this->PUSH(&PC);
      PC = 0x0050;
      cyclesLeft -= 5;
      updateTimers(5);
      IF &= ~0x04;
      IME = false;
    } else if (IH & 0x08) {   // Bit3: Serial
      this->PUSH(&PC);
      PC = 0x0058;
      cyclesLeft -= 5;
      updateTimers(5);
      IF &= ~0x08;
      IME = false;
    } else if (IH & 0x10) {   // Bit4: Joypad
      this->PUSH(&PC);
      PC = 0x0060;
      cyclesLeft -= 5;
      updateTimers(5);
      IF &= ~0x10;
      IME = false;
    }

    // Update IF
    this->memory.write(0xFF0F, IF);
  }

  // Check IME Delayed Enable (EI)
  else if (delayed_IME) {
    delayed_IME = false;
    IME = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x128(%rdi)
jne 0x30056
movq 0xc6eff(%rip), %rdi     # 0xf6ee8
leaq 0x81188(%rip), %rsi     # 0xb1178
movl $0x11, %edx
callq 0xc830
leaq 0x130(%rbx), %r14
movq %r14, %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x3c974
movl %eax, %r12d
movq %r14, %rdi
movl $0xff0f, %esi           # imm = 0xFF0F
callq 0x3c974
movl %eax, %r15d
andb %al, %r12b
testb $0x1, %r12b
jne 0x30077
andb $0x1f, %r12b
testb $0x2, %r12b
jne 0x30081
testb $0x4, %r12b
jne 0x3008b
testb $0x8, %r12b
jne 0x30095
movzbl %r12b, %eax
testl %eax, %eax
je 0x300cf
movb $-0x11, %r12b
movw $0x60, %r13w
jmp 0x3009d
cmpb $0x1, 0x129(%rbx)
jne 0x30068
movw $0x1, 0x128(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $-0x2, %r12b
movw $0x40, %r13w
jmp 0x3009d
movb $-0x3, %r12b
movw $0x48, %r13w
jmp 0x3009d
movb $-0x5, %r12b
movw $0x50, %r13w
jmp 0x3009d
movb $-0x9, %r12b
movw $0x58, %r13w
leaq 0x12c(%rbx), %rsi
movq %rbx, %rdi
callq 0x3bda6
movw %r13w, 0x12c(%rbx)
addl $-0x5, 0x8(%rbx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x31192
andb %r12b, %r15b
movb $0x0, 0x128(%rbx)
movzbl %r15b, %edx
movq %r14, %rdi
movl $0xff0f, %esi           # imm = 0xFF0F
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c980
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/src/CPU.cc
// Function: CPU::updateTimers(unsigned char)
void CPU::updateTimers(uint8_t cyclesPassed) {
  // Keep track of Cycles passed for each of the Timers
  this->timerCycles.div += cyclesPassed;

  // Get TAC Configuration
  uint8_t TAC = this->memory.read(0xFF07);


  if (this->timerCycles.div >= 64) {
    uint8_t DIV = this->memory.read(0xFF04);
    memory.memory[0xFF04] = ++DIV;
    this->timerCycles.div -= 64;
  }



  // TAC-Enabled, Tick TIMA
  // TODO: Figure out what happens if TAC changes interval while TAC enabled.
  if (TAC & (1 << 2)) {
    this->timerCycles.tima += cyclesPassed;
    uint8_t TIMA_OLD = this->memory.read(0xFF05);
    uint8_t TIMA = TIMA_OLD;

    switch (TAC & 0x03) {
      case 0x00:
        if (timerCycles.tima >= 256) {
          TIMA++;
          timerCycles.tima -= 256;
        }
        break;
      case 0x01:
        if (timerCycles.tima >= 4) {
          TIMA++;
          timerCycles.tima -= 4;
        }
        break;
      case 0x10:
        if (timerCycles.tima >= 16) {
          TIMA++;
          timerCycles.tima -= 16;
        }
        break;
      case 0x11:
        if (timerCycles.tima >= 64) {
          TIMA++;
          timerCycles.tima -= 64;
        }
        break;
    }

    // CHECK IF OVERFLOW
    if (TIMA < TIMA_OLD) {
      // Request Timer Interrupt
      uint8_t IF = this->memory.read(0xFF0F);
      this->memory.write(0xFF0F, IF |= 0x04);

      // Set TIMA = TAC
      TIMA = this->memory.read(0xFF06);
    }


    this->memory.write(0xFF05, TIMA);
  }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %r14
addl %esi, 0x120(%rdi)
leaq 0x130(%rdi), %rbx
movq %rbx, %rdi
movl $0xff07, %esi           # imm = 0xFF07
callq 0x3c974
movl %eax, %r12d
cmpl $0x40, 0x120(%r14)
jb 0x311e8
movq %rbx, %rdi
movl $0xff04, %esi           # imm = 0xFF04
callq 0x3c974
incb %al
movb %al, 0x10054(%r14)
addl $-0x40, 0x120(%r14)
testb $0x4, %r12b
jne 0x311f7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl %r12b, %r12d
addl %r15d, 0x124(%r14)
movq %rbx, %rdi
movl $0xff05, %esi           # imm = 0xFF05
callq 0x3c974
andl $0x3, %r12d
cmpl $0x1, %r12d
je 0x31235
testl %r12d, %r12d
jne 0x3127b
movl 0x124(%r14), %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x3127b
addl $0xffffff00, %ecx       # imm = 0xFFFFFF00
jmp 0x31244
movl 0x124(%r14), %ecx
cmpl $0x4, %ecx
jb 0x3127b
addl $-0x4, %ecx
movl %ecx, 0x124(%r14)
incb %al
jne 0x3127b
movq %rbx, %rdi
movl $0xff0f, %esi           # imm = 0xFF0F
callq 0x3c974
orb $0x4, %al
movzbl %al, %edx
movq %rbx, %rdi
movl $0xff0f, %esi           # imm = 0xFF0F
callq 0x3c980
movq %rbx, %rdi
movl $0xff06, %esi           # imm = 0xFF06
callq 0x3c974
movzbl %al, %edx
movq %rbx, %rdi
movl $0xff05, %esi           # imm = 0xFF05
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3c980
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ciaxur[P]yagb-emu/src/Instructions.cc
// Function: CPU::ADC(unsigned char)
void CPU::ADC(uint8_t u8) {                 // ADC A, u8
  uint8_t result = this->reg.A + ((this->reg.F & 0x10) >> 4) + u8;

  // Set Flags
  this->setZeroFlag(result == 0);     // Zero Flag
  this->setAddSubFlag(false);   // Unset N Flag
  this->checkHalfCarry(result, this->reg.A);
  this->checkCarry(this->reg.A, result);

  // Set new A Value
  this->reg.A = result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movzbl 0x11d(%rdi), %eax
btl $0x4, %eax
adcb 0x118(%rdi), %r14b
sete %al
movzbl %al, %esi
callq 0x300ee
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3010a
movzbl 0x118(%rbx), %edx
movzbl %r14b, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3015e
movzbl 0x118(%rbx), %esi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x3018c
movb %r14b, 0x118(%rbx)
popq %rbx
popq %r14
popq %rbp
retq