LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x30, %rdi
callq 0x3dbd0
movq -0x18(%rbp), %rcx
movslq 0x64(%rcx), %rcx
cmpq %rcx, %rax
jae 0x3cbab
movq 0x58417(%rip), %rdi     # 0x94f88
leaq 0x2daa1(%rip), %rsi     # 0x6a619
callq 0x7580
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x3b4e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x7580
movq %rax, %rdi
movq 0x58428(%rip), %rsi     # 0x94fc8
callq 0x7970
movb $0x0, -0x1(%rbp)
jmp 0x3cc1d
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x3dbd0
movq -0x18(%rbp), %rcx
movslq 0x60(%rcx), %rcx
cmpq %rcx, %rax
jbe 0x3cc06
movq 0x583bc(%rip), %rdi     # 0x94f88
leaq 0x2da67(%rip), %rsi     # 0x6a63a
callq 0x7580
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x3b4e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x7580
movq %rax, %rdi
movq 0x583cd(%rip), %rsi     # 0x94fc8
callq 0x7970
movb $0x0, -0x1(%rbp)
jmp 0x3cc1d
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x3b660
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
testb %al, %al
je 0x3f661
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x3fee0
movq -0x118(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, 0x20(%rax)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3f7d1
movq -0x118(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3ff00
jmp 0x3f6f1
movq -0x118(%rbp), %rax
movslq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3b500
movq %rax, -0x120(%rbp)
jmp 0x3f712
movq -0x120(%rbp), %rdi
callq 0x7390
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3ff40
movq %rax, -0x128(%rbp)
jmp 0x3f738
movq -0x118(%rbp), %rax
movq -0x128(%rbp), %rcx
movq (%rcx), %rcx
movl %ecx, 0x20(%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0x3f7a1
movq -0x138(%rbp), %rcx
movl -0x12c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x140(%rbp)
jmp 0x3f7be
movq -0x118(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3ff80
jmp 0x3f7da
movq -0x138(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x3f6d4
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7600
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x4081f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x407e7
jmp 0x407e9
jmp 0x40808
leaq 0x2ab58(%rip), %rdi     # 0x6b348
leaq 0x2ab5e(%rip), %rsi     # 0x6b355
movl $0x13c2, %edx           # imm = 0x13C2
leaq 0x2ab66(%rip), %rcx     # 0x6b369
callq 0x7180
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x74a0
jmp 0x40893
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4082c
jmp 0x4084b
leaq 0x2ab16(%rip), %rdi     # 0x6b349
leaq 0x2ab1b(%rip), %rsi     # 0x6b355
movl $0x13c7, %edx           # imm = 0x13C7
leaq 0x2ab23(%rip), %rcx     # 0x6b369
callq 0x7180
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x4085b
jmp 0x4087a
leaq 0x2ab49(%rip), %rdi     # 0x6b3ab
leaq 0x2aaec(%rip), %rsi     # 0x6b355
movl $0x13c8, %edx           # imm = 0x13C8
leaq 0x2aaf4(%rip), %rcx     # 0x6b369
callq 0x7180
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
shrq $0x2, %rdx
callq 0x7200
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
jne 0x41ef9
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x41f59
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x41f50
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x41f40
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x41f31
jmp 0x41f40
movq -0x20(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x41c10
jmp 0x41f59
jmp 0x41f42
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x41f08
leaq -0x8(%rbp), %rdi
callq 0x41bf0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
jne 0x42289
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x422e9
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x422e0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x422d0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x422c1
jmp 0x422d0
movq -0x20(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x40970
jmp 0x422e9
jmp 0x422d2
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x42298
leaq -0x8(%rbp), %rdi
callq 0x40950
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
jne 0x42329
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x42389
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x42380
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x42370
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x42361
jmp 0x42370
movq -0x20(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x41c10
jmp 0x42389
jmp 0x42372
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x42338
leaq -0x8(%rbp), %rdi
callq 0x41bf0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
jne 0x42419
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x4247d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x42474
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x42464
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x421f0
testb $0x1, %al
jne 0x42455
jmp 0x42464
movq -0x20(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x41c10
jmp 0x4247d
jmp 0x42466
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x42428
leaq -0x8(%rbp), %rdi
callq 0x41bf0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::is_attribute_of(pugi::xml_attribute_struct*, pugi::xml_node_struct*)
PUGI__FN bool is_attribute_of(xml_attribute_struct* attr, xml_node_struct* node)
	{
		for (xml_attribute_struct* a = node->first_attribute; a; a = a->next_attribute)
			if (a == attr)
				return true;

		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4266f
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x4265f
movb $0x1, -0x1(%rbp)
jmp 0x42673
jmp 0x42661
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x42648
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
jne 0x4285a
leaq 0x268b8(%rip), %rax     # 0x69109
movq %rax, -0x8(%rbp)
jmp 0x428e5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
andq $0xf, %rax
cmpl $0x2, %eax
jne 0x4288c
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x4288c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x428e5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x428da
movq -0x18(%rbp), %rdi
callq 0x428f0
testb $0x1, %al
jne 0x428b1
jmp 0x428ca
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x428ca
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x428e5
jmp 0x428cc
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4289b
leaq 0x26828(%rip), %rax     # 0x69109
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::set_name(char const*)
PUGI__FN bool xml_node::set_name(const char_t* rhs)
	{
		xml_node_type type_ = _root ? PUGI__NODETYPE(_root) : node_null;

		if (type_ != node_element && type_ != node_pi && type_ != node_declaration)
			return false;

		return impl::strcpy_insitu(_root->name, _root->header, impl::xml_memory_page_name_allocated_mask, rhs, impl::strlength(rhs));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x42af1
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
andq $0xf, %rax
movl %eax, -0x2c(%rbp)
jmp 0x42af8
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x42af8
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x42b16
cmpl $0x6, -0x1c(%rbp)
je 0x42b16
cmpl $0x7, -0x1c(%rbp)
je 0x42b16
movb $0x0, -0x1(%rbp)
jmp 0x42b5b
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x418f0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rcx
movq %rax, %r8
movl $0x20, %edx
callq 0x41750
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::set_value(char const*)
PUGI__FN bool xml_node::set_value(const char_t* rhs)
	{
		xml_node_type type_ = _root ? PUGI__NODETYPE(_root) : node_null;

		if (type_ != node_pcdata && type_ != node_cdata && type_ != node_comment && type_ != node_pi && type_ != node_doctype)
			return false;

		return impl::strcpy_insitu(_root->value, _root->header, impl::xml_memory_page_value_allocated_mask, rhs, impl::strlength(rhs));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x42ba1
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
andq $0xf, %rax
movl %eax, -0x2c(%rbp)
jmp 0x42ba8
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x42ba8
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
je 0x42bd2
cmpl $0x4, -0x1c(%rbp)
je 0x42bd2
cmpl $0x5, -0x1c(%rbp)
je 0x42bd2
cmpl $0x6, -0x1c(%rbp)
je 0x42bd2
cmpl $0x8, -0x1c(%rbp)
je 0x42bd2
movb $0x0, -0x1(%rbp)
jmp 0x42c17
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, -0x48(%rbp)
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x418f0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rcx
movq %rax, %r8
movl $0x10, %edx
callq 0x41750
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x42160
movl %eax, %edi
callq 0x42cf0
testb $0x1, %al
jne 0x42c63
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x42cdf
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x42c8b
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x42cdf
movq -0x20(%rbp), %rdi
callq 0x42d90
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x40970
leaq -0x28(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x42caf
jmp 0x42cba
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x42cdf
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x42df0
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x416d0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::append_attribute(pugi::xml_attribute_struct*, pugi::xml_node_struct*)
inline void append_attribute(xml_attribute_struct* attr, xml_node_struct* node)
	{
		xml_attribute_struct* head = node->first_attribute;

		if (head)
		{
			xml_attribute_struct* tail = head->prev_attribute_c;

			tail->next_attribute = attr;
			attr->prev_attribute_c = tail;
			head->prev_attribute_c = attr;
		}
		else
		{
			node->first_attribute = attr;
			attr->prev_attribute_c = attr;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x42e41
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x42e59
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x42160
movl %eax, %edi
callq 0x42cf0
testb $0x1, %al
jne 0x42e93
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x42f0f
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x42ebb
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x42f0f
movq -0x20(%rbp), %rdi
callq 0x42d90
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x40970
leaq -0x28(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x42edf
jmp 0x42eea
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x42f0f
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x42f20
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x416d0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::prepend_attribute(pugi::xml_attribute_struct*, pugi::xml_node_struct*)
inline void prepend_attribute(xml_attribute_struct* attr, xml_node_struct* node)
	{
		xml_attribute_struct* head = node->first_attribute;

		if (head)
		{
			attr->prev_attribute_c = head->prev_attribute_c;
			head->prev_attribute_c = attr;
		}
		else
			attr->prev_attribute_c = attr;

		attr->next_attribute = head;
		node->first_attribute = attr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x42f5d
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x42f69
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x42160
movl %eax, %edi
callq 0x42cf0
testb $0x1, %al
jne 0x42fca
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x4307f
movq -0x20(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x42fee
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
callq 0x42630
testb $0x1, %al
jne 0x42ffc
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x4307f
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x43024
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x4307f
movq -0x28(%rbp), %rdi
callq 0x42d90
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x40970
leaq -0x30(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x43048
jmp 0x43053
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x4307f
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
movq (%rax), %rdx
callq 0x43090
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x416d0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::insert_attribute_after(pugi::xml_attribute_struct*, pugi::xml_attribute_struct*, pugi::xml_node_struct*)
inline void insert_attribute_after(xml_attribute_struct* attr, xml_attribute_struct* place, xml_node_struct* node)
	{
		if (place->next_attribute)
			place->next_attribute->prev_attribute_c = attr;
		else
			node->first_attribute->prev_attribute_c = attr;

		attr->next_attribute = place->next_attribute;
		attr->prev_attribute_c = place;
		place->next_attribute = attr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x430bd
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x430cd
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x42160
movl %eax, %edi
callq 0x42cf0
testb $0x1, %al
jne 0x4313a
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x431ef
movq -0x20(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x4315e
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
callq 0x42630
testb $0x1, %al
jne 0x4316c
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x431ef
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x43194
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x431ef
movq -0x28(%rbp), %rdi
callq 0x42d90
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x40970
leaq -0x30(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x431b8
jmp 0x431c3
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x431ef
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
movq (%rax), %rdx
callq 0x43200
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x416d0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::insert_attribute_before(pugi::xml_attribute_struct*, pugi::xml_attribute_struct*, pugi::xml_node_struct*)
inline void insert_attribute_before(xml_attribute_struct* attr, xml_attribute_struct* place, xml_node_struct* node)
	{
		if (place->prev_attribute_c->next_attribute)
			place->prev_attribute_c->next_attribute = attr;
		else
			node->first_attribute = attr;

		attr->prev_attribute_c = place->prev_attribute_c;
		attr->next_attribute = place;
		place->prev_attribute_c = attr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x43231
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x4323d
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x43297
jmp 0x432a5
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x43343
movq -0x30(%rbp), %rdi
callq 0x42160
movl %eax, %edi
callq 0x42cf0
testb $0x1, %al
jne 0x432c4
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x43343
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x432ec
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x43343
movq -0x20(%rbp), %rdi
callq 0x42d90
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x40970
leaq -0x28(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x43310
jmp 0x4331b
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x43343
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x42df0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x43350
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::node_copy_attribute(pugi::xml_attribute_struct*, pugi::xml_attribute_struct*)
PUGI__FN void node_copy_attribute(xml_attribute_struct* da, xml_attribute_struct* sa)
	{
		xml_allocator& alloc = get_allocator(da);
		xml_allocator* shared_alloc = (&alloc == &get_allocator(sa)) ? &alloc : 0;

		node_copy_string(da->name, da->header, xml_memory_page_name_allocated_mask, sa->name, sa->header, shared_alloc);
		node_copy_string(da->value, da->header, xml_memory_page_value_allocated_mask, sa->value, sa->header, shared_alloc);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4f860
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4f860
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x43394
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x4339c
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x4339c
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0x20, %edx
callq 0x4f8c0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0x10, %edx
callq 0x4f8c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x43427
jmp 0x43435
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x434d3
movq -0x30(%rbp), %rdi
callq 0x42160
movl %eax, %edi
callq 0x42cf0
testb $0x1, %al
jne 0x43454
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x434d3
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x4347c
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x434d3
movq -0x20(%rbp), %rdi
callq 0x42d90
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x40970
leaq -0x28(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x434a0
jmp 0x434ab
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x434d3
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x42f20
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x43350
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x4350b
jmp 0x43519
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x435f3
movq -0x38(%rbp), %rdi
callq 0x42160
movl %eax, %edi
callq 0x42cf0
testb $0x1, %al
jne 0x4353b
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x435f3
movq -0x20(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x4355f
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
callq 0x42630
testb $0x1, %al
jne 0x4356d
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x435f3
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x43595
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x435f3
movq -0x28(%rbp), %rdi
callq 0x42d90
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x40970
leaq -0x30(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x435b9
jmp 0x435c4
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x435f3
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
movq (%rax), %rdx
callq 0x43090
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x43350
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x4362b
jmp 0x43639
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x43713
movq -0x38(%rbp), %rdi
callq 0x42160
movl %eax, %edi
callq 0x42cf0
testb $0x1, %al
jne 0x4365b
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x43713
movq -0x20(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x4367f
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
callq 0x42630
testb $0x1, %al
jne 0x4368d
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x43713
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x436b5
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x43713
movq -0x28(%rbp), %rdi
callq 0x42d90
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x40970
leaq -0x30(%rbp), %rdi
callq 0x409d0
testb $0x1, %al
jne 0x436d9
jmp 0x436e4
leaq -0x8(%rbp), %rdi
callq 0x40950
jmp 0x43713
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
movq (%rax), %rdx
callq 0x43200
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x43350
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x42160
movl %eax, %edi
movl -0x14(%rbp), %esi
callq 0x437f0
testb $0x1, %al
jne 0x43758
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x437e0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x43780
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x437e0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x43850
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x41c10
leaq -0x28(%rbp), %rdi
callq 0x41c70
testb $0x1, %al
jne 0x437a7
jmp 0x437b2
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x437e0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x438b0
cmpl $0x7, -0x14(%rbp)
jne 0x437d8
leaq -0x28(%rbp), %rdi
leaq 0x27c7a(%rip), %rsi     # 0x6b44d
callq 0x42ac0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::allow_insert_child(pugi::xml_node_type, pugi::xml_node_type)
PUGI__FN bool allow_insert_child(xml_node_type parent, xml_node_type child)
	{
		if (parent != node_document && parent != node_element) return false;
		if (child == node_document || child == node_null) return false;
		if (parent != node_document && (child == node_declaration || child == node_doctype)) return false;

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, -0x8(%rbp)
je 0x4380c
cmpl $0x2, -0x8(%rbp)
je 0x4380c
movb $0x0, -0x1(%rbp)
jmp 0x4383a
cmpl $0x1, -0xc(%rbp)
je 0x43818
cmpl $0x0, -0xc(%rbp)
jne 0x4381e
movb $0x0, -0x1(%rbp)
jmp 0x4383a
cmpl $0x1, -0x8(%rbp)
je 0x43836
cmpl $0x7, -0xc(%rbp)
je 0x43830
cmpl $0x8, -0xc(%rbp)
jne 0x43836
movb $0x0, -0x1(%rbp)
jmp 0x4383a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::append_node(pugi::xml_node_struct*, pugi::xml_node_struct*)
inline void append_node(xml_node_struct* child, xml_node_struct* node)
	{
		child->parent = node;

		xml_node_struct* head = node->first_child;

		if (head)
		{
			xml_node_struct* tail = head->prev_sibling_c;

			tail->next_sibling = child;
			child->prev_sibling_c = tail;
			head->prev_sibling_c = child;
		}
		else
		{
			node->first_child = child;
			child->prev_sibling_c = child;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4390d
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x43925
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x42160
movl %eax, %edi
movl -0x14(%rbp), %esi
callq 0x437f0
testb $0x1, %al
jne 0x43968
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x439f0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x43990
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x439f0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x43850
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x41c10
leaq -0x28(%rbp), %rdi
callq 0x41c70
testb $0x1, %al
jne 0x439b7
jmp 0x439c2
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x439f0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x43a00
cmpl $0x7, -0x14(%rbp)
jne 0x439e8
leaq -0x28(%rbp), %rdi
leaq 0x27a6a(%rip), %rsi     # 0x6b44d
callq 0x42ac0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::prepend_node(pugi::xml_node_struct*, pugi::xml_node_struct*)
inline void prepend_node(xml_node_struct* child, xml_node_struct* node)
	{
		child->parent = node;

		xml_node_struct* head = node->first_child;

		if (head)
		{
			child->prev_sibling_c = head->prev_sibling_c;
			head->prev_sibling_c = child;
		}
		else
			child->prev_sibling_c = child;

		child->next_sibling = head;
		node->first_child = child;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x43a49
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x43a55
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x42160
movl %eax, %edi
movl -0x14(%rbp), %esi
callq 0x437f0
testb $0x1, %al
jne 0x43aac
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43b60
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x43aca
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq (%rcx), %rax
je 0x43ad8
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43b60
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x43b00
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43b60
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x43850
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x41c10
leaq -0x30(%rbp), %rdi
callq 0x41c70
testb $0x1, %al
jne 0x43b27
jmp 0x43b32
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43b60
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x43b70
cmpl $0x7, -0x14(%rbp)
jne 0x43b58
leaq -0x30(%rbp), %rdi
leaq 0x278fa(%rip), %rsi     # 0x6b44d
callq 0x42ac0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::insert_node_before(pugi::xml_node_struct*, pugi::xml_node_struct*)
inline void insert_node_before(xml_node_struct* child, xml_node_struct* node)
	{
		xml_node_struct* parent = node->parent;

		child->parent = parent;

		if (node->prev_sibling_c->next_sibling)
			node->prev_sibling_c->next_sibling = child;
		else
			parent->first_child = child;

		child->prev_sibling_c = node->prev_sibling_c;
		child->next_sibling = node;

		node->prev_sibling_c = child;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x43bb5
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x30(%rax)
jmp 0x43bc1
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x42160
movl %eax, %edi
movl -0x14(%rbp), %esi
callq 0x437f0
testb $0x1, %al
jne 0x43c2c
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43ce0
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x43c4a
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq (%rcx), %rax
je 0x43c58
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43ce0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x42d20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42d80
testb $0x1, %al
jne 0x43c80
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43ce0
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x43850
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x41c10
leaq -0x30(%rbp), %rdi
callq 0x41c70
testb $0x1, %al
jne 0x43ca7
jmp 0x43cb2
leaq -0x8(%rbp), %rdi
callq 0x41bf0
jmp 0x43ce0
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x43cf0
cmpl $0x7, -0x14(%rbp)
jne 0x43cd8
leaq -0x30(%rbp), %rdi
leaq 0x2777a(%rip), %rsi     # 0x6b44d
callq 0x42ac0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)