LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/siolag161[P]louvain-original/main_hierarchy.cpp
// Function: parse_args(int, char**)
void
parse_args(int argc, char **argv) {
  if (argc<2)
    usage(argv[0], "Bad arguments number\n");

  for (int i = 1; i < argc; i++) {
    if(argv[i][0] == '-') {
      switch(argv[i][1]) {
      case 'l':
	display_level = atoi(argv[i+1]);
	i++;
	break;
      case 'n':
	display_level = -1;
	break;
      default:
	usage(argv[0], "Unknown option\n");
      }
    } else {
      if (filename==NULL)
        filename = argv[i];
      else
        usage(argv[0], "More than one filename\n");
    }
  }
  if (filename==NULL)
    usage(argv[0], "No input file has been provided.\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x2, %edi
jl 0x14ab
movl %edi, %ebp
movl $0x1, %r15d
movq 0x2ce3(%rip), %r14      # 0x4108
movslq %r15d, %rax
movq (%rbx,%rax,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x1455
movzbl 0x1(%rcx), %ecx
cmpl $0x6e, %ecx
je 0x1466
cmpl $0x6c, %ecx
jne 0x149c
leal 0x1(%rax), %r15d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1170
movl %eax, 0x2c95(%rip)      # 0x40e8
jmp 0x1470
testq %r14, %r14
jne 0x148d
movq %rcx, 0x2ca7(%rip)      # 0x4108
movq %rcx, %r14
jmp 0x1470
movl $0xffffffff, 0x2c78(%rip) # imm = 0xFFFFFFFF
incl %r15d
cmpl %ebp, %r15d
jl 0x1425
cmpq $0x0, 0x2c88(%rip)      # 0x4108
je 0x14ba
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
leaq 0xcef(%rip), %rsi       # 0x2186
callq 0x130c
movq (%rbx), %rdi
leaq 0xcd0(%rip), %rsi       # 0x2176
callq 0x130c
movq (%rbx), %rdi
leaq 0xcab(%rip), %rsi       # 0x2160
callq 0x130c
movq (%rbx), %rdi
leaq 0xcda(%rip), %rsi       # 0x219e
callq 0x130c
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/src/service_registry/service_registry.cpp
// Function: Boss::ServiceRegistry::GetServiceInfo(unsigned int, Boss::IServiceInfo**) const
RetCode BOSS_CALL ServiceRegistry::GetServiceInfo(ClassId clsId, IServiceInfo **info) const
  {
    if (!info || *info)
      return Status::InvalidArgument;
    
    try
    {
      std::lock_guard<std::recursive_mutex> Lock(Mtx);
      auto Iter = Services.find(clsId);
      return Iter != std::end(Services) ? Iter->second.QueryInterface(info) : Status::NotFound;
    }
    catch (...)
    {
    }
    return Status::Fail;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x5, %r15d
testq %rdx, %rdx
je 0x1e40a
movq %rdx, %r14
cmpq $0x0, (%rdx)
jne 0x1e40a
movl %esi, %ebp
movq %rdi, %r12
leaq 0x28(%rdi), %rbx
movq %rbx, %rdi
callq 0x1b620
testl %eax, %eax
jne 0x1e416
movl %ebp, %eax
movq 0x50(%r12), %rsi
movq 0x58(%r12), %rdi
xorl %r9d, %r9d
xorl %edx, %edx
divq %rdi
movq (%rsi,%rdx,8), %rax
testq %rax, %rax
je 0x1e3c7
movq (%rax), %r8
movq %rax, %r9
cmpl %ebp, 0x8(%r8)
je 0x1e3c7
movq %rdx, %rcx
movq %r8, %r10
movq (%r8), %r8
testq %r8, %r8
je 0x1e3c4
movl 0x8(%r8), %esi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movl $0x0, %r9d
cmpq %rcx, %rdx
jne 0x1e3c7
movq %r10, %r9
cmpl %ebp, %esi
jne 0x1e399
jmp 0x1e3c7
xorl %r9d, %r9d
testq %r9, %r9
je 0x1e3d1
movq (%r9), %rax
jmp 0x1e3d3
xorl %eax, %eax
testq %rax, %rax
je 0x1e3f4
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x1e3fc
movq (%rdi), %rax
movl $0x7bd8c883, %esi       # imm = 0x7BD8C883
movq %r14, %rdx
callq *0x20(%rax)
movl %eax, %r15d
jmp 0x1e402
movl $0x3, %r15d
jmp 0x1e402
movl $0x2, %r15d
movq %rbx, %rdi
callq 0x1b680
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1d32d
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b680
jmp 0x1e42d
movq %rax, %r14
movq %r14, %rdi
callq 0x2ccc0
callq 0x2cd30
movl $0x2, %r15d
jmp 0x1e40a
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/src/service_registry/service_registry.cpp
// Function: Boss::ServiceRegistry::DelService(unsigned int)
RetCode BOSS_CALL ServiceRegistry::DelService(ServiceId serviceId)
  {
    try
    {
      std::lock_guard<std::recursive_mutex> Lock(Mtx);
      typedef std::vector<ClassId> ClassIdPool;
      ClassIdPool ClassIds;
      for (auto const &i : Services)
      {
        ServiceId SrvId = 0;
        RetCode Res = i.second->GetServiceId(&SrvId);
        if (Res != Status::Ok)
          return Res;
        ClassIds.push_back(i.first);
      }
      for (auto const &i : ClassIds)
        Services.erase(i);
    }
    catch (...)
    {
      return Status::Fail;
    }
    return Status::Ok;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
addq $0x28, %rdi
movq %rdi, 0x30(%rsp)
callq 0x1b620
testl %eax, %eax
jne 0x1e9be
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x50(%r15), %r14
addq $0x60, %r15
leaq 0xc(%rsp), %r13
movq (%r15), %r15
testq %r15, %r15
je 0x1e96b
movl $0x0, 0xc(%rsp)
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0x28(%rax)
movl %eax, %ebp
movl %eax, %r12d
testl %eax, %eax
jne 0x1e962
leaq 0x8(%r15), %rdx
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x1e955
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
movl %ebx, %r12d
jmp 0x1e962
leaq 0x10(%rsp), %rdi
callq 0x210ba
movl %ebx, %r12d
movl %r12d, %ebx
testl %ebp, %ebp
je 0x1e90d
jmp 0x1e96e
xorl %r12d, %r12d
testq %r15, %r15
je 0x1e99e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1e982
callq 0x2c860
movq 0x30(%rsp), %rdi
callq 0x1b680
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rbx
cmpq %rbx, %r15
je 0x1e973
movq %r14, %rdi
movq %r15, %rsi
callq 0x214b0
addq $0x4, %r15
jmp 0x1e9a8
movl %eax, %edi
callq 0x1d32d
movq %rax, %rbx
jmp 0x1e9e8
jmp 0x1e9cc
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1e9de
callq 0x2c860
movq 0x30(%rsp), %rdi
callq 0x1b680
movq %rbx, %rdi
callq 0x2ccc0
callq 0x2cd30
movl $0x2, %r12d
jmp 0x1e98c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, (%rsi)
je 0x20266
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x18(%rdi)
jne 0x201e1
movq %rsp, %rdi
callq 0x205f6
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x201d1
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x18(%r14)
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 0x20257
movq 0x18(%r14), %r13
movq (%rsp), %rdi
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x20222
movq (%rdi), %rax
callq *0x10(%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x26772
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2023d
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x201f2
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x201f2
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x20266
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 0x202c0
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x202c0
jmp 0x202c8
jmp 0x202c8
jmp 0x202c8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x202a1
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x202b1
jmp 0x202c8
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x202c0
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xd7070
movq %rax, %rdi
callq 0x2087b
// File: /workspace/github_cpp_makefile_star2_O1/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 0x218be
movq %rdx, %r14
testq %rdx, %rdx
je 0x218be
movq %rsi, %r12
cmpb $0x0, (%rsi)
je 0x218be
cmpq $0x0, (%r14)
jne 0x218be
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x1b620
testl %eax, %eax
jne 0x218cf
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r12, %rdi
callq 0x1b2e0
leaq (%rax,%r12), %rdx
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x22342
addq $0x48, %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x22608
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2188a
callq 0x2c860
testq %r15, %r15
je 0x218aa
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x218b1
movq (%rdi), %rax
movl $0x2cc77d66, %esi       # imm = 0x2CC77D66
movq %r14, %rdx
callq *0x20(%rax)
movl %eax, %ebp
jmp 0x218b6
movl $0x3, %ebp
jmp 0x218b6
movl $0x2, %ebp
movq %rbx, %rdi
callq 0x1b680
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1d32d
jmp 0x218ec
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x218ef
callq 0x2c860
jmp 0x218ef
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b680
jmp 0x218fc
movq %rax, %r14
movq %r14, %rdi
callq 0x2ccc0
callq 0x2cd30
movl $0x2, %ebp
jmp 0x218be
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2199c
movq %rdx, %r14
testq %rdx, %rdx
je 0x2199c
movq %rsi, %r12
cmpb $0x0, (%rsi)
je 0x2199c
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x1b620
testl %eax, %eax
jne 0x219aa
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r12, %rdi
callq 0x1b2e0
leaq (%rax,%r12), %rdx
movq %rsp, %rdi
movq %r12, %rsi
callq 0x22342
addq $0x48, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x2275c
movq %rax, %rdi
movq %r14, %rsi
callq 0x22720
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x21992
callq 0x2c860
movq %rbx, %rdi
callq 0x1b680
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x1d32d
movq %rax, %r14
jmp 0x219cc
movq %rax, %r14
jmp 0x219d4
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x219cc
callq 0x2c860
movq %rbx, %rdi
callq 0x1b680
movq %r14, %rdi
callq 0x2ccc0
callq 0x2cd30
movl $0x2, %eax
jmp 0x2199c
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21abb
movq %rsi, %r14
cmpq $0x0, (%rsi)
jne 0x21abb
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x1b620
testl %eax, %eax
jne 0x21acc
leaq 0x8(%rsp), %rdi
callq 0x205f6
movq 0x58(%r15), %r13
testq %r13, %r13
je 0x21a82
leaq 0x10(%rsp), %r15
leaq 0x8(%r13), %rsi
movq 0x8(%rsp), %r12
leaq 0x28(%r13), %rdx
movq %r15, %rdi
callq 0x22b0e
movq %r12, %rdi
movq %r15, %rsi
callq 0x22a76
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x21a70
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x10(%rsp)
movq (%r13), %r13
testq %r13, %r13
jne 0x21a40
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21a9e
movq (%rdi), %rax
movl $0xe2cd2d56, %esi       # imm = 0xE2CD2D56
movq %r14, %rdx
callq *0x28(%rax)
movl %eax, %ebp
jmp 0x21aa3
movl $0x2, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21ab3
movq (%rdi), %rax
callq *0x20(%rax)
movq %rbx, %rdi
callq 0x1b680
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1d32d
jmp 0x21ae1
jmp 0x21ae9
movq %rax, %r14
jmp 0x21b23
movq %rax, %r14
jmp 0x21b2b
movq %rax, %rdi
callq 0x2087b
movq %rax, %r14
jmp 0x21b0a
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x21b01
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21b1a
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1b680
movq %r14, %rdi
callq 0x2ccc0
callq 0x2cd30
movl $0x2, %ebp
jmp 0x21abb
jmp 0x21ae1
jmp 0x21ae1
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25d52
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 0x2594e
testq %r12, %r12
jne 0x25947
movq $-0x1, %rcx
leaq 0x1(%rcx), %r12
cmpb $0x0, 0x1(%r15,%rcx)
movq %r12, %rcx
jne 0x25938
movq %r15, (%rax)
movq %r12, 0x10(%rax)
testq %rbx, %rbx
je 0x25975
testq %r14, %r14
jne 0x2596d
movq $-0x1, %rcx
leaq 0x1(%rcx), %r14
cmpb $0x0, 0x1(%rbx,%rcx)
movq %r14, %rcx
jne 0x2595f
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_O1/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 0x25d52
movq $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
testq %r15, %r15
je 0x25e67
testq %r12, %r12
jne 0x25e60
movq $-0x1, %rcx
leaq 0x1(%rcx), %r12
cmpb $0x0, 0x1(%r15,%rcx)
movq %r12, %rcx
jne 0x25e51
movq %r15, (%rax)
movq %r12, 0x10(%rax)
testq %rbx, %rbx
je 0x25e8e
testq %r14, %r14
jne 0x25e86
movq $-0x1, %rcx
leaq 0x1(%rcx), %r14
cmpb $0x0, 0x1(%rbx,%rcx)
movq %r14, %rcx
jne 0x25e78
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_O1/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 0x2755d
movq %rdx, %r14
movq %rsi, %rbx
testq %rdx, %rdx
jne 0x2752e
xorl %eax, %eax
leaq 0x1(%rax), %r14
cmpb $0x0, (%rbx,%rax)
movq %r14, %rax
jne 0x27521
testq %rbx, %rbx
sete %bpl
movq %r14, %rsi
callq 0x25d52
testq %r14, %r14
sete %cl
orb %bpl, %cl
jne 0x27558
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0x2754a
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb3389(%rip), %rdi     # 0xda8ed
leaq 0xb2f6d(%rip), %rsi     # 0xda4d8
leaq 0xb338a(%rip), %rcx     # 0xda8fc
movl $0x1de, %edx            # imm = 0x1DE
callq 0x1b150
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2765a
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testl %eax, %eax
jne 0x2768e
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x275f1
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0x28(%rax)
testl %eax, %eax
jne 0x276c2
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %edx
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x22342
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rcx
cmpq %r14, %rcx
je 0x2762f
movq %rcx, (%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x27636
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2764f
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2cb60
movq %rax, %r14
leaq 0xb32e0(%rip), %rsi     # 0xda94e
movq %rax, %rdi
callq 0x40360
leaq 0xf79f3(%rip), %rsi     # 0x11f070
leaq 0xf35c(%rip), %rdx      # 0x369e0
movq %r14, %rdi
callq 0x2dbb0
jmp 0x276f4
movl $0x10, %edi
callq 0x2cb60
movq %rax, %r14
leaq 0xb32c2(%rip), %rsi     # 0xda964
movq %rax, %rdi
callq 0x40360
leaq 0xf79bf(%rip), %rsi     # 0x11f070
leaq 0xf328(%rip), %rdx      # 0x369e0
movq %r14, %rdi
callq 0x2dbb0
jmp 0x276f4
movl $0x10, %edi
callq 0x2cb60
movq %rax, %r14
leaq 0xb32ab(%rip), %rsi     # 0xda981
movq %rax, %rdi
callq 0x40360
leaq 0xf798b(%rip), %rsi     # 0x11f070
leaq 0xf2f4(%rip), %rdx      # 0x369e0
movq %r14, %rdi
callq 0x2dbb0
jmp 0x276f8
jmp 0x276f8
movq %rax, %rbx
movq %r14, %rdi
callq 0x2cbc0
jmp 0x27710
jmp 0x27728
jmp 0x2770d
jmp 0x2770d
jmp 0x2770d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x27720
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xd7070
movq %rax, %rdi
callq 0x2087b
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27fdd
movl %r8d, %r12d
movq %r13, 0x18(%rsp)
movups (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
movb $0x9, 0x8(%rsp)
testl %r8d, %r8d
jle 0x27fcf
leaq 0x20(%rsp), %r13
leaq 0x8(%rsp), %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x28550
decl %r12d
jne 0x27fbf
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movb $0x3c, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x28550
movb $0x3f, %r12b
movb %r12b, (%r15)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x28550
movb $0x78, (%r15)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x28550
movb $0x6d, (%r15)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x28550
movb $0x6c, (%r15)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x28550
movups (%r14), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r13, %rdx
movl %ebp, %ecx
callq 0x285a1
movups (%r15), %xmm0
movups %xmm0, (%r14)
movb %r12b, (%r15)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x28550
movb $0x3e, (%r15)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x28550
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_O1/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 $0x38, %rsp
cmpl $0x4, 0x28(%rdx)
jne 0x281ef
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %cl
jne 0x28101
movl %r8d, %ebp
movups (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
movb $0x9, 0xf(%rsp)
testl %r8d, %r8d
jle 0x280f8
leaq 0x20(%rsp), %r12
leaq 0xf(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x28550
decl %ebp
jne 0x280e9
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%r14)
leaq 0xf(%rsp), %r12
movb $0x3c, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x28550
movb $0x21, (%r12)
leaq 0xf(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x28550
movb $0x2d, %bpl
movb %bpl, (%r12)
leaq 0xf(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x28550
movb %bpl, (%r12)
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0x28550
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x28165
movq %r12, %rsi
movq 0x18(%r15), %r12
jmp 0x2816c
leaq 0xfd395(%rip), %rsi     # 0x125501
movups (%r14), %xmm0
movaps %xmm0, 0x10(%rsp)
testq %r12, %r12
je 0x28193
leaq 0x10(%rsp), %r15
leaq 0x1(%rsi), %r13
movq %r15, %rdi
callq 0x28550
movq %r13, %rsi
decq %r12
jne 0x2817f
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r14)
movb $0x2d, %bpl
leaq 0xf(%rsp), %r15
movb %bpl, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x28550
movb %bpl, (%r15)
leaq 0xf(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x28550
movb $0x3e, (%r15)
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0x28550
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 0xb2999(%rip), %rdi     # 0xdab8f
leaq 0xb27a1(%rip), %rsi     # 0xda99e
leaq 0xb29a8(%rip), %rcx     # 0xdabac
movl $0x163, %edx            # imm = 0x163
callq 0x1b150
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
cmpl $0x7, 0x28(%rdx)
jne 0x28530
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %cl
jne 0x2842a
movl %r8d, %ebp
movups (%r14), %xmm0
movaps %xmm0, 0x30(%rsp)
movb $0x9, 0xf(%rsp)
testl %r8d, %r8d
jle 0x28421
leaq 0x30(%rsp), %r12
leaq 0xf(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x28550
decl %ebp
jne 0x28412
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%r14)
leaq 0xf(%rsp), %r12
movb $0x3c, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x28550
movb $0x3f, (%r12)
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0x28550
movq (%r15), %r13
testq %r13, %r13
je 0x28462
movq %r13, %rsi
movq 0x10(%r15), %r13
jmp 0x28469
leaq 0xfd098(%rip), %rsi     # 0x125501
movups (%r14), %xmm0
movaps %xmm0, 0x20(%rsp)
testq %r13, %r13
je 0x28490
leaq 0x20(%rsp), %r12
leaq 0x1(%rsi), %rbp
movq %r12, %rdi
callq 0x28550
movq %rbp, %rsi
decq %r13
jne 0x2847c
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%r14)
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movq %r14, %rdi
callq 0x28550
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x284bb
movq %r12, %rsi
movq 0x18(%r15), %r12
jmp 0x284c2
leaq 0xfd03f(%rip), %rsi     # 0x125501
movups (%r14), %xmm0
movaps %xmm0, 0x10(%rsp)
testq %r12, %r12
je 0x284e9
leaq 0x10(%rsp), %r15
leaq 0x1(%rsi), %r13
movq %r15, %rdi
callq 0x28550
movq %r13, %rsi
decq %r12
jne 0x284d5
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r14)
leaq 0xf(%rsp), %r15
movb $0x3f, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x28550
movb $0x3e, (%r15)
leaq 0xf(%rsp), %rsi
movq %r14, %rdi
callq 0x28550
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
leaq 0xb279c(%rip), %rdi     # 0xdacd3
leaq 0xb2460(%rip), %rsi     # 0xda99e
leaq 0xb27a6(%rip), %rcx     # 0xdaceb
movl $0x18b, %edx            # imm = 0x18B
callq 0x1b150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb1704(%rip), %rsi     # 0xdbe42
leaq 0xb170d(%rip), %rdx     # 0xdbe52
leaq 0x8(%rsp), %rdi
callq 0x22342
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ab88
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2a76e
callq 0x2c860
leaq 0x8(%rsp), %rdi
movl $0x0, (%rdi)
callq *%rbx
testl %eax, %eax
jne 0x2a78b
movl 0x8(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2cb60
movq %rax, %r14
leaq 0xb16b4(%rip), %rsi     # 0xdbe53
movq %rax, %rdi
callq 0x2ace0
leaq 0xf382a(%rip), %rsi     # 0x11dfd8
leaq 0xc22b(%rip), %rdx      # 0x369e0
movq %r14, %rdi
callq 0x2dbb0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2cbc0
jmp 0x2a7e1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2a7e1
callq 0x2c860
jmp 0x2a7e1
movq %rax, %rbx
movq %rbx, %rdi
callq 0xd7070
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
setge %al
jl 0x42e5
movq %rsi, %rbx
movq 0x8(%rsi), %rcx
movl $0x1, %r14d
cmpb $0x2d, (%rcx)
jne 0x4226
movl %edi, %ebp
movl $0x3, %r14d
movb 0x1(%rcx), %al
cmpb $0x62, %al
jne 0x42fb
movq -0x8(%rbx,%r14,8), %rdi
callq 0x3320
movl %eax, 0x16047(%rip)     # 0x1a250
cmpl %ebp, %r14d
setl %al
jge 0x42e5
movq (%rbx,%r14,8), %rcx
addq $0x2, %r14
cmpb $0x2d, (%rcx)
je 0x41ee
addl $-0x2, %r14d
testb %al, %al
je 0x42e5
leaq (%rbx,%r14,8), %r15
movq (%r15), %rdi
leaq 0x11edc(%rip), %rsi     # 0x16118
callq 0x3240
testq %rax, %rax
je 0x4303
movq %rax, %rbx
movq 0x10(%r15), %rdi
leaq 0x11edc(%rip), %rsi     # 0x16134
callq 0x3240
testq %rax, %rax
je 0x430b
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0x125f3
movq %rax, 0x15fcf(%rip)     # 0x1a248
testq %rax, %rax
je 0x4317
movslq 0x15f97(%rip), %rdi     # 0x1a220
shlq $0x4, %rdi
callq 0x32b0
movq %rax, 0x15fa7(%rip)     # 0x1a240
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b21
leaq 0x15f9d(%rip), %rdi     # 0x1a248
callq 0x11ee0
movq 0x15fa1(%rip), %rdi     # 0x1a258
callq 0x3250
movq 0x15f7d(%rip), %rdi     # 0x1a240
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
leaq 0x11e7f(%rip), %rdi     # 0x1616b
callq 0x3310
movl $0x1, %edi
callq 0x3260
movzbl %al, %edi
callq 0x34e9
movq %r15, %rdi
callq 0x3568
addq $0x10, %r15
movq %r15, %rdi
callq 0x3541
addq $0x8, %r15
movq %r15, %rdi
callq 0x351a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2966
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x27dd
movq %rax, %r15
movb $0x1, %bpl
cmpq %rbx, %rax
jne 0x24a2
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1b99(%rip), %rsi      # 0x4007
leaq 0x1b98(%rip), %rdx      # 0x400d
leaq 0x8(%rsp), %rdi
callq 0x2966
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27dd
cmpq %rbx, %rax
jne 0x24a2
movq %rbx, %rax
subq %r14, %rax
cmpq $0x8, %rax
sete %bpl
cmpq %rbx, %r15
jne 0x24c2
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x24c2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x24d9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
testb %bpl, %bpl
jne 0x24f6
subq %r14, %rbx
cmpq $0x18, %rbx
jne 0x2502
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x275d
xorl %edi, %edi
callq 0x2170
movq 0x3ae7(%rip), %rdi      # 0x5ff0
leaq 0x1afe(%rip), %rsi      # 0x400e
callq 0x2130
leaq 0x1b19(%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 %r13, %rdi
je 0x2557
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x2557
jmp 0x2554
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x256e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a3a(%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 0x2720
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2720
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x28d6
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x28d6
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x29f8
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x2644
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x265b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2676
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2691
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 0x26c0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x26c0
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x26dc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x26dc
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26fc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
jmp 0x26fc
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2717
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3092
movq (%rbx), %rax
movl $0x0, (%rax)
movq 0x8(%r14), %rcx
cmpl $0x2, %ecx
jl 0x2eb3
movq (%r14), %rdx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edi, %edi
movl $0x1, %esi
testl %edi, %edi
jle 0x2e93
movq (%r14), %r8
movb (%r8,%rsi), %r9b
movl %edi, %r10d
cmpb (%r8,%r10), %r9b
je 0x2e93
movl -0x4(%rax,%r10,4), %edi
testl %edi, %edi
jg 0x2e81
movb (%rdx,%rsi), %r8b
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 0x2e76
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ba53c(%rip), %rsi    # 0x2d89f6
leaq 0x1ba536(%rip), %rdx    # 0x2d89f7
leaq 0x20(%rsp), %rdi
callq 0x11e2ee
movw $0x100, 0x8(%rbx)       # imm = 0x100
movq $0x0, 0x10(%rbx)
movq $-0x1, 0x18(%rbx)
leaq 0x2c34a8(%rip), %r13    # 0x3e1990
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 0x120a1c
movl $0x0, 0x40(%rbx)
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x11e527
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x119090
leaq 0x2c33d2(%rip), %rax    # 0x3e1900
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 0x11e547
movq $0x270, 0x13c8(%rbx) # imm = 0x270
xorps %xmm0, %xmm0
movhps 0x1b4b41(%rip), %xmm0   # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, 0x13d0(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x1207de
xorl %ebp, %ebp
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x119140
movl %eax, 0x13a8(%rsp,%rbp,4)
incq %rbp
cmpq $0x270, %rbp            # imm = 0x270
jne 0x11e597
leaq 0x1d68(%rsp), %rdx
leaq 0x8(%rsp), %rdi
leaq 0x13a8(%rsp), %rsi
callq 0x120858
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1208ee
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x11e5f0
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x119090
leaq 0x20(%rsp), %rdi
callq 0x119110
addq $0x1d68, %rsp           # imm = 0x1D68
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11e677
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x11e64d
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x119090
jmp 0x11e64d
jmp 0x11e64a
movq %rax, %r14
jmp 0x11e657
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x11e66f
movq 0x30(%rsp), %rsi
jmp 0x11e667
movq %rax, %r14
jmp 0x11e66f
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x119110
movq %r13, (%rbx)
movq 0x20(%rbx), %rdi
cmpq %r12, %rdi
je 0x11e66f
movq (%r12), %rsi
incq %rsi
callq 0x119090
movq %r14, %rdi
callq 0x119300
movq %rax, %rdi
callq 0x11e2e2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30649
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x30644
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x3061f
leaq 0x30(%r14), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x30637
movq (%rax), %rsi
incq %rsi
callq 0xc0d0
movl $0x50, %esi
movq %r14, %rdi
callq 0xc0d0
movq (%r15), %r15
jmp 0x305fa
movq 0xf0(%rbx), %r15
testq %r15, %r15
je 0x3069f
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x3069a
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x30675
leaq 0x30(%r14), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rax, %rdi
je 0x3068d
movq (%rax), %rsi
incq %rsi
callq 0xc0d0
movl $0x50, %esi
movq %r14, %rdi
callq 0xc0d0
movq (%r15), %r15
jmp 0x30650
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x306b1
movl $0x28, %esi
callq 0xc0d0
leaq 0x10158(%rbx), %rdi
callq 0xc7a0
movq 0x80(%rbx), %r14
testq %r14, %r14
je 0x306e1
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x306dc
movl $0x10, %esi
callq 0xc0d0
movq (%r14), %r14
jmp 0x306c4
movq 0xc87f0(%rip), %rax     # 0xf8ed8
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 0x30735
movq 0x148(%rbx), %rsi
subq %rdi, %rsi
callq 0xc0d0
leaq 0x70(%rbx), %r14
leaq 0xe0(%rbx), %rdi
leaq 0xa8(%rbx), %r15
callq 0x3a8bc
movq %r15, %rdi
callq 0x3a8bc
movq %r14, %rdi
callq 0x3a944
addq $0x10, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a566
jmp 0x30776
jmp 0x30776
movq %rax, %rdi
callq 0x3a5b4
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30791
popq %rbp
jmp 0x3079a
movq (%rdi), %rdi
popq %rbp
jmp 0x3d678
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30828
movq 0xc872d(%rip), %rdi     # 0xf8ee8
leaq 0x829b6(%rip), %rsi     # 0xb3178
movl $0x11, %edx
callq 0xc830
leaq 0x130(%rbx), %r14
movq %r14, %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x3d1ac
movl %eax, %r12d
movq %r14, %rdi
movl $0xff0f, %esi           # imm = 0xFF0F
callq 0x3d1ac
movl %eax, %r15d
andb %al, %r12b
testb $0x1, %r12b
jne 0x30849
andb $0x1f, %r12b
testb $0x2, %r12b
jne 0x30853
testb $0x4, %r12b
jne 0x3085d
testb $0x8, %r12b
jne 0x30867
movzbl %r12b, %eax
testl %eax, %eax
je 0x308a1
movb $-0x11, %r12b
movw $0x60, %r13w
jmp 0x3086f
cmpb $0x1, 0x129(%rbx)
jne 0x3083a
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 0x3086f
movb $-0x3, %r12b
movw $0x48, %r13w
jmp 0x3086f
movb $-0x5, %r12b
movw $0x50, %r13w
jmp 0x3086f
movb $-0x9, %r12b
movw $0x58, %r13w
leaq 0x12c(%rbx), %rsi
movq %rbx, %rdi
callq 0x3c5d6
movw %r13w, 0x12c(%rbx)
addl $-0x5, 0x8(%rbx)
movq %rbx, %rdi
movl $0x5, %esi
callq 0x3196c
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 0x3d1b8
// File: /workspace/github_cpp_makefile_star2_O1/Ciaxur[P]yagb-emu/src/CPU.cc
// Function: CPU::checkHalfCarry(unsigned char, unsigned char)
void CPU::checkHalfCarry(uint8_t prev, uint8_t after) { // Overflow from 3rd Bit
  this->reg.F &= 0xDF;                    // Unset H Flag
  if ((prev & 0x0F) != (after & 0x0F))    // LSB Change
    if ((prev & 0xF0) != (after & 0xF0))  // MSB Change
      this->reg.F |= 0x20;                // Set H Flag
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x11d(%rdi), %al
andb $-0x21, %al
xorl %edx, %esi
testb $0xf, %sil
setne %cl
shlb $0x5, %cl
xorl %edx, %edx
cmpb $0x10, %sil
movzbl %cl, %ecx
cmovbl %edx, %ecx
orb %al, %cl
movb %cl, 0x11d(%rdi)
popq %rbp
retq