LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yinqiwen[P]coroxx/./thread_mutex_lock.h
// Function: coroxx::ThreadMutexLock::Wait(unsigned long)
bool Wait(uint64_t timeout = 0)
            {
                if (timeout <= 0)
                {
                    return 0 == pthread_cond_wait(&m_cond, &m_mutex);
                }
                else
                {
                    struct timeval tp;
                    struct timespec ts;
                    gettimeofday(&tp, NULL);
                    int64_t now_micros = ((int64_t) tp.tv_sec) * 1000*1000 + tp.tv_usec;
                    setWaitTime(&ts, now_micros, timeout);
                    return 0 == pthread_cond_timedwait(&m_cond, &m_mutex, &ts);
                }
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x42f0
movq %rsi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2300
imulq $0xf4240, (%r15), %rax  # imm = 0xF4240
addq 0x8(%r15), %rax
imulq $0x3e8, %rax, %rcx      # imm = 0x3E8
imulq $0xf4240, %r14, %rax    # imm = 0xF4240
addq %rcx, %rax
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
cqto
idivq %rcx
movq %rsp, %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x38(%rbx), %rdi
addq $0x8, %rbx
movq %rbx, %rsi
movq %rcx, %rdx
callq 0x22b0
jmp 0x4300
leaq 0x38(%rbx), %rdi
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x22d0
testl %eax, %eax
sete %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yinqiwen[P]coroxx/./thread_local.h
// Function: coroxx::ThreadLocal<coroxx::Scheduler*>::GetValue()
T*& GetValue()
			{
				T** local_thread_value = static_cast<T**>(pthread_getspecific(
				        m_key));
				if (NULL == local_thread_value)
				{
					T** newObj = InitialValue();
					pthread_setspecific(m_key, newObj);
					local_thread_value = newObj;
				}
				return *local_thread_value;
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x22c0
movq %rax, %r14
testq %rax, %rax
jne 0x43cb
movq %rbx, %rdi
callq 0x51cc
movq %rax, %r14
movl (%rbx), %edi
movq %rax, %rsi
callq 0x2080
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/yinqiwen[P]coroxx/scheduler.cpp
// Function: coroxx::CoroDiaptchData::InvokeFunc(void*)
static void InvokeFunc(void* data)
            {
                CoroDiaptchData* v = (CoroDiaptchData*) data;
                if (NULL != v && v->call)
                {
                    v->call(v->data);
                    delete v;
                }
            }

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x483e
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x483e
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
callq 0x31e6
movq %rbx, %rdi
callq 0x2716
pushq $0x30
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x21e0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/yinqiwen[P]coroxx/coro.c
// Function: coro_stack_alloc
int
coro_stack_alloc (struct coro_stack *stack, unsigned int size)
{
  if (!size)
    size = 256 * 1024;

  stack->sptr = 0;
  stack->ssze = ((size_t)size * sizeof (void *) + PAGESIZE - 1) / PAGESIZE * PAGESIZE;

#if CORO_FIBER

  stack->sptr = (void *)stack;
  return 1;

#else

  size_t ssze = stack->ssze + CORO_GUARDPAGES * PAGESIZE;
  void *base;

  #if CORO_MMAP
    /* mmap supposedly does allocate-on-write for us */
    base = mmap (0, ssze, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    if (base == (void *)-1)
      {
        /* some systems don't let us have executable heap */
        /* we assume they won't need executable stack in that case */
        base = mmap (0, ssze, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

        if (base == (void *)-1)
          return 0;
      }

    #if CORO_GUARDPAGES
      mprotect (base, CORO_GUARDPAGES * PAGESIZE, PROT_NONE);
    #endif

    base = (void*)((char *)base + CORO_GUARDPAGES * PAGESIZE);
  #else
    base = malloc (ssze);
    if (!base)
      return 0;
  #endif

  #if CORO_USE_VALGRIND
    stack->valgrind_id = VALGRIND_STACK_REGISTER ((char *)base, ((char *)base) + ssze - CORO_GUARDPAGES * PAGESIZE);
  #endif

  stack->sptr = base;
  return 1;

#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
movl $0x40000, %r14d         # imm = 0x40000
cmovnel %esi, %r14d
movq %rdi, %rbx
andq $0x0, (%rdi)
callq 0x5b69
leaq (%rax,%r14,8), %r15
decq %r15
callq 0x5b69
movq %rax, %rcx
xorl %r14d, %r14d
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r15
callq 0x5b69
movq %rax, %r12
imulq %r15, %r12
movq %r12, 0x8(%rbx)
callq 0x5b69
leaq (%r12,%rax,4), %r12
pushq $0x7
popq %rdx
pushq $0x22
popq %rcx
pushq $-0x1
popq %r8
xorl %edi, %edi
movq %r12, %rsi
xorl %r9d, %r9d
callq 0x2340
cmpq $-0x1, %rax
jne 0x5b30
pushq $0x3
popq %rdx
pushq $0x22
popq %rcx
pushq $-0x1
popq %r8
xorl %edi, %edi
movq %r12, %rsi
xorl %r9d, %r9d
callq 0x2340
cmpq $-0x1, %rax
je 0x5b5a
movq %rax, %r15
callq 0x5b69
leaq (,%rax,4), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x22f0
callq 0x5b69
leaq (%r15,%rax,4), %rax
movq %rax, (%rbx)
pushq $0x1
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/yinqiwen[P]coroxx/coro.c
// Function: coro_pagesize
static size_t
    coro_pagesize (void)
    {
      static size_t pagesize;

      if (!pagesize)
        pagesize = sysconf (_SC_PAGESIZE);

      return pagesize;
    }

// Assembly:
movq 0x46d8(%rip), %rax      # 0xa248
testq %rax, %rax
je 0x5b76
retq
pushq %rax
pushq $0x1e
popq %rdi
callq 0x2150
movq %rax, 0x46c2(%rip)      # 0xa248
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yinqiwen[P]coroxx/coro.c
// Function: coro_stack_free
void
coro_stack_free (struct coro_stack *stack)
{
#if CORO_FIBER
  /* nop */
#else
  #if CORO_USE_VALGRIND
    VALGRIND_STACK_DEREGISTER (stack->valgrind_id);
  #endif

  #if CORO_MMAP
    if (stack->sptr)
      munmap ((void*)((char *)stack->sptr - CORO_GUARDPAGES * PAGESIZE),
              stack->ssze                 + CORO_GUARDPAGES * PAGESIZE);
  #else
    free (stack->sptr);
  #endif
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x5bc2
movq %rdi, %r14
callq 0x5b69
shlq $0x2, %rax
subq %rax, %rbx
movq 0x8(%r14), %r14
callq 0x5b69
leaq (%r14,%rax,4), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2130
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/rthoelen[P]NXCore_Kenwood/main.cc
// Function: rpton_64001(int)
void rpton_64001(int rpt_no)
{
		int o_bufsize;

		up_packet[24] = (char)repeater[rpt_no].tx_ran;
		while(tx_sem==1)
			usleep(1);
		tx_sem=1;
		sendto(socket_01, up_packet, sizeof(up_packet), 0, (struct sockaddr *)&repeater[rpt_no].rpt_addr_01,
		 	sizeof(repeater[rpt_no].rpt_addr_01));
		tx_sem=0;
		while(1)
		{
			#ifdef __FreeBSD__
			ioctl(socket_01,FIONWRITE,&o_bufsize);
			#else
			ioctl(socket_01,SIOCOUTQ,&o_bufsize);
			#endif
			if(o_bufsize == 0)
				break;
			usleep(500);
		}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0xe83b(%rip), %rax      # 0x143f0
movslq %edi, %rcx
imulq $0x90, %rcx, %r14
movb 0x48(%rax,%r14), %al
movb %al, 0xe7ce(%rip)       # 0x14398
pushq $0x1
popq %rbx
cmpl $0x1, 0xe850(%rip)      # 0x14424
jne 0x5bdf
movl %ebx, %edi
callq 0x4490
jmp 0x5bcd
movl $0x1, 0xe83b(%rip)      # 0x14424
movl 0xe831(%rip), %edi      # 0x14420
movq 0xe7fa(%rip), %rax      # 0x143f0
leaq (%rax,%r14), %r8
addq $0x10, %r8
leaq 0xe77b(%rip), %rsi      # 0x14380
pushq $0x1c
popq %rdx
pushq $0x10
popq %r9
xorl %ecx, %ecx
callq 0x4050
andl $0x0, 0xe80a(%rip)      # 0x14424
leaq -0x14(%rbp), %rbx
movl 0xe7fc(%rip), %edi      # 0x14420
movl $0x5411, %esi           # imm = 0x5411
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4470
cmpl $0x0, -0x14(%rbp)
je 0x5c45
movl $0x1f4, %edi            # imm = 0x1F4
callq 0x4490
jmp 0x5c1e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rthoelen[P]NXCore_Kenwood/main.cc
// Function: shutdown_64001(int)
void shutdown_64001(int rpt_no)
{

	down_packet[12] = (char)(repeater[rpt_no].tx_uid >> 8);
	down_packet[13] = (char)repeater[rpt_no].tx_uid & 0xff;

	while(tx_sem==1)
		usleep(1);

	tx_sem=1;
	sendto(socket_01, down_packet, sizeof(down_packet), 0, (struct sockaddr *)&repeater[rpt_no].rpt_addr_01,
		sizeof(repeater[rpt_no].rpt_addr_01));
	tx_sem=0;

	if(--repeater[rpt_no].keydown < 0)
		repeater[rpt_no].keydown = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xe567(%rip), %rax      # 0x143f0
movslq %edi, %rcx
imulq $0x90, %rcx, %r14
movb 0x6d(%rax,%r14), %cl
movb %cl, 0xe50e(%rip)       # 0x143ac
movb 0x6c(%rax,%r14), %al
movb %al, 0xe504(%rip)       # 0x143ad
pushq $0x1
popq %rbx
cmpl $0x1, 0xe571(%rip)      # 0x14424
jne 0x5ebe
movl %ebx, %edi
callq 0x4490
jmp 0x5eac
movl $0x1, 0xe55c(%rip)      # 0x14424
movl 0xe552(%rip), %edi      # 0x14420
movq 0xe51b(%rip), %rax      # 0x143f0
leaq (%rax,%r14), %r8
addq $0x10, %r8
leaq 0xe4bc(%rip), %rsi      # 0x143a0
pushq $0x14
popq %rdx
xorl %ebx, %ebx
pushq $0x10
popq %r9
xorl %ecx, %ecx
callq 0x4050
andl $0x0, 0xe529(%rip)      # 0x14424
movq 0xe4ee(%rip), %rax      # 0x143f0
movl 0x74(%rax,%r14), %ecx
leal -0x1(%rcx), %edx
testl %ecx, %ecx
cmovlel %ebx, %edx
movl %edx, 0x74(%rax,%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/siolag161[P]louvain-original/main_hierarchy.cpp
// Function: usage(char*, char const*)
void
usage(char *prog_name, const char *more) {
  cerr << more;
  cerr << "usage: " << prog_name << " input_file [options]" << endl << endl;
  cerr << "input_file: read the community tree from this file." << endl;
  cerr << "-l xx\t display the community structure for the level xx." << endl;
  cerr << "\t outputs the community for each node." << endl;
  cerr << "\t xx must belong to [-1,N] if N is the number of levels." << endl;
  cerr << "-n\t displays the number of levels and the size of each level." << endl;
  cerr << "\t equivalent to -l -1." << endl;
  cerr << "-h\tshow this usage message." << endl;
  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x2d16(%rip), %rbx      # 0x3ff0
movq %rbx, %rdi
callq 0x10e0
leaq 0xd1b(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x10e0
leaq 0xd09(%rip), %rsi       # 0x200c
movq %rax, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1070
leaq 0xd00(%rip), %rsi       # 0x2022
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
leaq 0xd1d(%rip), %rsi       # 0x2056
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
leaq 0xd3f(%rip), %rsi       # 0x208f
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
leaq 0xd4f(%rip), %rsi       # 0x20b6
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
leaq 0xd71(%rip), %rsi       # 0x20ef
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
leaq 0xd98(%rip), %rsi       # 0x212d
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
leaq 0xd98(%rip), %rsi       # 0x2144
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1070
xorl %edi, %edi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1462
movl %edi, %ebp
pushq $0x1
popq %r14
movq 0x2d1d(%rip), %r15      # 0x4100
cmpl %ebp, %r14d
jge 0x1434
movslq %r14d, %rax
movq (%rbx,%rax,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x1417
movzbl 0x1(%rcx), %ecx
cmpl $0x6e, %ecx
je 0x1428
cmpl $0x6c, %ecx
jne 0x1453
incl %r14d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1150
movl %eax, 0x2ccb(%rip)      # 0x40e0
jmp 0x142f
testq %r15, %r15
jne 0x1444
movq %rcx, 0x2cdd(%rip)      # 0x4100
movq %rcx, %r15
jmp 0x142f
orl $-0x1, 0x2cb1(%rip)     # 0x40e0
incl %r14d
jmp 0x13e3
testq %r15, %r15
je 0x1471
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
leaq 0xd38(%rip), %rsi       # 0x2186
callq 0x12cc
movq (%rbx), %rdi
leaq 0xd19(%rip), %rsi       # 0x2176
callq 0x12cc
movq (%rbx), %rdi
leaq 0xcf4(%rip), %rsi       # 0x2160
callq 0x12cc
movq (%rbx), %rdi
leaq 0xd23(%rip), %rsi       # 0x219e
callq 0x12cc
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movl %esi, 0x4(%rsp)
pushq $0x5
popq %rbp
testq %rdx, %rdx
je 0x1c36f
movq %rdx, %r14
cmpq $0x0, (%rdx)
jne 0x1c36f
movq %rdi, %r15
leaq 0x28(%rdi), %rbx
movq %rbx, %rdi
callq 0x1e168
addq $0x50, %r15
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x1e76a
testq %rax, %rax
je 0x1c364
addq $0x10, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0x1d51a
movl %eax, %ebp
jmp 0x1c367
pushq $0x3
popq %rbp
movq %rbx, %rdi
callq 0x19680
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1c37e
movq %rax, %r14
movq %rbx, %rdi
callq 0x19680
jmp 0x1c38e
movq %rax, %r14
movq %r14, %rdi
callq 0x28cb0
callq 0x28d20
pushq $0x2
popq %rbp
jmp 0x1c36f
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, %r15
leaq 0x28(%rdi), %rbx
movq %rbx, %rdi
callq 0x1e168
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
andq $0x0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x50(%r15), %r14
addq $0x60, %r15
leaq 0xc(%rsp), %r13
movq (%r15), %r15
testq %r15, %r15
je 0x1c709
andl $0x0, 0xc(%rsp)
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0x28(%rax)
movl %eax, %ebp
testl %eax, %eax
jne 0x1c72b
leaq 0x8(%r15), %rsi
movq %r12, %rdi
callq 0x1d604
jmp 0x1c6db
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r12
cmpq %r12, %r15
je 0x1c729
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ee7a
addq $0x4, %r15
jmp 0x1c713
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
callq 0x1e82a
movq %rbx, %rdi
callq 0x19680
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1c76a
jmp 0x1c755
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x1e82a
movq %rbx, %rdi
callq 0x19680
movq %r14, %rdi
callq 0x28cb0
callq 0x28d20
pushq $0x2
popq %rbp
jmp 0x1c73d
// File: /workspace/github_cpp_makefile_star2_O2/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, %rax
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1da1d
movq %rsi, %rbx
leaq 0x18(%rax), %r14
cmpq $0x0, 0x18(%rax)
jne 0x1d9b7
movq %rsp, %rdi
callq 0x1ddda
movq %r14, %rdi
callq 0x1e534
movq %rsp, %rdi
movq (%rdi), %rax
movq %rax, (%r14)
andq $0x0, (%rdi)
callq 0x1e040
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rsp, %r15
leaq 0x8(%rsp), %r12
andq $0x0, (%rsp)
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x28(%rax)
testl %eax, %eax
jne 0x1da15
movq (%r14), %r13
movq (%rsp), %rdi
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x1d9f1
movq (%rdi), %rax
callq *0x10(%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x236ee
movq %r12, %rdi
callq 0x1dcb8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d9c5
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1d9c5
movq %rsp, %rdi
callq 0x1dcb8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1e040
jmp 0x1da52
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1dcb8
jmp 0x1da4a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1dcb8
movq %rbx, %rdi
callq 0xd3bc0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
pushq $0x5
popq %rbp
testq %rsi, %rsi
je 0x1f1b4
movq %rdx, %r14
testq %rdx, %rdx
je 0x1f1b4
movq %rsi, %r12
cmpb $0x0, (%rsi)
je 0x1f1b4
cmpq $0x0, (%r14)
jne 0x1f1b4
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x1e168
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r12, %rsi
callq 0xa7de0
addq $0x48, %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x1fb60
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0xa5530
testq %r15, %r15
je 0x1f1a9
addq $0x28, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1fb42
movl %eax, %ebp
jmp 0x1f1ac
pushq $0x3
popq %rbp
movq %rbx, %rdi
callq 0x19680
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f1d4
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xa5530
jmp 0x1f1d7
movq %rax, %r14
movq %rbx, %rdi
callq 0x19680
jmp 0x1f1e4
movq %rax, %r14
movq %r14, %rdi
callq 0x28cb0
callq 0x28d20
pushq $0x2
popq %rbp
jmp 0x1f1b4
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x5
popq %rax
testq %rsi, %rsi
je 0x1f275
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
testq %rdx, %rdx
je 0x1f26a
movq %rsi, %r12
cmpb $0x0, (%rsi)
je 0x1f26a
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x1e168
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
callq 0xa7de0
addq $0x48, %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x1fcb0
movq %rax, %rdi
movq %r14, %rsi
callq 0x1fc7c
leaq 0x8(%rsp), %rdi
callq 0xa5530
movq %rbx, %rdi
callq 0x19680
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x1f28d
movq %rax, %r14
jmp 0x1f295
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xa5530
movq %rbx, %rdi
callq 0x19680
movq %r14, %rdi
callq 0x28cb0
callq 0x28d20
pushq $0x2
popq %rax
jmp 0x1f26a
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x5
popq %rbp
testq %rsi, %rsi
je 0x1f354
movq %rsi, %r14
cmpq $0x0, (%rsi)
jne 0x1f354
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x1e168
leaq 0x8(%rsp), %rdi
callq 0x1ddda
addq $0x58, %r15
leaq 0x10(%rsp), %r12
movq (%r15), %r15
testq %r15, %r15
je 0x1f323
leaq 0x8(%r15), %rsi
movq 0x8(%rsp), %r13
leaq 0x28(%r15), %rdx
movq %r12, %rdi
callq 0x20066
movq %r13, %rdi
movq %r12, %rsi
callq 0x2000c
movq %r12, %rdi
callq 0x200f2
jmp 0x1f2f1
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1f33f
movq (%rdi), %rax
movl $0xe2cd2d56, %esi       # imm = 0xE2CD2D56
movq %r14, %rdx
callq *0x28(%rax)
movl %eax, %ebp
jmp 0x1f342
pushq $0x2
popq %rbp
leaq 0x8(%rsp), %rdi
callq 0x1e040
movq %rbx, %rdi
callq 0x19680
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f371
movq %rax, %r14
jmp 0x1f38d
movq %rax, %r14
jmp 0x1f395
movq %rax, %r14
jmp 0x1f383
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x200f2
leaq 0x8(%rsp), %rdi
callq 0x1e040
movq %rbx, %rdi
callq 0x19680
movq %r14, %rdi
callq 0x28cb0
callq 0x28d20
pushq $0x2
popq %rbp
jmp 0x1f354
nop
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/include/common/xml_property_bag.h
// Function: Boss::XmlPropertyBag::Save(Boss::IOStream*)
virtual RetCode BOSS_CALL Save(IOStream *stream)
    {
      if (!stream)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        rapidxml::xml_document<> Doc;
        auto *RootNode = Doc.allocate_node(rapidxml::node_element, RootName.c_str());
        Doc.append_node(RootNode);
        for (auto &prop : Props)
          SerializeItem(prop.first, prop.second.Get(), &Doc, RootNode);
        std::stringstream Io;
        rapidxml::print(std::ostream_iterator<char>(Io), Doc, 0);
        std::string Xml(Io.str());
        return stream->Write(Xml.c_str(), Xml.length());
      }
      catch (...)
      {
        return Status::Fail;
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10248, %rsp          # imm = 0x10248
testq %rsi, %rsi
je 0x1f824
movq %rsi, %r15
movq %rdi, %r12
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
callq 0x1e168
movq %rbx, (%rsp)
leaq 0x220(%rsp), %r14
andq $0x0, -0x40(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%r14)
andl $0x0, -0x38(%r14)
andq $0x0, -0x30(%r14)
andq $0x0, -0x20(%r14)
leaq 0x10238(%rsp), %rax
leaq 0x238(%rsp), %rcx
movups %xmm0, (%rax)
movq %rcx, -0x18(%rcx)
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movq 0x80(%r12), %rdx
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x228ec
movq %rax, %r13
leaq 0x1c0(%rsp), %rdi
movq %rax, %rsi
callq 0x222ea
leaq 0x58(%r12), %rbx
leaq 0x1c0(%rsp), %rbp
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1f7aa
leaq 0x8(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r12, %rdi
movq %rbp, %rcx
movq %r13, %r8
callq 0x23ac0
jmp 0x1f78a
leaq 0x38(%rsp), %rdi
callq 0x9e7a0
leaq 0x48(%rsp), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x1c0(%rsp), %rdx
xorl %ecx, %ecx
callq 0x241fa
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x9b240
movq 0x8(%rsp), %rsi
movl 0x10(%rsp), %edx
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xa5530
leaq 0x38(%rsp), %rdi
callq 0x9abc0
movq %r14, %rdi
callq 0x23a5c
movq (%rsp), %rdi
callq 0x19680
jmp 0x1f827
pushq $0x5
popq %rbp
movl %ebp, %eax
addq $0x10248, %rsp          # imm = 0x10248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0xa5530
jmp 0x1f84f
jmp 0x1f84c
movq %rax, %r15
leaq 0x38(%rsp), %rdi
callq 0x9abc0
jmp 0x1f867
jmp 0x1f864
movq %rax, %r15
jmp 0x1f878
jmp 0x1f864
movq %rax, %r15
movq %r14, %rdi
callq 0x23a5c
movq (%rsp), %rdi
callq 0x19680
movq %r15, %rdi
callq 0x28cb0
callq 0x28d20
pushq $0x2
jmp 0x1f826
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r12
pushq $0x38
popq %rsi
callq 0x22c94
movq %rax, %r15
andq $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
testq %r12, %r12
je 0x22dfd
testq %r13, %r13
je 0x22df2
movq %r12, (%r15)
movq %r13, 0x10(%r15)
jmp 0x22dfd
movq %r15, %rdi
movq %r12, %rsi
callq 0x22d14
testq %rbx, %rbx
je 0x22e1c
testq %r14, %r14
je 0x22e11
movq %rbx, 0x8(%r15)
movq %r14, 0x18(%r15)
jmp 0x22e1c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22d36
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/include/core/utils.h
// Function: unsigned int Boss::FromString<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline T FromString(std::string const &str)
  {
    std::stringstream Io;
    Io << str;
    T Ret;
    Io >> Ret;
    return Ret;
  }

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9e7a0
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0xa7eb0
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x7b210
movl 0x4(%rsp), %ebx
leaq 0x8(%rsp), %rdi
callq 0x9abc0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
jmp 0x236d8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9abc0
movq %rbx, %rdi
callq 0xd3bc0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
orq %rdx, %rax
je 0x2428b
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
jne 0x24263
movq %rbx, %rdi
callq 0x223cb
movq %rax, %r14
incq %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x22c94
testq %rbx, %rbx
je 0x24285
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x24285
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x24275
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb3673(%rip), %rdi     # 0xd7905
leaq 0xb323f(%rip), %rsi     # 0xd74d8
leaq 0xb3674(%rip), %rcx     # 0xd7914
movl $0x1de, %edx            # imm = 0x1DE
callq 0x19150
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdx)
movq (%rax), %rcx
pushq $0x1
popq %rsi
movq %rax, %rdi
callq *0x38(%rcx)
testl %eax, %eax
jne 0x24408
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testl %eax, %eax
jne 0x2443a
andq $0x0, 0x10(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x24395
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0x28(%rax)
testl %eax, %eax
jne 0x2446c
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %edx
jmp 0x24399
xorl %edx, %edx
xorl %esi, %esi
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x1f964
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rcx
cmpq %r14, %rcx
je 0x243ce
movq %rcx, (%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x243d5
movups (%r14), %xmm0
movups %xmm0, (%rax)
leaq 0x18(%rsp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
movq %r14, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0xa5530
leaq 0x8(%rsp), %rdi
callq 0x21296
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x28b50
movq %rax, %r14
leaq 0xb354c(%rip), %rsi     # 0xd7966
movq %rax, %rdi
callq 0x3c350
leaq 0xf7c47(%rip), %rsi     # 0x11c070
leaq 0xe5a0(%rip), %rdx      # 0x329d0
movq %r14, %rdi
callq 0x29ba0
jmp 0x2449c
pushq $0x10
popq %rdi
callq 0x28b50
movq %rax, %r14
leaq 0xb3530(%rip), %rsi     # 0xd797c
movq %rax, %rdi
callq 0x3c350
leaq 0xf7c15(%rip), %rsi     # 0x11c070
leaq 0xe56e(%rip), %rdx      # 0x329d0
movq %r14, %rdi
callq 0x29ba0
jmp 0x2449c
pushq $0x10
popq %rdi
callq 0x28b50
movq %rax, %r14
leaq 0xb351b(%rip), %rsi     # 0xd7999
movq %rax, %rdi
callq 0x3c350
leaq 0xf7be3(%rip), %rsi     # 0x11c070
leaq 0xe53c(%rip), %rdx      # 0x329d0
movq %r14, %rdi
callq 0x29ba0
jmp 0x244a0
jmp 0x244a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x28bb0
jmp 0x244b6
jmp 0x244b3
jmp 0x244b3
jmp 0x244b3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21296
movq %rbx, %rdi
callq 0xd3bc0
// File: /workspace/github_cpp_makefile_star2_O2/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_data_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_data_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_data);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);
            return out;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x2, 0x28(%rdx)
jne 0x24ae1
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %cl
jne 0x24a8d
movups (%r14), %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rsp, %r12
pushq $0x9
popq %rcx
movq %r12, %rdi
movl %r8d, %edx
callq 0x251c9
movups (%r12), %xmm0
movups %xmm0, (%r14)
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x24a9f
movq %rdx, %rsi
movq 0x18(%r15), %rdx
jmp 0x24aa6
leaq 0xfda5b(%rip), %rsi     # 0x122501
addq %rsi, %rdx
movups (%r14), %xmm0
leaq 0x10(%rsp), %r8
movaps %xmm0, (%r8)
movq %rsp, %r15
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x253d0
movups (%r15), %xmm0
movups %xmm0, (%r14)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xb3021(%rip), %rdi     # 0xd7b09
leaq 0xb2ec7(%rip), %rsi     # 0xd79b6
leaq 0xb302d(%rip), %rcx     # 0xd7b23
movl $0xf2, %edx
callq 0x19150
// File: /workspace/github_cpp_makefile_star2_O2/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_cdata_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_cdata_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_cdata);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'); ++out;
            *out = Ch('!'); ++out;
            *out = Ch('['); ++out;
            *out = Ch('C'); ++out;
            *out = Ch('D'); ++out;
            *out = Ch('A'); ++out;
            *out = Ch('T'); ++out;
            *out = Ch('A'); ++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 $0x3, 0x28(%rdx)
jne 0x24c7e
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %cl
jne 0x24b4c
movups (%r14), %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rsp, %r12
pushq $0x9
popq %rcx
movq %r12, %rdi
movl %r8d, %edx
callq 0x251c9
movups (%r12), %xmm0
movups %xmm0, (%r14)
movq %rsp, %r12
movb $0x3c, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x21, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x5b, %bpl
movb %bpl, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x43, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x44, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x41, %r13b
movb %r13b, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x54, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb %r13b, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb %bpl, (%r12)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x24c08
movq %rdx, %rsi
movq 0x18(%r15), %rdx
jmp 0x24c0f
leaq 0xfd8f2(%rip), %rsi     # 0x122501
addq %rsi, %rdx
movups (%r14), %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rsp, %r15
movq %r15, %rdi
callq 0x2520c
movups (%r15), %xmm0
movups %xmm0, (%r14)
movb $0x5d, %bpl
movb %bpl, (%r15)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x251a4
movb %bpl, (%r15)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x251a4
movb $0x3e, (%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
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 0xb2f20(%rip), %rdi     # 0xd7ba5
leaq 0xb2d2a(%rip), %rsi     # 0xd79b6
leaq 0xb2f2d(%rip), %rcx     # 0xd7bc0
movl $0xfd, %edx
callq 0x19150
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %bpl
jne 0x24ce2
movups (%r14), %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rsp, %r12
pushq $0x9
popq %rcx
movq %r12, %rdi
movl %r8d, %edx
callq 0x251c9
movups (%r12), %xmm0
movups %xmm0, (%r14)
movq %rsp, %r12
movb $0x3c, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x3f, %r13b
movb %r13b, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x78, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x6d, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x6c, (%r12)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
movups (%r14), %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x25249
movups (%r12), %xmm0
movups %xmm0, (%r14)
movb %r13b, (%r12)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x251a4
movb $0x3e, (%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
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
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
cmpl $0x4, 0x28(%rdx)
jne 0x24eb6
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %cl
jne 0x24de9
movups (%r14), %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rsp, %r12
pushq $0x9
popq %rcx
movq %r12, %rdi
movl %r8d, %edx
callq 0x251c9
movups (%r12), %xmm0
movups %xmm0, (%r14)
movq %rsp, %r12
movb $0x3c, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x21, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x2d, %bpl
movb %bpl, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb %bpl, (%r12)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x24e45
movq %rdx, %rsi
movq 0x18(%r15), %rdx
jmp 0x24e4c
leaq 0xfd6b5(%rip), %rsi     # 0x122501
addq %rsi, %rdx
movups (%r14), %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rsp, %r15
movq %r15, %rdi
callq 0x2520c
movups (%r15), %xmm0
movups %xmm0, (%r14)
movb %bpl, (%r15)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x251a4
movb %bpl, (%r15)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x251a4
movb $0x3e, (%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb2d86(%rip), %rdi     # 0xd7c43
leaq 0xb2af2(%rip), %rsi     # 0xd79b6
leaq 0xb2d95(%rip), %rcx     # 0xd7c60
movl $0x163, %edx            # imm = 0x163
callq 0x19150
// File: /workspace/github_cpp_makefile_star2_O2/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_doctype_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_doctype_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
        {
            assert(node->type() == node_doctype);
            if (!(flags & print_no_indenting))
                out = fill_chars(out, indent, Ch('\t'));
            *out = Ch('<'), ++out;
            *out = Ch('!'), ++out;
            *out = Ch('D'), ++out;
            *out = Ch('O'), ++out;
            *out = Ch('C'), ++out;
            *out = Ch('T'), ++out;
            *out = Ch('Y'), ++out;
            *out = Ch('P'), ++out;
            *out = Ch('E'), ++out;
            *out = Ch(' '), ++out;
            out = copy_chars(node->value(), node->value() + node->value_size(), out);
            *out = Ch('>'), ++out;
            return out;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x6, 0x28(%rdx)
jne 0x25039
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %cl
jne 0x24f1e
movups (%r14), %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rsp, %r12
pushq $0x9
popq %rcx
movq %r12, %rdi
movl %r8d, %edx
callq 0x251c9
movups (%r12), %xmm0
movups %xmm0, (%r14)
movq %rsp, %r12
movb $0x3c, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x21, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x44, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x4f, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x43, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x54, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x59, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x50, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x45, (%r12)
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x20, (%r12)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x24feb
movq %rdx, %rsi
movq 0x18(%r15), %rdx
jmp 0x24ff2
leaq 0xfd50f(%rip), %rsi     # 0x122501
addq %rsi, %rdx
movups (%r14), %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rsp, %r15
movq %r15, %rdi
callq 0x2520c
movups (%r15), %xmm0
movups %xmm0, (%r14)
movb $0x3e, (%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xb2ca5(%rip), %rdi     # 0xd7ce5
leaq 0xb296f(%rip), %rsi     # 0xd79b6
leaq 0xb2cb4(%rip), %rcx     # 0xd7d02
movl $0x175, %edx            # imm = 0x175
callq 0x19150
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25185
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %cl
jne 0x250a4
movups (%r14), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
movq %rsp, %r12
pushq $0x9
popq %rcx
movq %r12, %rdi
movl %r8d, %edx
callq 0x251c9
movups (%r12), %xmm0
movups %xmm0, (%r14)
movq %rsp, %r12
movb $0x3c, (%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x251a4
movb $0x3f, %bpl
movb %bpl, (%r12)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
movq (%r15), %rdx
leaq 0xfd42e(%rip), %r12     # 0x122501
testq %rdx, %rdx
je 0x250e1
movq %rdx, %rsi
movq 0x10(%r15), %rdx
jmp 0x250e4
movq %r12, %rsi
addq %rsi, %rdx
movups (%r14), %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rsp, %r13
movq %r13, %rdi
callq 0x2520c
movups (%r13), %xmm0
movups %xmm0, (%r14)
movb $0x20, (%r13)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x25127
movq %rdx, %r12
movq 0x18(%r15), %rdx
addq %r12, %rdx
movups (%r14), %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2520c
movups (%r15), %xmm0
movups %xmm0, (%r14)
movb %bpl, (%r15)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x251a4
movb $0x3e, (%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x251a4
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 0xb2bfb(%rip), %rdi     # 0xd7d87
leaq 0xb2823(%rip), %rsi     # 0xd79b6
leaq 0xb2c05(%rip), %rcx     # 0xd7d9f
movl $0x18b, %edx            # imm = 0x18B
callq 0x19150