LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: addPaddingBits(unsigned char*, unsigned char const*, unsigned long, unsigned long, unsigned int)
static void addPaddingBits(unsigned char* out, const unsigned char* in, size_t olinebits, size_t ilinebits, unsigned h)
{
  /*The opposite of the removePaddingBits function
  olinebits must be >= ilinebits*/
  unsigned y;
  size_t diff = olinebits - ilinebits;
  size_t obp = 0, ibp = 0; /*bit pointers*/
  for(y = 0; y < h; y++)
  {
    size_t x;
    for(x = 0; x < ilinebits; x++)
    {
      unsigned char bit = readBitFromReversedStream(&ibp, in);
      setBitOfReversedStream(&obp, out, bit);
    }
    /*obp += diff; --> no, fill in some value in the padding bits too, to avoid "Use of uninitialised value of size ###" warning from valgrind*/
    for(x = 0; x < diff; x++) setBitOfReversedStream(&obp, out, 0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x309cb
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3098c
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2f790
movb %al, -0x49(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movzbl -0x49(%rbp), %edx
callq 0x30800
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x30953
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x309bb
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x30800
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x30994
jmp 0x309bd
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3093f
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: addChunk(ucvector*, char const*, unsigned char const*, unsigned long)
static unsigned addChunk(ucvector* out, const char* chunkName, const unsigned char* data, size_t length)
{
  unsigned error = LodePNG_create_chunk(&out->data, &out->size, (unsigned)length, chunkName, data);
  if(error) return error;
  out->allocsize = out->size; /*fix the allocsize again*/
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x25ed0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x317a8
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x317bf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/scene.cpp
// Function: Scene::trace(Ray const&)
Color Scene::trace(const Ray &ray)
{
	// Find hit object and distance
	double t, min_t = 0.0;
	Object *obj = NULL;
	for (unsigned int i = 0; i < numObjects; ++i) {
		if (objects[i]->intersect(ray, &t) && (!obj || t < min_t)) {
			min_t = t;
			obj = objects[i];
		}
	}
	
	// No hit? Return background color.
	if (!obj) return Color(0.0, 0.0, 0.0);

	Material *material = obj->material;            //the hit objects material
	Point hit = ray.at(min_t);                     //the hit point
	Vector N = obj->normal(hit);                   //the normal at hit point
	Vector V = -ray.D;                             //the view vector


	/****************************************************
	* This is where you should insert the color
	* calculation (Phong model).
	*
	* Given: material, hit, N, V, lights[]
	* Sought: color
	*
	* Hints: (see triple.h)
	*        Triple.dot(Vector) dot product
	*        Vector+Vector      vector sum
	*        Vector-Vector      vector difference
	*        Point-Point        yields vector
	*        Vector.normalize() normalizes vector, returns length
	*        double*Color        scales each color component (r,g,b)
	*        Color*Color        dito
	*        pow(a,b)           a to the power of b
	****************************************************/

	Color color = material->color;                  // place holder

	return color;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x88(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jae 0x32965
movq -0x88(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq 0x8(%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
leaq -0x18(%rbp), %rdx
callq *0x10(%rax)
testb $0x1, %al
jne 0x32924
jmp 0x32958
cmpq $0x0, -0x28(%rbp)
je 0x3293b
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x32958
movq -0x88(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x2c(%rbp), %ecx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x3295a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x328f3
cmpq $0x0, -0x28(%rbp)
jne 0x32983
movq -0x98(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x21740
jmp 0x329e5
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0x32c00
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq *0x18(%rax)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x80(%rbp), %rdi
callq 0x32c50
movq -0x98(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/scene.cpp
// Function: Scene::render(Image&)
void Scene::render(Image &img)
{
	int w = img.width();
	int h = img.height();
	for (int y = 0; y < h; y++) {
		for (int x = 0; x < w; x++) {
			Point pixel(x, h-1-y, 0);
			Ray ray(eye, (pixel-eye).normalized());
			Color col = trace(ray);
			col.clamp();
			img(x,y) = col;
		}
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32cd0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32cf0
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x32b44
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x32b34
cvtsi2sdl -0x20(%rbp), %xmm0
movl -0x18(%rbp), %eax
subl $0x1, %eax
subl -0x1c(%rbp), %eax
cvtsi2sd %eax, %xmm1
leaq -0x38(%rbp), %rdi
xorps %xmm2, %xmm2
callq 0x21740
movq -0xb8(%rbp), %rdx
movq %rdx, %rax
addq $0x380, %rax            # imm = 0x380
movq %rax, -0xc0(%rbp)
addq $0x380, %rdx            # imm = 0x380
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x222b0
leaq -0x80(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x22310
movq -0xc0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x32d10
movq -0xb8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x328b0
leaq -0xb0(%rbp), %rdi
movsd 0x18c1e(%rip), %xmm0    # 0x4b710
callq 0x32d60
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x32dd0
movq -0xb0(%rbp), %rcx
movq %rcx, (%rax)
movq -0xa8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0xa0(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x32a50
jmp 0x32b36
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x32a3d
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/yaml/exp.cpp
// Function: YAML::Exp::ParseHex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int)
unsigned ParseHex(const std::string& str, int line, int column)
		{
			unsigned value = 0;
			for(unsigned i=0;i<str.size();i++) {
				char ch = str[i];
				int digit = 0;
				if('a' <= ch && ch <= 'f')
					digit = ch - 'a' + 10;
				else if('A' <= ch && ch <= 'F')
					digit = ch - 'A' + 10;
				else if('0' <= ch && ch <= '9')
					digit = ch - '0';
				else
					throw ParserException(line, column, ErrorMsg::INVALID_HEX);

				value = (value << 4) + digit;
			}

			return value;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5290
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x3326d
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5450
movb (%rax), %al
movb %al, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movsbl -0x19(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x331b2
movsbl -0x19(%rbp), %eax
cmpl $0x66, %eax
jg 0x331b2
movsbl -0x19(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x20(%rbp)
jmp 0x33253
movsbl -0x19(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x331d7
movsbl -0x19(%rbp), %eax
cmpl $0x46, %eax
jg 0x331d7
movsbl -0x19(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x20(%rbp)
jmp 0x33251
movsbl -0x19(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x331f9
movsbl -0x19(%rbp), %eax
cmpl $0x39, %eax
jg 0x331f9
movsbl -0x19(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x20(%rbp)
jmp 0x3324f
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x3688e(%rip), %rcx     # 0x69aa8
callq 0x340e0
jmp 0x33221
movq -0x40(%rbp), %rdi
leaq 0x343d4(%rip), %rsi     # 0x67600
leaq 0xefd(%rip), %rdx       # 0x34130
callq 0x5690
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x52c0
jmp 0x33276
jmp 0x33251
jmp 0x33253
movl -0x14(%rbp), %eax
shll $0x4, %eax
addl -0x20(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x33150
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
nop
// File: mhe[P]raytracerframework_cpp/yaml/iterator.cpp
// Function: YAML::Iterator::operator=(YAML::Iterator const&)
Iterator& Iterator::operator = (const Iterator& rhs)
	{
		if(this == &rhs)
			return *this;

		delete m_pData;
		m_pData = new IterPriv(*rhs.m_pData);
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x34438
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3448c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x34457
movq -0x28(%rbp), %rdi
movl $0x18, %esi
callq 0x53c0
movl $0x18, %edi
callq 0x53b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
movq (%rdx), %rsi
movq %rsi, (%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rcx)
movq %rcx, (%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/iterator.cpp
// Function: YAML::Iterator::operator++()
Iterator& Iterator::operator ++ ()
	{
		if(m_pData->type == IterPriv::IT_SEQ)
			++m_pData->seqIter;
		else if(m_pData->type == IterPriv::IT_MAP)
			++m_pData->mapIter;

		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x3450e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x34920
jmp 0x3452c
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
jne 0x3452a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x10, %rdi
callq 0x34940
jmp 0x3452c
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/iterator.cpp
// Function: YAML::Iterator::operator++(int)
Iterator Iterator::operator ++ (int)
	{
		Iterator temp = *this;

		if(m_pData->type == IterPriv::IT_SEQ)
			++m_pData->seqIter;
		else if(m_pData->type == IterPriv::IT_MAP)
			++m_pData->mapIter;

		return temp;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x343b0
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x3458d
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x34920
jmp 0x345ab
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
jne 0x345a9
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0x10, %rdi
callq 0x34940
jmp 0x345ab
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x345be
movq -0x30(%rbp), %rdi
callq 0x344a0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/iterator.cpp
// Function: YAML::operator==(YAML::Iterator const&, YAML::Iterator const&)
bool operator == (const Iterator& it, const Iterator& jt)
	{
		if(it.m_pData->type != jt.m_pData->type)
			return false;

		if(it.m_pData->type == IterPriv::IT_SEQ)
			return it.m_pData->seqIter == jt.m_pData->seqIter;
		else if(it.m_pData->type == IterPriv::IT_MAP)
			return it.m_pData->mapIter == jt.m_pData->mapIter;

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x3483a
movb $0x0, -0x1(%rbp)
jmp 0x3489c
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x34868
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x349c0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3489c
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
jne 0x34896
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x10, %rsi
callq 0x34a00
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3489c
jmp 0x34898
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/map.cpp
// Function: YAML::Map::Clear()
void Map::Clear()
	{
		for(node_map::const_iterator it=m_data.begin();it!=m_data.end();++it) {
			delete it->first;
			delete it->second;
		}
		m_data.clear();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0x358d0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x35900
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x35950
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x35900
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x35920
testb $0x1, %al
jne 0x34bbf
jmp 0x34c2a
leaq -0x10(%rbp), %rdi
callq 0x34990
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x34bec
movq -0x38(%rbp), %rdi
callq 0x37a30
movq -0x38(%rbp), %rdi
movl $0x58, %esi
callq 0x53c0
leaq -0x10(%rbp), %rdi
callq 0x34990
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x34c1a
movq -0x40(%rbp), %rdi
callq 0x37a30
movq -0x40(%rbp), %rdi
movl $0x58, %esi
callq 0x53c0
jmp 0x34c1c
leaq -0x10(%rbp), %rdi
callq 0x34940
jmp 0x34b8e
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x35980
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/yaml/map.cpp
// Function: YAML::Map::Parse(YAML::Scanner*, YAML::ParserState const&)
void Map::Parse(Scanner *pScanner, const ParserState& state)
	{
		Clear();

		// split based on start token
		switch(pScanner->peek().type) {
			case TT_BLOCK_MAP_START: ParseBlock(pScanner, state); break;
			case TT_FLOW_MAP_START: ParseFlow(pScanner, state); break;
			default: break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x34b60
movq -0x10(%rbp), %rdi
callq 0x40550
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x4, %eax
je 0x34d31
jmp 0x34d27
movl -0x1c(%rbp), %eax
subl $0x8, %eax
je 0x34d44
jmp 0x34d57
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x34d60
jmp 0x34d59
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x350e0
jmp 0x34d59
jmp 0x34d59
addq $0x30, %rsp
popq %rbp
retq
nop
// File: mhe[P]raytracerframework_cpp/yaml/map.cpp
// Function: YAML::Map::Compare(YAML::Map*)
int Map::Compare(Map *pMap)
	{
		node_map::const_iterator it = m_data.begin(), jt = pMap->m_data.begin();
		while(1) {
			if(it == m_data.end()) {
				if(jt == pMap->m_data.end())
					return 0;
				else
					return -1;
			}
			if(jt == pMap->m_data.end())
				return 1;

			int cmp = it->first->Compare(*jt->first);
			if(cmp != 0)
				return cmp;

			cmp = it->second->Compare(*jt->second);
			if(cmp != 0)
				return cmp;
		}

		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x8, %rdi
callq 0x358d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x35900
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x358d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x35900
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
callq 0x35950
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x35900
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x34a00
testb $0x1, %al
jne 0x35784
jmp 0x357cd
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x35950
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x35900
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x34a00
testb $0x1, %al
jne 0x357b5
jmp 0x357c1
movl $0x0, -0x4(%rbp)
jmp 0x35880
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x35880
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x35950
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x35900
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x34a00
testb $0x1, %al
jne 0x357fe
jmp 0x35807
movl $0x1, -0x4(%rbp)
jmp 0x35880
leaq -0x20(%rbp), %rdi
callq 0x34990
movq (%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34990
movq -0x80(%rbp), %rdi
movq (%rax), %rsi
callq 0x38e90
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
je 0x3583d
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35880
leaq -0x20(%rbp), %rdi
callq 0x34990
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34990
movq -0x88(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x38e90
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
je 0x3587b
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x35880
jmp 0x35753
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::ParseHeader(YAML::Scanner*, YAML::ParserState const&)
void Node::ParseHeader(Scanner *pScanner, const ParserState& state)
	{
		while(1) {
			if(pScanner->empty())
				return;

			switch(pScanner->peek().type) {
				case TT_TAG: ParseTag(pScanner, state); break;
				case TT_ANCHOR: ParseAnchor(pScanner, state); break;
				case TT_ALIAS: ParseAlias(pScanner, state); break;
				default: return;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40460
testb $0x1, %al
jne 0x37cdb
jmp 0x37cdd
jmp 0x37d44
movq -0x10(%rbp), %rdi
callq 0x40550
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0xe, %eax
je 0x37d1a
jmp 0x37cf3
movl -0x24(%rbp), %eax
subl $0xf, %eax
je 0x37d2d
jmp 0x37cfd
movl -0x24(%rbp), %eax
subl $0x10, %eax
jne 0x37d40
jmp 0x37d07
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37d50
jmp 0x37d42
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37e90
jmp 0x37d42
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37f70
jmp 0x37d42
jmp 0x37d44
jmp 0x37ccc
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::ParseTag(YAML::Scanner*, YAML::ParserState const&)
void Node::ParseTag(Scanner *pScanner, const ParserState& state)
	{
		Token& token = pScanner->peek();
		if(m_tag != "")
			throw ParserException(token.line, token.column, ErrorMsg::MULTIPLE_TAGS);

		m_tag = state.TranslateTag(token.value);

		for(unsigned i=0;i<token.params.size();i++)
			m_tag += token.params[i];
		pScanner->pop();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40550
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
leaq 0x14025(%rip), %rsi     # 0x4bdad
callq 0x38f10
testb $0x1, %al
jne 0x37d93
jmp 0x37df0
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x32b28(%rip), %rcx     # 0x6a8e0
callq 0x340e0
jmp 0x37dbf
movq -0x68(%rbp), %rdi
leaq 0x2f836(%rip), %rsi     # 0x67600
leaq -0x3ca1(%rip), %rdx     # 0x34130
callq 0x5690
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x52c0
jmp 0x37e82
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x10, %rdx
leaq -0x50(%rbp), %rdi
callq 0x3b4c0
movq -0x60(%rbp), %rdi
addq $0x28, %rdi
leaq -0x50(%rbp), %rsi
callq 0x54e0
leaq -0x50(%rbp), %rdi
callq 0x5788
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x361d0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x37e73
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movl -0x54(%rbp), %eax
movl %eax, %esi
callq 0x38f40
movq -0x60(%rbp), %rdi
movq %rax, %rsi
addq $0x28, %rdi
callq 0x5520
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x37e26
movq -0x10(%rbp), %rdi
callq 0x40510
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::ParseAnchor(YAML::Scanner*, YAML::ParserState const&)
void Node::ParseAnchor(Scanner *pScanner, const ParserState& state)
	{
		Token& token = pScanner->peek();
		if(m_anchor != "")
			throw ParserException(token.line, token.column, ErrorMsg::MULTIPLE_ANCHORS);

		m_anchor = token.value;
		m_alias = false;
		pScanner->pop();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40550
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
leaq 0x13ee5(%rip), %rsi     # 0x4bdad
callq 0x38f10
testb $0x1, %al
jne 0x37ed3
jmp 0x37f2d
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x32a08(%rip), %rcx     # 0x6a900
callq 0x340e0
jmp 0x37eff
movq -0x40(%rbp), %rdi
leaq 0x2f6f6(%rip), %rsi     # 0x67600
leaq -0x3de1(%rip), %rdx     # 0x34130
callq 0x5690
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x52c0
jmp 0x37f59
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
addq $0x8, %rdi
callq 0x5080
movq -0x38(%rbp), %rax
movb $0x0, 0x50(%rax)
movq -0x10(%rbp), %rdi
callq 0x40510
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::ParseAlias(YAML::Scanner*, YAML::ParserState const&)
void Node::ParseAlias(Scanner *pScanner, const ParserState& state)
	{
		Token& token = pScanner->peek();
		if(m_anchor != "")
			throw ParserException(token.line, token.column, ErrorMsg::MULTIPLE_ALIASES);
		if(m_tag != "")
			throw ParserException(token.line, token.column, ErrorMsg::ALIAS_CONTENT);

		m_anchor = token.value;
		m_alias = true;
		pScanner->pop();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40550
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
leaq 0x13e05(%rip), %rsi     # 0x4bdad
callq 0x38f10
testb $0x1, %al
jne 0x37fb3
jmp 0x38010
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x32948(%rip), %rcx     # 0x6a920
callq 0x340e0
jmp 0x37fdf
movq -0x40(%rbp), %rdi
leaq 0x2f616(%rip), %rsi     # 0x67600
leaq -0x3ec1(%rip), %rdx     # 0x34130
callq 0x5690
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x52c0
jmp 0x380b0
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
leaq 0x13d8e(%rip), %rsi     # 0x4bdad
callq 0x38f10
testb $0x1, %al
jne 0x3802a
jmp 0x38084
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x328f1(%rip), %rcx     # 0x6a940
callq 0x340e0
jmp 0x38056
movq -0x48(%rbp), %rdi
leaq 0x2f59f(%rip), %rsi     # 0x67600
leaq -0x3f38(%rip), %rdx     # 0x34130
callq 0x5690
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x52c0
jmp 0x380b0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
addq $0x8, %rdi
callq 0x5080
movq -0x38(%rbp), %rax
movb $0x1, 0x50(%rax)
movq -0x10(%rbp), %rdi
callq 0x40510
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::GetType() const
CONTENT_TYPE Node::GetType() const
	{
		if(!m_pContent)
			return CT_NONE;

		if(m_pContent->IsScalar())
			return CT_SCALAR;
		else if(m_pContent->IsSequence())
			return CT_SEQUENCE;
		else if(m_pContent->IsMap())
			return CT_MAP;
			
		return CT_NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x386e4
movl $0x0, -0x4(%rbp)
jmp 0x38746
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb $0x1, %al
jne 0x386f8
jmp 0x38701
movl $0x1, -0x4(%rbp)
jmp 0x38746
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
testb $0x1, %al
jne 0x38715
jmp 0x3871e
movl $0x2, -0x4(%rbp)
jmp 0x38746
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
testb $0x1, %al
jne 0x38732
jmp 0x3873b
movl $0x3, -0x4(%rbp)
jmp 0x38746
jmp 0x3873d
jmp 0x3873f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::begin() const
Iterator Node::begin() const
	{
		if(!m_pContent)
			return Iterator();

		std::vector <Node *>::const_iterator seqIter;
		if(m_pContent->GetBegin(seqIter))
			return Iterator(new IterPriv(seqIter));

		std::map <Node *, Node *, ltnode>::const_iterator mapIter;
		if(m_pContent->GetBegin(mapIter))
			return Iterator(new IterPriv(mapIter));

		return Iterator();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x38788
movq -0x58(%rbp), %rdi
callq 0x34320
jmp 0x3887d
leaq -0x18(%rbp), %rdi
callq 0x34a30
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
leaq -0x18(%rbp), %rsi
callq *0x20(%rax)
testb $0x1, %al
jne 0x387a9
jmp 0x38801
movl $0x18, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x38f90
jmp 0x387d0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x34390
jmp 0x3887d
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x18, %esi
callq 0x53c0
jmp 0x38887
leaq -0x38(%rbp), %rdi
callq 0x34a50
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
leaq -0x38(%rbp), %rsi
callq *0x28(%rax)
testb $0x1, %al
jne 0x38822
jmp 0x38874
movl $0x18, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x38fd0
jmp 0x38849
movq -0x68(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x34390
jmp 0x3887d
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x18, %esi
callq 0x53c0
jmp 0x38887
movq -0x58(%rbp), %rdi
callq 0x34320
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
// File: mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::end() const
Iterator Node::end() const
	{
		if(!m_pContent)
			return Iterator();

		std::vector <Node *>::const_iterator seqIter;
		if(m_pContent->GetEnd(seqIter))
			return Iterator(new IterPriv(seqIter));

		std::map <Node *, Node *, ltnode>::const_iterator mapIter;
		if(m_pContent->GetEnd(mapIter))
			return Iterator(new IterPriv(mapIter));

		return Iterator();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x388c8
movq -0x58(%rbp), %rdi
callq 0x34320
jmp 0x389bd
leaq -0x18(%rbp), %rdi
callq 0x34a30
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
leaq -0x18(%rbp), %rsi
callq *0x30(%rax)
testb $0x1, %al
jne 0x388e9
jmp 0x38941
movl $0x18, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x38f90
jmp 0x38910
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x34390
jmp 0x389bd
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x18, %esi
callq 0x53c0
jmp 0x389c7
leaq -0x38(%rbp), %rdi
callq 0x34a50
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
leaq -0x38(%rbp), %rsi
callq *0x38(%rax)
testb $0x1, %al
jne 0x38962
jmp 0x389b4
movl $0x18, %edi
callq 0x53b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x38fd0
jmp 0x38989
movq -0x68(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x34390
jmp 0x389bd
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x18, %esi
callq 0x53c0
jmp 0x389c7
movq -0x58(%rbp), %rdi
callq 0x34320
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56c0
// File: mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::operator[](unsigned int) const
const Node& Node::operator [] (unsigned u) const
	{
		if(!m_pContent)
			throw BadDereference();

		Node *pNode = m_pContent->GetNode(u);
		if(pNode)
			return *pNode;

		return GetValue(u);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x38a77
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x21ce0
jmp 0x38a49
movq -0x40(%rbp), %rdi
leaq 0x2ebdc(%rip), %rsi     # 0x67630
leaq -0x16d3b(%rip), %rdx    # 0x21d20
callq 0x5690
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x52c0
jmp 0x38ab8
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x38a9d
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38aae
movq -0x38(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x39010
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::operator[](int) const
const Node& Node::operator [] (int i) const
	{
		if(!m_pContent)
			throw BadDereference();

		Node *pNode = m_pContent->GetNode(i);
		if(pNode)
			return *pNode;

		return GetValue(i);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x38b37
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x21ce0
jmp 0x38b09
movq -0x40(%rbp), %rdi
leaq 0x2eb1c(%rip), %rsi     # 0x67630
leaq -0x16dfb(%rip), %rdx    # 0x21d20
callq 0x5690
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x52c0
jmp 0x38b78
movq -0x38(%rbp), %rax
movq 0x48(%rax), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x38b5d
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38b6e
movq -0x38(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x391f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::Compare(YAML::Node const&) const
int Node::Compare(const Node& rhs) const
	{
		// Step 1: no content is the smallest
		if(!m_pContent) {
			if(rhs.m_pContent)
				return -1;
			else
				return 0;
		}
		if(!rhs.m_pContent)
			return 1;

		return m_pContent->Compare(rhs.m_pContent);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x38ecc
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x38ec3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x38efc
movl $0x0, -0x4(%rbp)
jmp 0x38efc
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x38ee0
movl $0x1, -0x4(%rbp)
jmp 0x38efc
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rdi), %rax
callq *0xa8(%rax)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::GetNextDocument(YAML::Node&)
void Parser::GetNextDocument(Node& document)
	{
		// clear node
		document.Clear();

		// first read directives
		ParseDirectives();

		// we better have some tokens in the queue
		if(m_pScanner->empty())
			return;

		// first eat doc start (optional)
		if(m_pScanner->peek().type == TT_DOC_START)
			m_pScanner->pop();

		// now parse our root node
		document.Parse(m_pScanner, m_state);

		// and finally eat any doc ends we see
		while(!m_pScanner->empty() && m_pScanner->peek().type == TT_DOC_END)
			m_pScanner->pop();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37a80
movq -0x18(%rbp), %rdi
callq 0x39670
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x40460
testb $0x1, %al
jne 0x395ec
jmp 0x395ee
jmp 0x39665
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x40550
cmpl $0x1, 0x4(%rax)
jne 0x3960c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x40510
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rdi
movq (%rdx), %rsi
addq $0x8, %rdx
callq 0x37ad0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x40460
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x3964e
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x40550
cmpl $0x2, 0x4(%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x39657
jmp 0x39665
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x40510
jmp 0x39620
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::ParseDirectives()
void Parser::ParseDirectives()
	{
		bool readDirective = false;

		while(1) {
			if(m_pScanner->empty())
				break;

			Token& token = m_pScanner->peek();
			if(token.type != TT_DIRECTIVE)
				break;

			// we keep the directives from the last document if none are specified;
			// but if any directives are specific, then we reset them
			if(!readDirective)
				m_state.Reset();

			readDirective = true;
			HandleDirective(&token);
			m_pScanner->pop();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x40460
testb $0x1, %al
jne 0x3969a
jmp 0x3969c
jmp 0x396ea
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x40550
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x396b8
jmp 0x396ea
testb $0x1, -0x9(%rbp)
jne 0x396cb
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x3b340
movq -0x20(%rbp), %rdi
movb $0x1, -0x9(%rbp)
movq -0x18(%rbp), %rsi
callq 0x396f0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x40510
jmp 0x39688
addq $0x20, %rsp
popq %rbp
retq
// File: mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::HandleDirective(YAML::Token*)
void Parser::HandleDirective(Token *pToken)
	{
		if(pToken->value == "YAML")
			HandleYamlDirective(pToken);
		else if(pToken->value == "TAG")
			HandleTagDirective(pToken);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x12785(%rip), %rsi     # 0x4be9c
callq 0x38f60
testb $0x1, %al
jne 0x39722
jmp 0x39731
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x39760
jmp 0x3975a
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x12736(%rip), %rsi     # 0x4be76
callq 0x38f60
testb $0x1, %al
jne 0x3974b
jmp 0x39758
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x39a60
jmp 0x3975a
addq $0x20, %rsp
popq %rbp
retq
// File: mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::HandleTagDirective(YAML::Token*)
void Parser::HandleTagDirective(Token *pToken)
	{
		if(pToken->params.size() != 2)
			throw ParserException(pToken->line, pToken->column, ErrorMsg::TAG_DIRECTIVE_ARGS);

		std::string handle = pToken->params[0], prefix = pToken->params[1];
		m_state.tags[handle] = prefix;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x361d0
cmpq $0x2, %rax
je 0x39aeb
movl $0x30, %edi
callq 0x51b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
leaq 0x313ed(%rip), %rcx     # 0x6aea0
callq 0x340e0
jmp 0x39aba
movq -0x70(%rbp), %rdi
leaq 0x2db3b(%rip), %rsi     # 0x67600
leaq -0x599c(%rip), %rdx     # 0x34130
callq 0x5690
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x52c0
jmp 0x39b95
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x38f40
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x5170
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movl $0x1, %esi
callq 0x38f40
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x5170
jmp 0x39b28
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
leaq -0x40(%rbp), %rsi
callq 0x39cd0
movq %rax, -0x78(%rbp)
jmp 0x39b3f
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5080
jmp 0x39b4e
leaq -0x60(%rbp), %rdi
callq 0x5788
leaq -0x40(%rbp), %rdi
callq 0x5788
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x39b8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5788
leaq -0x40(%rbp), %rdi
callq 0x5788
movq -0x18(%rbp), %rdi
callq 0x56c0
nop
// File: mhe[P]raytracerframework_cpp/yaml/parser.cpp
// Function: YAML::Parser::PrintTokens(std::ostream&)
void Parser::PrintTokens(std::ostream& out)
	{
		while(1) {
			if(m_pScanner->empty())
				break;

			out << m_pScanner->peek() << "\n";
			m_pScanner->pop();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x40460
testb $0x1, %al
jne 0x39bca
jmp 0x39bcc
jmp 0x39c09
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
callq 0x40550
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x39db0
movq %rax, %rdi
leaq 0x12181(%rip), %rsi     # 0x4bd77
callq 0x5390
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x40510
jmp 0x39bb8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mhe[P]raytracerframework_cpp/yaml/token.h
// Function: YAML::operator<<(std::ostream&, YAML::Token const&)
std::ostream& operator << (std::ostream& out, const Token& token) {
			out << TokenNames[token.type] << std::string(": ") << token.value;
			for(unsigned i=0;i<token.params.size();i++)
				out << std::string(" ") << token.params[i];
			return out;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shlq $0x5, %rax
leaq 0x31487(%rip), %rsi     # 0x6b260
addq %rax, %rsi
callq 0x5360
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x56d0
movq -0x78(%rbp), %rdx
leaq 0x113f8(%rip), %rsi     # 0x4b1f5
leaq -0x30(%rbp), %rdi
callq 0x20460
jmp 0x39e08
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5360
movq %rax, -0x88(%rbp)
jmp 0x39e1e
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x5360
jmp 0x39e34
leaq -0x30(%rbp), %rdi
callq 0x5788
leaq -0x31(%rbp), %rdi
callq 0x5420
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x361d0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x39f63
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x56d0
movq -0x98(%rbp), %rdx
leaq 0x11fe2(%rip), %rsi     # 0x4be82
leaq -0x68(%rbp), %rdi
callq 0x20460
jmp 0x39eab
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5360
movq %rax, -0xa8(%rbp)
jmp 0x39ec4
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x3a3e0
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x5360
jmp 0x39ee7
leaq -0x68(%rbp), %rdi
callq 0x5788
leaq -0x69(%rbp), %rdi
callq 0x5420
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x39e4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x39f2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5788
leaq -0x31(%rbp), %rdi
callq 0x5420
jmp 0x39f70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x39f58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5788
leaq -0x69(%rbp), %rdi
callq 0x5420
jmp 0x39f70
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x56c0
nopl (%rax)
// File: mhe[P]raytracerframework_cpp/yaml/parserstate.cpp
// Function: YAML::ParserState::Reset()
void ParserState::Reset()
	{
		// version
		version.major = 1;
		version.minor = 2;

		// and tags
		tags.clear();
		tags["!"] = "!";
		tags["!!"] = "tag:yaml.org,2002:";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x1, (%rdi)
movl $0x2, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, -0x78(%rbp)
callq 0x3b550
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x56d0
movq -0x70(%rbp), %rdx
leaq 0x10b2c(%rip), %rsi     # 0x4beb5
leaq -0x28(%rbp), %rdi
callq 0x20460
jmp 0x3b394
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3b570
movq %rax, -0x88(%rbp)
jmp 0x3b3aa
movq -0x88(%rbp), %rdi
leaq 0x10afd(%rip), %rsi     # 0x4beb5
callq 0x55a0
jmp 0x3b3bf
leaq -0x28(%rbp), %rdi
callq 0x5788
leaq -0x29(%rbp), %rdi
callq 0x5420
movq -0x80(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x98(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x56d0
movq -0x90(%rbp), %rdx
leaq 0x10ab6(%rip), %rsi     # 0x4beb4
leaq -0x60(%rbp), %rdi
callq 0x20460
jmp 0x3b409
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3b570
movq %rax, -0xa0(%rbp)
jmp 0x3b422
movq -0xa0(%rbp), %rdi
leaq 0x10a71(%rip), %rsi     # 0x4bea1
callq 0x55a0
jmp 0x3b437
leaq -0x60(%rbp), %rdi
callq 0x5788
leaq -0x61(%rbp), %rdi
callq 0x5420
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3b475
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5788
leaq -0x29(%rbp), %rdi
callq 0x5420
jmp 0x3b4ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3b4a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5788
leaq -0x61(%rbp), %rdi
callq 0x5420
movq -0x38(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: mhe[P]raytracerframework_cpp/yaml/parserstate.cpp
// Function: YAML::ParserState::TranslateTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string ParserState::TranslateTag(const std::string& handle) const
	{
		std::map <std::string, std::string>::const_iterator it = tags.find(handle);
		if(it == tags.end())
			return handle;

		return it->second;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x3b650
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x3b6b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3b680
testb $0x1, %al
jne 0x3b51c
jmp 0x3b52b
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5170
jmp 0x3b544
leaq -0x20(%rbp), %rdi
callq 0x3b6e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x5170
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop