LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgIntList::getValue(int*, int, char**)
bool CmdArgIntList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  long val;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  val = strtol(tok, (char **)&ptr, 0);
	  if (ptr == tok)
	    {
	      cout << "invalid integer value \"" << tok << "\"" << endl;
	      return false;
	    }
	  insert(val);
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x1b35b
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6050
movq 0x58(%rbx), %rsi
movq %rax, %rdi
callq 0x61a0
testq %rax, %rax
je 0x1b2de
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x65c0
cmpq %r14, 0x8(%rsp)
je 0x1b2ef
movq %rbx, %rdi
movl %eax, %esi
callq 0x1b8d0
movq 0x58(%rbx), %rsi
xorl %edi, %edi
callq 0x61a0
movq %rax, %r14
testq %rax, %rax
jne 0x1b2ad
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1b908
movq 0x2bc8a(%rip), %rbx     # 0x46f80
leaq 0x171de(%rip), %rsi     # 0x324db
movl $0x17, %edx
movq %rbx, %rdi
callq 0x6690
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6690
leaq 0x1720d(%rip), %rsi     # 0x32534
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6690
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6730
movsbl %al, %esi
movq %rbx, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6340
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgFloatList::getValue(int*, int, char**)
bool CmdArgFloatList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  double val;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  val = strtod(tok, (char **)&ptr);
	  if (ptr == tok)
	    {
	      cout << "invalid float value \"" << tok << "\"" << endl;
	      return false;
	    }
	  insert(val);
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x1b4f1
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6050
movq 0x58(%rbx), %rsi
movq %rax, %rdi
callq 0x61a0
testq %rax, %rax
je 0x1b474
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6840
cmpq %r14, 0x8(%rsp)
je 0x1b485
movq %rbx, %rdi
callq 0x1bb2e
movq 0x58(%rbx), %rsi
xorl %edi, %edi
callq 0x61a0
movq %rax, %r14
testq %rax, %rax
jne 0x1b447
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1bb74
movq 0x2baf4(%rip), %rbx     # 0x46f80
leaq 0x17061(%rip), %rsi     # 0x324f4
movl $0x15, %edx
movq %rbx, %rdi
callq 0x6690
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6690
leaq 0x17077(%rip), %rsi     # 0x32534
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6690
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6730
movsbl %al, %esi
movq %rbx, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6340
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgStrList::getValue(int*, int, char**)
bool CmdArgStrList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  insert(strdup(tok));
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x1b5e4
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6050
movq 0x58(%rbx), %rsi
movq %rax, %rdi
callq 0x61a0
testq %rax, %rax
je 0x1b5e8
movq %rax, %rdi
callq 0x6050
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1bd9a
movq 0x58(%rbx), %rsi
xorl %edi, %edi
jmp 0x1b5bf
xorl %eax, %eax
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x1bdd6
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgCharList::getValue(int*, int, char**)
bool CmdArgCharList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  if (strlen(tok) != 1)
	    {
	      cout << "invalid char value \"" << tok << "\"" << endl;
	      return false;
	    }
	  insert(tok[0]);
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x1b76f
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6050
movq 0x58(%rbx), %rsi
movq %rax, %rdi
callq 0x61a0
testq %rax, %rax
je 0x1b6f4
movq %rax, %r14
movq %r14, %rdi
callq 0x6270
cmpq $0x1, %rax
jne 0x1b703
movsbl (%r14), %esi
movq %rbx, %rdi
callq 0x1bffc
movq 0x58(%rbx), %rsi
xorl %edi, %edi
callq 0x61a0
movq %rax, %r14
testq %rax, %rax
jne 0x1b6c7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1c036
movq 0x2b876(%rip), %rbx     # 0x46f80
leaq 0x16e10(%rip), %rsi     # 0x32521
movl $0x14, %edx
movq %rbx, %rdi
callq 0x6690
movq %r14, %rdi
callq 0x6270
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6690
leaq 0x16df9(%rip), %rsi     # 0x32534
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6690
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6730
movsbl %al, %esi
movq %rbx, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6340
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/clap/include/cmdarg.hh
// Function: CmdArgTypeList<int>::CmdArgTypeList(char, char const*, char const*, char const*, unsigned int, int, int, char const*)
CmdArgTypeList(const char   optChar,
		 const char*  keyword,
		 const char*  valueName,
		 const char*  description,
		 unsigned int syntaxFlags = (isREQ | isVALREQ),
		 int          minSize = 1,
		 int          maxSize = 100,
		 const char*  delim = ",-~/.")
    :   CmdArg(optChar, keyword, valueName, description, syntaxFlags),
	_delimiters(delim), _min(minSize),_max(maxSize)    
  {
    char buf[512];
    sprintf(buf, "%s1%c...%c%sn", getValueName(), _delimiters[0],
	    _delimiters[0], getValueName());
    setValueName(buf);
    sprintf(buf, "%s (%d <= n <= %d)", description, _min, _max);
    setDescription(buf);
    for (int i = 0; i < strlen(delim); i++){
      if (delim[i] == ' '){
	cout << "ERROR: space can't be a delimiter" << endl;
	exit(0);}}
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %r8, %r15
movq %rdi, %r14
movq 0x250(%rsp), %rbx
movl 0x240(%rsp), %ebp
movl 0x248(%rsp), %r12d
leaq 0x2b001(%rip), %rax     # 0x467b0
movq %rax, (%rdi)
movb %sil, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movl %r9d, 0x28(%rdi)
movl $0x0, 0x2c(%rdi)
callq 0x1a94e
leaq 0x2b2cf(%rip), %rax     # 0x46aa8
movq %rax, (%r14)
leaq 0x30(%r14), %r13
movq %r13, 0x38(%r14)
movq %r13, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r14)
movq %rbx, 0x58(%r14)
movl %r12d, 0x60(%r14)
movl %ebp, 0x64(%r14)
movq 0x18(%r14), %rdx
movsbl (%rbx), %ecx
leaq 0x16d2c(%rip), %rsi     # 0x32536
movq %rsp, %r12
movq %r12, %rdi
movl %ecx, %r8d
movq %rdx, %r9
xorl %eax, %eax
callq 0x6700
movq %r12, %rdi
callq 0x6050
movq %rax, 0x18(%r14)
movl 0x60(%r14), %r8d
movl 0x64(%r14), %ecx
leaq 0x16d0c(%rip), %rsi     # 0x32544
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x6700
movq %r12, %rdi
callq 0x6050
movq %rax, 0x20(%r14)
movq %rbx, %rdi
callq 0x6270
testq %rax, %rax
je 0x1b86e
xorl %ecx, %ecx
cmpb $0x20, (%rbx,%rcx)
je 0x1b880
incq %rcx
cmpq %rcx, %rax
jne 0x1b860
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2b6f9(%rip), %rdi     # 0x46f80
leaq 0x16cc9(%rip), %rsi     # 0x32557
movl $0x21, %edx
callq 0x6690
movq 0x2b6e1(%rip), %rdi     # 0x46f80
callq 0x66e0
xorl %edi, %edi
callq 0x6470
movq %rax, %rbx
movq (%r13), %rdi
cmpq %r13, %rdi
je 0x1b8c7
movq (%rdi), %r14
callq 0x63b0
movq %r14, %rdi
cmpq %r13, %r14
jne 0x1b8b7
movq %rbx, %rdi
callq 0x6430
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/clap/include/cmdarg.hh
// Function: CmdArgTypeList<int>::validate()
bool         validate     (){
    if (_list.size() < _min) {
      cout << "too few argument to the switch -" << getKeyword() << endl;
      return false;
    }
    if (_list.size() > _max) {
      cout << "too many argument to the switch -" << getKeyword() << endl;
      return false;
    }
    reset();
    setParseOK();
    return true;    
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x40(%rdi), %rax
movslq 0x64(%rdi), %rcx
cmpq %rcx, %rax
jae 0x1b931
movq 0x2b65d(%rip), %rbx     # 0x46f80
leaq 0x16c4f(%rip), %rsi     # 0x32579
movl $0x20, %edx
jmp 0x1b951
movslq 0x60(%r14), %rcx
cmpq %rcx, %rax
jbe 0x1b9c0
movq 0x2b63b(%rip), %rbx     # 0x46f80
leaq 0x16c4e(%rip), %rsi     # 0x3259a
movl $0x21, %edx
movq %rbx, %rdi
callq 0x6690
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1b97e
movq %r14, %rdi
callq 0x6270
movq 0x2b60f(%rip), %rdi     # 0x46f80
movq %r14, %rsi
movq %rax, %rdx
callq 0x6690
jmp 0x1b995
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x67b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6730
movsbl %al, %esi
movq %rbx, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6340
xorl %eax, %eax
jmp 0x1b9d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
orb $0x4, 0x2c(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/clap/src/cmdline.cc
// Function: CmdLine::CmdLine(char*, CmdArg*, ...)
CmdLine::CmdLine(char *progName, CmdArg *cmds ...) :
  _progName(progName), _maxLength(0)
{
  va_list args;
  va_start(args, cmds);
  for (CmdArg* arg = cmds; arg; arg = va_arg(args, CmdArg*))
    {
      _cmdList.push_front(arg);
      _maxLength = std::max((long)_maxLength, (long)strlen(arg->getValueName()));
    }
  va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r14
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x1c27b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movl $0x0, 0x20(%rdi)
movq %rdx, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rsp)
testq %r14, %r14
je 0x1c32b
movq %rdi, %rbx
movq (%rbx), %r15
movl $0x18, %edi
callq 0x60f0
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x6150
incq 0x10(%rbx)
movslq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x1abd0
movq %rax, %rdi
callq 0x6270
cmpq %r15, %rax
cmovgq %rax, %r15
movl %r15d, 0x20(%rbx)
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x1c315
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x1c323
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
jne 0x1c2bd
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1c33a
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x1c355
movq (%rdi), %r15
callq 0x63b0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x1c345
movq %r14, %rdi
callq 0x6430
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_writer_stream::write(void const*, unsigned long)
PUGI__FN void xml_writer_stream::write(const void* data, size_t size)
	{
		if (narrow_stream)
		{
			assert(!wide_stream);
			narrow_stream->write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
		}
		else
		{
			assert(wide_stream);
			assert(size % sizeof(wchar_t) == 0);

			wide_stream->write(reinterpret_cast<const wchar_t*>(data), static_cast<std::streamsize>(size / sizeof(wchar_t)));
		}
	}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
testq %rax, %rax
je 0x1cafc
testq %rdi, %rdi
jne 0x1cb10
movq %rax, %rdi
popq %rax
jmp 0x6330
testq %rdi, %rdi
je 0x1cb2f
testb $0x3, %dl
jne 0x1cb4e
shrq $0x2, %rdx
popq %rax
jmp 0x6160
leaq 0x163d1(%rip), %rdi     # 0x32ee8
leaq 0x163d7(%rip), %rsi     # 0x32ef5
leaq 0x163e4(%rip), %rcx     # 0x32f09
movl $0x13c2, %edx           # imm = 0x13C2
callq 0x6120
leaq 0x163b3(%rip), %rdi     # 0x32ee9
leaq 0x163b8(%rip), %rsi     # 0x32ef5
leaq 0x163c5(%rip), %rcx     # 0x32f09
movl $0x13c7, %edx           # imm = 0x13C7
callq 0x6120
leaq 0x163f6(%rip), %rdi     # 0x32f4b
leaq 0x16399(%rip), %rsi     # 0x32ef5
leaq 0x163a6(%rip), %rcx     # 0x32f09
movl $0x13c8, %edx           # imm = 0x13C8
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: bool pugi::impl::(anonymous namespace)::set_value_integer<unsigned int, char*, unsigned long>(char*&, unsigned long&, unsigned long, unsigned int, bool)
PUGI__FN bool set_value_integer(String& dest, Header& header, uintptr_t header_mask, U value, bool negative)
	{
		char_t buf[64];
		char_t* end = buf + sizeof(buf) / sizeof(buf[0]);
		char_t* begin = integer_to_string(buf, end, value, negative);

		return strcpy_insitu(dest, header, header_mask, begin, end - begin);
	}

// Assembly:
pushq %rbx
subq $0x40, %rsp
leaq 0x3f(%rsp), %rax
movl %edx, %r9d
negl %r9d
testl %ecx, %ecx
cmovel %edx, %r9d
leal 0x1(%rcx), %edx
movzbl %dl, %r8d
andl $0x1, %r8d
decq %r8
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %r9d, %r10d
imulq %rdx, %r10
shrq $0x23, %r10
leal (%r10,%r10), %r11d
leal (%r11,%r11,4), %r11d
movl %r9d, %ebx
subl %r11d, %ebx
orb $0x30, %bl
movb %bl, (%rax)
decq %rax
decq %r8
cmpl $0x9, %r9d
movl %r10d, %r9d
ja 0x1d2f4
movq %rsp, %rdx
cmpq %rdx, %rax
jb 0x1d348
movb $0x2d, (%rax)
xorb $0x1, %cl
movzbl %cl, %ecx
addq %rax, %rcx
negq %r8
movl $0x10, %edx
callq 0x1d06a
addq $0x40, %rsp
popq %rbx
retq
leaq 0x190f4(%rip), %rdi     # 0x36443
leaq 0x15b9f(%rip), %rsi     # 0x32ef5
leaq 0x190f6(%rip), %rcx     # 0x36453
movl $0x120b, %edx           # imm = 0x120B
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::child(char const*) const
PUGI__FN xml_node xml_node::child(const char_t* name_) const
	{
		if (!_root) return xml_node();

		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);

		return xml_node();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1d64a
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0x1d64c
movq %rsi, %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1d63f
movq %r14, %rdi
callq 0x1d71d
testb %al, %al
jne 0x1d64c
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d62a
jmp 0x1d64c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::attribute(char const*) const
PUGI__FN xml_attribute xml_node::attribute(const char_t* name_) const
	{
		if (!_root) return xml_attribute();

		for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
			if (i->name && impl::strequal(name_, i->name))
				return xml_attribute(i);

		return xml_attribute();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1d78c
movq 0x38(%rax), %rbx
testq %rbx, %rbx
je 0x1d78e
movq %rsi, %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1d781
movq %r14, %rdi
callq 0x1d71d
testb %al, %al
jne 0x1d78e
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d76c
jmp 0x1d78e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::next_sibling(char const*) const
PUGI__FN xml_node xml_node::next_sibling(const char_t* name_) const
	{
		if (!_root) return xml_node();

		for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);

		return xml_node();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1d7d2
movq 0x30(%rax), %rbx
testq %rbx, %rbx
je 0x1d7d4
movq %rsi, %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1d7c7
movq %r14, %rdi
callq 0x1d71d
testb %al, %al
jne 0x1d7d4
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x1d7b2
jmp 0x1d7d4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::previous_sibling(char const*) const
PUGI__FN xml_node xml_node::previous_sibling(const char_t* name_) const
	{
		if (!_root) return xml_node();

		for (xml_node_struct* i = _root->prev_sibling_c; i->next_sibling; i = i->prev_sibling_c)
			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);

		return xml_node();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1d82a
movq 0x28(%rax), %rbx
cmpq $0x0, 0x30(%rbx)
je 0x1d82a
movq %rsi, %r14
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1d81f
movq %r14, %rdi
callq 0x1d71d
testb %al, %al
jne 0x1d82c
movq 0x28(%rbx), %rbx
cmpq $0x0, 0x30(%rbx)
jne 0x1d80a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::attribute(char const*, pugi::xml_attribute&) const
PUGI__FN xml_attribute xml_node::attribute(const char_t* name_, xml_attribute& hint_) const
	{
		xml_attribute_struct* hint = hint_._attr;

		// if hint is not an attribute of node, behavior is not defined
		assert(!hint || (_root && impl::is_attribute_of(hint, _root)));

		if (!_root) return xml_attribute();

		// optimistically search from hint up until the end
		for (xml_attribute_struct* i = hint; i; i = i->next_attribute)
			if (i->name && impl::strequal(name_, i->name))
			{
				// update hint to maximize efficiency of searching for consecutive attributes
				hint_._attr = i->next_attribute;

				return xml_attribute(i);
			}

		// wrap around and search from the first attribute until the hint
		// 'j' null pointer check is technically redundant, but it prevents a crash in case the assertion above fails
		for (xml_attribute_struct* j = _root->first_attribute; j && j != hint; j = j->next_attribute)
			if (j->name && impl::strequal(name_, j->name))
			{
				// update hint to maximize efficiency of searching for consecutive attributes
				hint_._attr = j->next_attribute;

				return xml_attribute(j);
			}

		return xml_attribute();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %r12
testq %r12, %r12
je 0x1d87c
movq (%r15), %rax
testq %rax, %rax
je 0x1d903
addq $0x38, %rax
movq (%rax), %rcx
cmpq %r12, %rcx
je 0x1d873
leaq 0x20(%rcx), %rax
testq %rcx, %rcx
jne 0x1d862
testq %rcx, %rcx
je 0x1d903
cmpq $0x0, (%r15)
je 0x1d8bf
testq %r12, %r12
je 0x1d8a8
movq %r12, %r13
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x1d89f
movq %r14, %rdi
callq 0x1d71d
testb %al, %al
jne 0x1d8ec
movq 0x20(%r13), %r13
testq %r13, %r13
jne 0x1d88a
movq (%r15), %rax
movq 0x38(%rax), %r13
testq %r13, %r13
sete %al
cmpq %r12, %r13
sete %cl
orb %al, %cl
je 0x1d8c4
xorl %r15d, %r15d
jmp 0x1d8f6
xorl %r15d, %r15d
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x1d8dc
movq %r14, %rdi
callq 0x1d71d
testb %al, %al
jne 0x1d8ec
movq 0x20(%r13), %r13
testq %r13, %r13
je 0x1d8f6
cmpq %r12, %r13
jne 0x1d8c7
jmp 0x1d8f6
movq 0x20(%r13), %rax
movq %rax, (%rbx)
movq %r13, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1565d(%rip), %rdi     # 0x32f67
leaq 0x155e4(%rip), %rsi     # 0x32ef5
leaq 0x15686(%rip), %rcx     # 0x32f9e
movl $0x159e, %edx           # imm = 0x159E
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::child_value() const
PUGI__FN const char_t* xml_node::child_value() const
	{
		if (!_root) return PUGIXML_TEXT("");

		// element nodes can have value if parse_embed_pcdata was used
		if (PUGI__NODETYPE(_root) == node_element && _root->value)
			return _root->value;

		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
			if (impl::is_text_node(i) && i->value)
				return i->value;

		return PUGIXML_TEXT("");
	}

// Assembly:
movq (%rdi), %rdx
leaq 0x1378f(%rip), %rcx     # 0x31109
testq %rdx, %rdx
je 0x1d9b8
movl (%rdx), %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x1d993
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x1d993
retq
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
je 0x1d9b8
movl (%rdx), %eax
andl $0xf, %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x1d9b2
movq 0x10(%rdx), %rax
testq %rax, %rax
jne 0x1d992
movq 0x30(%rdx), %rdx
jmp 0x1d997
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::append_attribute(char const*)
PUGI__FN xml_attribute xml_node::append_attribute(const char_t* name_)
	{
		if (!impl::allow_insert_attribute(type())) return xml_attribute();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_attribute();

		xml_attribute a(impl::allocate_attribute(alloc));
		if (!a) return xml_attribute();

		impl::append_attribute(a._attr, _root);

		a.set_name(name_);

		return a;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x1daf1
movl (%rax), %ecx
andl $0xf, %ecx
jmp 0x1daf3
xorl %ecx, %ecx
cmpl $0x7, %ecx
je 0x1db01
cmpl $0x2, %ecx
jne 0x1db88
testq %rax, %rax
je 0x1dbbf
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x28(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1dbb0
movq (%rdi), %rdx
addq %rdx, %rax
addq $0x28, %rax
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %rax, %rax
je 0x1db5f
movq %rax, %rcx
subq (%rsp), %rcx
shlq $0x8, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq %rcx, (%rax)
jmp 0x1db61
xorl %eax, %eax
movq %rax, (%rsp)
testq %rax, %rax
je 0x1db88
movq (%r14), %rdx
movq 0x38(%rdx), %rcx
testq %rcx, %rcx
je 0x1db8c
movq 0x18(%rcx), %rdx
addq $0x18, %rcx
movq %rax, 0x20(%rdx)
movq %rdx, 0x18(%rax)
jmp 0x1db94
xorl %eax, %eax
jmp 0x1dba8
movq %rax, 0x38(%rdx)
leaq 0x18(%rax), %rcx
movq %rax, (%rcx)
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d02e
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsp, %rdx
movl $0x28, %esi
callq 0x28a84
jmp 0x1db3f
leaq 0x15e30(%rip), %rdi     # 0x339f6
leaq 0x15328(%rip), %rsi     # 0x32ef5
leaq 0x186df(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::prepend_attribute(char const*)
PUGI__FN xml_attribute xml_node::prepend_attribute(const char_t* name_)
	{
		if (!impl::allow_insert_attribute(type())) return xml_attribute();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_attribute();

		xml_attribute a(impl::allocate_attribute(alloc));
		if (!a) return xml_attribute();

		impl::prepend_attribute(a._attr, _root);

		a.set_name(name_);

		return a;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x1dbf7
movl (%rax), %ecx
andl $0xf, %ecx
jmp 0x1dbf9
xorl %ecx, %ecx
cmpl $0x7, %ecx
je 0x1dc07
cmpl $0x2, %ecx
jne 0x1dc8a
testq %rax, %rax
je 0x1dcc5
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x28(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1dcb6
movq (%rdi), %rdx
addq %rdx, %rax
addq $0x28, %rax
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %rax, %rax
je 0x1dc65
movq %rax, %rcx
subq (%rsp), %rcx
shlq $0x8, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq %rcx, (%rax)
jmp 0x1dc67
xorl %eax, %eax
movq %rax, (%rsp)
testq %rax, %rax
je 0x1dc8a
movq (%r14), %rcx
movq 0x38(%rcx), %rdx
testq %rdx, %rdx
je 0x1dc8e
leaq 0x18(%rdx), %rsi
movq 0x18(%rdx), %rdi
movq %rdi, 0x18(%rax)
jmp 0x1dc92
xorl %eax, %eax
jmp 0x1dcae
leaq 0x18(%rax), %rsi
movq %rax, (%rsi)
movq %rdx, 0x20(%rax)
movq %rax, 0x38(%rcx)
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d02e
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsp, %rdx
movl $0x28, %esi
callq 0x28a84
jmp 0x1dc45
leaq 0x15d2a(%rip), %rdi     # 0x339f6
leaq 0x15222(%rip), %rsi     # 0x32ef5
leaq 0x185d9(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_attribute_after(char const*, pugi::xml_attribute const&)
PUGI__FN xml_attribute xml_node::insert_attribute_after(const char_t* name_, const xml_attribute& attr)
	{
		if (!impl::allow_insert_attribute(type())) return xml_attribute();
		if (!attr || !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_attribute();

		xml_attribute a(impl::allocate_attribute(alloc));
		if (!a) return xml_attribute();

		impl::insert_attribute_after(a._attr, attr._attr, _root);

		a.set_name(name_);

		return a;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x1dd05
movl (%rax), %ecx
andl $0xf, %ecx
jmp 0x1dd07
xorl %ecx, %ecx
cmpl $0x7, %ecx
je 0x1dd15
cmpl $0x2, %ecx
jne 0x1dde6
movq (%r15), %rcx
testq %rcx, %rcx
je 0x1dde6
leaq 0x38(%rax), %rsi
movq (%rsi), %rdx
cmpq %rcx, %rdx
je 0x1dd36
leaq 0x20(%rdx), %rsi
testq %rdx, %rdx
jne 0x1dd25
testq %rdx, %rdx
je 0x1dde6
testq %rax, %rax
je 0x1de06
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x28(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1ddf2
movq (%rdi), %rdx
addq %rdx, %rax
addq $0x28, %rax
movq %rcx, 0x8(%rdi)
movq %rdx, 0x8(%rsp)
testq %rax, %rax
je 0x1dd9f
movq %rax, %rcx
subq 0x8(%rsp), %rcx
shlq $0x8, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq %rcx, (%rax)
jmp 0x1dda1
xorl %eax, %eax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1dde6
movq (%r15), %rcx
movq 0x20(%rcx), %rdx
movq %rdx, %rsi
testq %rdx, %rdx
jne 0x1ddc1
movq (%r14), %rsi
movq 0x38(%rsi), %rsi
movq %rax, 0x18(%rsi)
movq %rdx, 0x20(%rax)
movq %rcx, 0x18(%rax)
movq %rax, 0x20(%rcx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d02e
movq (%r14), %rax
jmp 0x1dde8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdx
movl $0x28, %esi
callq 0x28a84
jmp 0x1dd7e
leaq 0x15be9(%rip), %rdi     # 0x339f6
leaq 0x150e1(%rip), %rsi     # 0x32ef5
leaq 0x18498(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_attribute_before(char const*, pugi::xml_attribute const&)
PUGI__FN xml_attribute xml_node::insert_attribute_before(const char_t* name_, const xml_attribute& attr)
	{
		if (!impl::allow_insert_attribute(type())) return xml_attribute();
		if (!attr || !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_attribute();

		xml_attribute a(impl::allocate_attribute(alloc));
		if (!a) return xml_attribute();

		impl::insert_attribute_before(a._attr, attr._attr, _root);

		a.set_name(name_);

		return a;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x1de47
movl (%rax), %ecx
andl $0xf, %ecx
jmp 0x1de49
xorl %ecx, %ecx
cmpl $0x7, %ecx
je 0x1de57
cmpl $0x2, %ecx
jne 0x1df2c
movq (%r15), %rcx
testq %rcx, %rcx
je 0x1df2c
leaq 0x38(%rax), %rsi
movq (%rsi), %rdx
cmpq %rcx, %rdx
je 0x1de78
leaq 0x20(%rdx), %rsi
testq %rdx, %rdx
jne 0x1de67
testq %rdx, %rdx
je 0x1df2c
testq %rax, %rax
je 0x1df4c
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x28(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1df38
movq (%rdi), %rdx
addq %rdx, %rax
addq $0x28, %rax
movq %rcx, 0x8(%rdi)
movq %rdx, 0x8(%rsp)
testq %rax, %rax
je 0x1dee1
movq %rax, %rcx
subq 0x8(%rsp), %rcx
shlq $0x8, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq %rcx, (%rax)
jmp 0x1dee3
xorl %eax, %eax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1df2c
movq (%r15), %rcx
movq 0x18(%rcx), %rdx
leaq 0x20(%rdx), %rsi
movq (%r14), %rdi
addq $0x38, %rdi
cmpq $0x0, 0x20(%rdx)
cmovneq %rsi, %rdi
movq %rax, (%rdi)
movq %rdx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rax, 0x18(%rcx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d02e
movq (%r14), %rax
jmp 0x1df2e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdx
movl $0x28, %esi
callq 0x28a84
jmp 0x1dec0
leaq 0x15aa3(%rip), %rdi     # 0x339f6
leaq 0x14f9b(%rip), %rsi     # 0x32ef5
leaq 0x18352(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::append_copy(pugi::xml_attribute const&)
PUGI__FN xml_attribute xml_node::append_copy(const xml_attribute& proto)
	{
		if (!proto) return xml_attribute();
		if (!impl::allow_insert_attribute(type())) return xml_attribute();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_attribute();

		xml_attribute a(impl::allocate_attribute(alloc));
		if (!a) return xml_attribute();

		impl::append_attribute(a._attr, _root);
		impl::node_copy_attribute(a._attr, proto._attr);

		return a;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorl %r14d, %r14d
cmpq $0x0, (%rsi)
je 0x1e04b
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rax
testq %rax, %rax
je 0x1df97
movl (%rax), %r14d
andl $0xf, %r14d
cmpl $0x7, %r14d
je 0x1dfa7
cmpl $0x2, %r14d
jne 0x1e030
testq %rax, %rax
je 0x1e06f
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x28(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1e058
movq (%rdi), %rdx
leaq (%rdx,%rax), %r14
addq $0x28, %r14
movq %rcx, 0x8(%rdi)
movq %rdx, 0x8(%rsp)
testq %r14, %r14
je 0x1e00a
movq %r14, %rax
subq 0x8(%rsp), %rax
shlq $0x8, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x8(%r14)
movq %rax, (%r14)
jmp 0x1e00d
xorl %r14d, %r14d
testq %r14, %r14
je 0x1e030
movq (%r15), %rcx
movq 0x38(%rcx), %rax
testq %rax, %rax
je 0x1e035
movq 0x18(%rax), %rcx
addq $0x18, %rax
movq %r14, 0x20(%rcx)
movq %rcx, 0x18(%r14)
jmp 0x1e03d
xorl %r14d, %r14d
jmp 0x1e04b
movq %r14, 0x38(%rcx)
leaq 0x18(%r14), %rax
movq %r14, (%rax)
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1e08e
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdx
movl $0x28, %esi
callq 0x28a84
movq %rax, %r14
jmp 0x1dfe7
leaq 0x15980(%rip), %rdi     # 0x339f6
leaq 0x14e78(%rip), %rsi     # 0x32ef5
leaq 0x1822f(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::prepend_copy(pugi::xml_attribute const&)
PUGI__FN xml_attribute xml_node::prepend_copy(const xml_attribute& proto)
	{
		if (!proto) return xml_attribute();
		if (!impl::allow_insert_attribute(type())) return xml_attribute();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_attribute();

		xml_attribute a(impl::allocate_attribute(alloc));
		if (!a) return xml_attribute();

		impl::prepend_attribute(a._attr, _root);
		impl::node_copy_attribute(a._attr, proto._attr);

		return a;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorl %r14d, %r14d
cmpq $0x0, (%rsi)
je 0x1e1ff
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rax
testq %rax, %rax
je 0x1e14b
movl (%rax), %r14d
andl $0xf, %r14d
cmpl $0x7, %r14d
je 0x1e15b
cmpl $0x2, %r14d
jne 0x1e1e0
testq %rax, %rax
je 0x1e223
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x28(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1e20c
movq (%rdi), %rdx
leaq (%rdx,%rax), %r14
addq $0x28, %r14
movq %rcx, 0x8(%rdi)
movq %rdx, 0x8(%rsp)
testq %r14, %r14
je 0x1e1be
movq %r14, %rax
subq 0x8(%rsp), %rax
shlq $0x8, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x8(%r14)
movq %rax, (%r14)
jmp 0x1e1c1
xorl %r14d, %r14d
testq %r14, %r14
je 0x1e1e0
movq (%r15), %rax
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x1e1e5
leaq 0x18(%rcx), %rdx
movq 0x18(%rcx), %rsi
movq %rsi, 0x18(%r14)
jmp 0x1e1e9
xorl %r14d, %r14d
jmp 0x1e1ff
leaq 0x18(%r14), %rdx
movq %r14, (%rdx)
movq %rcx, 0x20(%r14)
movq %r14, 0x38(%rax)
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1e08e
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdx
movl $0x28, %esi
callq 0x28a84
movq %rax, %r14
jmp 0x1e19b
leaq 0x157cc(%rip), %rdi     # 0x339f6
leaq 0x14cc4(%rip), %rsi     # 0x32ef5
leaq 0x1807b(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_copy_after(pugi::xml_attribute const&, pugi::xml_attribute const&)
PUGI__FN xml_attribute xml_node::insert_copy_after(const xml_attribute& proto, const xml_attribute& attr)
	{
		if (!proto) return xml_attribute();
		if (!impl::allow_insert_attribute(type())) return xml_attribute();
		if (!attr || !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_attribute();

		xml_attribute a(impl::allocate_attribute(alloc));
		if (!a) return xml_attribute();

		impl::insert_attribute_after(a._attr, attr._attr, _root);
		impl::node_copy_attribute(a._attr, proto._attr);

		return a;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
cmpq $0x0, (%rsi)
je 0x1e34d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x1e26f
movl (%rax), %r12d
andl $0xf, %r12d
cmpl $0x7, %r12d
je 0x1e27f
cmpl $0x2, %r12d
jne 0x1e34a
movq (%r15), %rcx
testq %rcx, %rcx
je 0x1e34a
leaq 0x38(%rax), %rsi
movq (%rsi), %rdx
cmpq %rcx, %rdx
je 0x1e2a0
leaq 0x20(%rdx), %rsi
testq %rdx, %rdx
jne 0x1e28f
testq %rdx, %rdx
je 0x1e34a
testq %rax, %rax
je 0x1e371
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x28(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1e35c
movq (%rdi), %rdx
leaq (%rdx,%rax), %r12
addq $0x28, %r12
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %r12, %r12
je 0x1e30d
movq %r12, %rax
subq (%rsp), %rax
shlq $0x8, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
movups %xmm0, 0x8(%r12)
movq %rax, (%r12)
jmp 0x1e310
xorl %r12d, %r12d
testq %r12, %r12
je 0x1e34a
movq (%r15), %rax
movq 0x20(%rax), %rcx
movq %rcx, %rdx
testq %rcx, %rcx
jne 0x1e32b
movq (%r14), %rdx
movq 0x38(%rdx), %rdx
movq %r12, 0x18(%rdx)
movq %rcx, 0x20(%r12)
movq %rax, 0x18(%r12)
movq %r12, 0x20(%rax)
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x1e08e
jmp 0x1e34d
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsp, %rdx
movl $0x28, %esi
callq 0x28a84
movq %rax, %r12
jmp 0x1e2e8
leaq 0x1567e(%rip), %rdi     # 0x339f6
leaq 0x14b76(%rip), %rsi     # 0x32ef5
leaq 0x17f2d(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_copy_before(pugi::xml_attribute const&, pugi::xml_attribute const&)
PUGI__FN xml_attribute xml_node::insert_copy_before(const xml_attribute& proto, const xml_attribute& attr)
	{
		if (!proto) return xml_attribute();
		if (!impl::allow_insert_attribute(type())) return xml_attribute();
		if (!attr || !impl::is_attribute_of(attr._attr, _root)) return xml_attribute();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_attribute();

		xml_attribute a(impl::allocate_attribute(alloc));
		if (!a) return xml_attribute();

		impl::insert_attribute_before(a._attr, attr._attr, _root);
		impl::node_copy_attribute(a._attr, proto._attr);

		return a;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
cmpq $0x0, (%rsi)
je 0x1e49f
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x1e3bd
movl (%rax), %r12d
andl $0xf, %r12d
cmpl $0x7, %r12d
je 0x1e3cd
cmpl $0x2, %r12d
jne 0x1e49c
movq (%r15), %rcx
testq %rcx, %rcx
je 0x1e49c
leaq 0x38(%rax), %rsi
movq (%rsi), %rdx
cmpq %rcx, %rdx
je 0x1e3ee
leaq 0x20(%rdx), %rsi
testq %rdx, %rdx
jne 0x1e3dd
testq %rdx, %rdx
je 0x1e49c
testq %rax, %rax
je 0x1e4c3
movq (%rax), %rcx
shrq $0x8, %rcx
negq %rcx
movq (%rax,%rcx), %rdi
movq 0x8(%rdi), %rax
leaq 0x28(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1e4ae
movq (%rdi), %rdx
leaq (%rdx,%rax), %r12
addq $0x28, %r12
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %r12, %r12
je 0x1e45b
movq %r12, %rax
subq (%rsp), %rax
shlq $0x8, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r12)
movups %xmm0, 0x8(%r12)
movq %rax, (%r12)
jmp 0x1e45e
xorl %r12d, %r12d
testq %r12, %r12
je 0x1e49c
movq (%r15), %rax
movq 0x18(%rax), %rcx
movq (%r14), %rdx
addq $0x38, %rdx
cmpq $0x0, 0x20(%rcx)
leaq 0x20(%rcx), %rsi
cmovneq %rsi, %rdx
movq %r12, (%rdx)
movq %rcx, 0x18(%r12)
movq %rax, 0x20(%r12)
movq %r12, 0x18(%rax)
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x1e08e
jmp 0x1e49f
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsp, %rdx
movl $0x28, %esi
callq 0x28a84
movq %rax, %r12
jmp 0x1e436
leaq 0x1552c(%rip), %rdi     # 0x339f6
leaq 0x14a24(%rip), %rsi     # 0x32ef5
leaq 0x17ddb(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::append_child(pugi::xml_node_type)
PUGI__FN xml_node xml_node::append_child(xml_node_type type_)
	{
		if (!impl::allow_insert_child(type(), type_)) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::append_node(n._root, _root);

		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));

		return n;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1e4fa
movl (%rcx), %edx
andl $0xf, %edx
jmp 0x1e4fc
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x2, %ebx
jb 0x1e5e7
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x1e5e7
leal -0x9(%rbx), %eax
cmpl $-0x2, %eax
jb 0x1e524
cmpl $0x1, %edx
jne 0x1e5c0
testq %rcx, %rcx
je 0x1e601
movq (%rcx), %rax
shrq $0x8, %rax
negq %rax
movq (%rcx,%rax), %rdi
movq 0x8(%rdi), %rax
leaq 0x40(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1e5ef
movq (%rdi), %rdx
addq %rdx, %rax
addq $0x28, %rax
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %rax, %rax
je 0x1e593
movq %rax, %rcx
subq (%rsp), %rcx
shlq $0x8, %rcx
movl %ebx, %edx
orq %rcx, %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x38(%rax)
movq %rdx, (%rax)
jmp 0x1e595
xorl %eax, %eax
movq %rax, (%rsp)
testq %rax, %rax
je 0x1e5c0
movq (%r14), %rdx
movq %rdx, 0x18(%rax)
movq 0x20(%rdx), %rcx
testq %rcx, %rcx
je 0x1e5c4
movq 0x28(%rcx), %rdx
addq $0x28, %rcx
movq %rax, 0x30(%rdx)
movq %rdx, 0x28(%rax)
jmp 0x1e5cc
xorl %eax, %eax
jmp 0x1e5e7
movq %rax, 0x20(%rdx)
leaq 0x28(%rax), %rcx
movq %rax, (%rcx)
cmpl $0x7, %ebx
jne 0x1e5e3
leaq 0x14a12(%rip), %rsi     # 0x32fed
movq %rsp, %rdi
callq 0x1da24
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28a84
jmp 0x1e562
leaq 0x153ee(%rip), %rdi     # 0x339f6
leaq 0x148e6(%rip), %rsi     # 0x32ef5
leaq 0x17c9d(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::prepend_child(pugi::xml_node_type)
PUGI__FN xml_node xml_node::prepend_child(xml_node_type type_)
	{
		if (!impl::allow_insert_child(type(), type_)) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::prepend_node(n._root, _root);

		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));

		return n;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1e638
movl (%rcx), %edx
andl $0xf, %edx
jmp 0x1e63a
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x2, %ebx
jb 0x1e725
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x1e725
leal -0x9(%rbx), %eax
cmpl $-0x2, %eax
jb 0x1e662
cmpl $0x1, %edx
jne 0x1e6fa
testq %rcx, %rcx
je 0x1e73f
movq (%rcx), %rax
shrq $0x8, %rax
negq %rax
movq (%rcx,%rax), %rdi
movq 0x8(%rdi), %rax
leaq 0x40(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1e72d
movq (%rdi), %rdx
addq %rdx, %rax
addq $0x28, %rax
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %rax, %rax
je 0x1e6d1
movq %rax, %rcx
subq (%rsp), %rcx
shlq $0x8, %rcx
movl %ebx, %edx
orq %rcx, %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x38(%rax)
movq %rdx, (%rax)
jmp 0x1e6d3
xorl %eax, %eax
movq %rax, (%rsp)
testq %rax, %rax
je 0x1e6fa
movq (%r14), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rcx), %rdx
testq %rdx, %rdx
je 0x1e6fe
leaq 0x28(%rdx), %rsi
movq 0x28(%rdx), %rdi
movq %rdi, 0x28(%rax)
jmp 0x1e702
xorl %eax, %eax
jmp 0x1e725
leaq 0x28(%rax), %rsi
movq %rax, (%rsi)
movq %rdx, 0x30(%rax)
movq %rax, 0x20(%rcx)
cmpl $0x7, %ebx
jne 0x1e721
leaq 0x148d4(%rip), %rsi     # 0x32fed
movq %rsp, %rdi
callq 0x1da24
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28a84
jmp 0x1e6a0
leaq 0x152b0(%rip), %rdi     # 0x339f6
leaq 0x147a8(%rip), %rsi     # 0x32ef5
leaq 0x17b5f(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_child_before(pugi::xml_node_type, pugi::xml_node const&)
PUGI__FN xml_node xml_node::insert_child_before(xml_node_type type_, const xml_node& node)
	{
		if (!impl::allow_insert_child(type(), type_)) return xml_node();
		if (!node._root || node._root->parent != _root) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::insert_node_before(n._root, node._root);

		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));

		return n;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1e776
movl (%rcx), %edx
andl $0xf, %edx
jmp 0x1e778
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x2, %ebx
jb 0x1e7a4
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x1e7a4
leal -0x9(%rbx), %eax
cmpl $-0x2, %eax
jb 0x1e794
cmpl $0x1, %edx
jne 0x1e7a2
movq (%r14), %rax
testq %rax, %rax
je 0x1e7a2
cmpq %rcx, 0x18(%rax)
je 0x1e7ac
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testq %rcx, %rcx
je 0x1e888
movq (%rcx), %rax
shrq $0x8, %rax
negq %rax
movq (%rcx,%rax), %rdi
movq 0x8(%rdi), %rax
leaq 0x40(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1e876
movq (%rdi), %rdx
addq %rdx, %rax
addq $0x28, %rax
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %rax, %rax
je 0x1e81b
movq %rax, %rcx
subq (%rsp), %rcx
shlq $0x8, %rcx
movl %ebx, %edx
orq %rcx, %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x38(%rax)
movq %rdx, (%rax)
jmp 0x1e81d
xorl %eax, %eax
movq %rax, (%rsp)
testq %rax, %rax
je 0x1e7a2
movq (%r14), %rcx
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x28(%rcx), %rsi
addq $0x20, %rdx
cmpq $0x0, 0x30(%rsi)
leaq 0x30(%rsi), %rdi
cmovneq %rdi, %rdx
movq %rax, (%rdx)
movq %rsi, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rax, 0x28(%rcx)
cmpl $0x7, %ebx
jne 0x1e86d
leaq 0x14788(%rip), %rsi     # 0x32fed
movq %rsp, %rdi
callq 0x1da24
movq (%rsp), %rax
jmp 0x1e7a4
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28a84
jmp 0x1e7ea
leaq 0x15167(%rip), %rdi     # 0x339f6
leaq 0x1465f(%rip), %rsi     # 0x32ef5
leaq 0x17a16(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O1/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::insert_child_after(pugi::xml_node_type, pugi::xml_node const&)
PUGI__FN xml_node xml_node::insert_child_after(xml_node_type type_, const xml_node& node)
	{
		if (!impl::allow_insert_child(type(), type_)) return xml_node();
		if (!node._root || node._root->parent != _root) return xml_node();

		impl::xml_allocator& alloc = impl::get_allocator(_root);
		if (!alloc.reserve()) return xml_node();

		xml_node n(impl::allocate_node(alloc, type_));
		if (!n) return xml_node();

		impl::insert_node_after(n._root, node._root);

		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));

		return n;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1e8c0
movl (%rcx), %edx
andl $0xf, %edx
jmp 0x1e8c2
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x2, %ebx
jb 0x1e8ee
leal -0x3(%rdx), %esi
cmpl $-0x2, %esi
jb 0x1e8ee
leal -0x9(%rbx), %eax
cmpl $-0x2, %eax
jb 0x1e8de
cmpl $0x1, %edx
jne 0x1e8ec
movq (%r14), %rax
testq %rax, %rax
je 0x1e8ec
cmpq %rcx, 0x18(%rax)
je 0x1e8f6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testq %rcx, %rcx
je 0x1e9ce
movq (%rcx), %rax
shrq $0x8, %rax
negq %rax
movq (%rcx,%rax), %rdi
movq 0x8(%rdi), %rax
leaq 0x40(%rax), %rcx
cmpq $0x7fd9, %rcx           # imm = 0x7FD9
jae 0x1e9bc
movq (%rdi), %rdx
addq %rdx, %rax
addq $0x28, %rax
movq %rcx, 0x8(%rdi)
movq %rdx, (%rsp)
testq %rax, %rax
je 0x1e965
movq %rax, %rcx
subq (%rsp), %rcx
shlq $0x8, %rcx
movl %ebx, %edx
orq %rcx, %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x38(%rax)
movq %rdx, (%rax)
jmp 0x1e967
xorl %eax, %eax
movq %rax, (%rsp)
testq %rax, %rax
je 0x1e8ec
movq (%r14), %rcx
movq 0x18(%rcx), %rsi
movq %rsi, 0x18(%rax)
movq 0x30(%rcx), %rdx
movq %rdx, %rdi
testq %rdx, %rdx
jne 0x1e98f
movq 0x20(%rsi), %rdi
movq %rax, 0x28(%rdi)
movq %rdx, 0x30(%rax)
movq %rcx, 0x28(%rax)
movq %rax, 0x30(%rcx)
cmpl $0x7, %ebx
jne 0x1e9b3
leaq 0x14642(%rip), %rsi     # 0x32fed
movq %rsp, %rdi
callq 0x1da24
movq (%rsp), %rax
jmp 0x1e8ee
movq %rsp, %rdx
movl $0x40, %esi
callq 0x28a84
jmp 0x1e934
leaq 0x15021(%rip), %rdi     # 0x339f6
leaq 0x14519(%rip), %rsi     # 0x32ef5
leaq 0x178d0(%rip), %rcx     # 0x362b3
movl $0x486, %edx            # imm = 0x486
callq 0x6120
nop