LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG::decode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, unsigned char const*, unsigned int, unsigned int, unsigned int)
unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const unsigned char* in, unsigned size, unsigned colorType, unsigned bitDepth)
  {
    Decoder decoder;
    decoder.getInfoRaw().color.colorType = colorType;
    decoder.getInfoRaw().color.bitDepth = bitDepth;
    decoder.decode(out, in, size);
    w = decoder.getWidth();
    h = decoder.getHeight();
    return decoder.getError();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movl 0x10(%rbp), %eax
movabsq $0x100000001, %rdx      # imm = 0x100000001
leaq -0x138(%rbp), %rdi
movq %rdx, 0x8(%rdi)
xorl %edx, %edx
movl %edx, 0x10(%rdi)
movq $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x70(%rdi)
movabsq $0x800000006, %r10      # imm = 0x800000006
movq %r10, 0x58(%rdi)
movups %xmm0, 0x60(%rdi)
movl %edx, 0x50(%rdi)
movl %edx, 0xe0(%rdi)
movups %xmm0, 0xf0(%rdi)
movups %xmm0, 0x100(%rdi)
movups %xmm0, 0x110(%rdi)
movups %xmm0, 0xc0(%rdi)
movups %xmm0, 0xb0(%rdi)
movups %xmm0, 0xa0(%rdi)
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0x80(%rdi)
movb $0x0, 0xd0(%rdi)
movl $0x1, 0x120(%rdi)
movl %r9d, 0x18(%rdi)
movl %eax, 0x1c(%rdi)
movl %r8d, %eax
movq %rcx, %rdx
movq %rax, %rcx
callq 0x217a0
leaq -0x138(%rbp), %rdi
movl 0x40(%rdi), %eax
movl %eax, (%r14)
movl 0x44(%rdi), %eax
movl %eax, (%rbx)
movl 0x120(%rdi), %ebx
callq 0x1edee
movl %ebx, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x138(%rbp), %rdi
callq 0x1edee
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG::encode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned int, unsigned int, unsigned int, unsigned int)
unsigned encode(std::vector<unsigned char>& out, const unsigned char* in, unsigned w, unsigned h, unsigned colorType, unsigned bitDepth)
  {
    Encoder encoder;
    encoder.getInfoRaw().color.colorType = colorType;
    encoder.getInfoRaw().color.bitDepth = bitDepth;
    encoder.encode(out, in, w, h);
    return encoder.getError();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movl %ecx, %eax
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rsi
movaps 0xe8cd(%rip), %xmm0     # 0x307d0
leaq -0x138(%rbp), %rdi
movups %xmm0, (%rdi)
movabsq $0x100000000, %r10      # imm = 0x100000000
movq %r10, 0x10(%rdi)
xorl %r10d, %r10d
movl %r10d, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x50(%rdi)
movabsq $0x800000006, %r11      # imm = 0x800000006
movq %r11, 0x38(%rdi)
movups %xmm0, 0x40(%rdi)
movl %r10d, 0x30(%rdi)
movl %r10d, 0xc0(%rdi)
movups %xmm0, 0xd0(%rdi)
movups %xmm0, 0xe0(%rdi)
movups %xmm0, 0xf0(%rdi)
movups %xmm0, 0xa0(%rdi)
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movb $0x0, 0xb0(%rdi)
movups %xmm0, 0x118(%rdi)
movups %xmm0, 0x108(%rdi)
movl $0x1, 0x128(%rdi)
movl %r8d, 0x100(%rdi)
movl %r9d, 0x104(%rdi)
movl %eax, %r8d
callq 0x21962
leaq -0x138(%rbp), %rdi
movl 0x128(%rdi), %ebx
callq 0x21432
movl %ebx, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x138(%rbp), %rdi
callq 0x21432
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: LodePNG::encode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char const*, unsigned int, unsigned int, unsigned int, unsigned int)
unsigned encode(const std::string& filename, const unsigned char* in, unsigned w, unsigned h, unsigned colorType, unsigned bitDepth)
  {
    std::vector<unsigned char> buffer;
    Encoder encoder;
    encoder.getInfoRaw().color.colorType = colorType;
    encoder.getInfoRaw().color.bitDepth = bitDepth;
    encoder.encode(buffer, in, w, h);
    if(!encoder.hasError()) saveFile(buffer, filename);
    return encoder.getError();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movl %ecx, %eax
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movaps 0xe79f(%rip), %xmm1     # 0x307d0
leaq -0x160(%rbp), %rdi
movups %xmm1, (%rdi)
movabsq $0x100000000, %r10      # imm = 0x100000000
movq %r10, 0x10(%rdi)
xorl %r10d, %r10d
movl %r10d, 0x18(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x50(%rdi)
movabsq $0x800000006, %r11      # imm = 0x800000006
movq %r11, 0x38(%rdi)
movups %xmm0, 0x40(%rdi)
movl %r10d, 0x30(%rdi)
movl %r10d, 0xc0(%rdi)
movups %xmm0, 0xd0(%rdi)
movups %xmm0, 0xe0(%rdi)
movups %xmm0, 0xf0(%rdi)
movups %xmm0, 0xa0(%rdi)
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movb $0x0, 0xb0(%rdi)
movups %xmm0, 0x118(%rdi)
movups %xmm0, 0x108(%rdi)
movl $0x1, 0x128(%rdi)
movl %r8d, 0x100(%rdi)
movl %r9d, 0x104(%rdi)
movl %eax, %r8d
callq 0x21962
movl -0x38(%rbp), %r14d
testl %r14d, %r14d
jne 0x220f1
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x21c69
leaq -0x160(%rbp), %rdi
callq 0x21432
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x22112
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x42d0
movl %r14d, %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x160(%rbp), %rdi
callq 0x21432
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x22145
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: huffmanDecodeSymbol(unsigned int*, unsigned char const*, unsigned long*, HuffmanTree const*, unsigned long)
static unsigned huffmanDecodeSymbol(unsigned int* error, const unsigned char* in, size_t* bp, const HuffmanTree* codetree, size_t inlength)
{
  unsigned treepos = 0, decoded, ct;
  for(;;)
  {
    unsigned char bit;
    if(((*bp) & 0x07) == 0 && ((*bp) >> 3) > inlength) { *error = 10; return 0; } /*error: end of input memory reached without endcode*/
    bit = readBitFromStream(bp, in);
    *error = HuffmanTree_decode(codetree, &decoded, &ct, &treepos, bit);
    if(*error) return 0; /*stop, an error happened*/
    if(decoded) return ct;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdx), %rbx
testb $0x7, %bl
sete %al
movq %rbx, %r14
shrq $0x3, %r14
cmpq %r8, %r14
seta %r10b
movl $0xa, %r9d
testb %r10b, %al
jne 0x2223e
xorl %eax, %eax
xorl %r10d, %r10d
movzbl (%rsi,%r14), %r15d
leaq 0x1(%rbx), %r11
movq %r11, (%rdx)
movl 0x4c(%rcx), %r14d
cmpl %r14d, %r10d
jae 0x22242
andl $0x7, %ebx
xorl %r12d, %r12d
btl %ebx, %r15d
setb %r12b
movq (%rcx), %rbx
leal (%r12,%r10,2), %r10d
movl (%rbx,%r10,4), %ebx
movl %ebx, %r10d
subl %r14d, %r10d
jb 0x2224a
movl $0x0, (%rdi)
testb $0x7, %r11b
setne %bl
movq %r11, %r14
shrq $0x3, %r14
cmpq %r8, %r14
setbe %r15b
orb %bl, %r15b
movq %r11, %rbx
jne 0x221e5
xorl %eax, %eax
jmp 0x2224f
movl $0xb, %r9d
jmp 0x2224f
xorl %r9d, %r9d
movl %ebx, %eax
movl %r9d, (%rdi)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: generateFixedTree(HuffmanTree*)
static unsigned generateFixedTree(HuffmanTree* tree)
{
  unsigned i, error = 0;
  uivector bitlen;
  uivector_init(&bitlen);
  if(!uivector_resize(&bitlen, NUM_DEFLATE_CODE_SYMBOLS)) error = 9909;
  
  if(!error)
  {
    /*288 possible codes: 0-255=literals, 256=endcode, 257-285=lengthcodes, 286-287=unused*/
    for(i =   0; i <= 143; i++) bitlen.data[i] = 8;
    for(i = 144; i <= 255; i++) bitlen.data[i] = 9;
    for(i = 256; i <= 279; i++) bitlen.data[i] = 7;
    for(i = 280; i <= 287; i++) bitlen.data[i] = 8;
    
    error = HuffmanTree_makeFromLengths(tree, bitlen.data, NUM_DEFLATE_CODE_SYMBOLS, 15);
  }
  
  uivector_cleanup(&bitlen);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x900, %edi            # imm = 0x900
callq 0x4410
movq %rax, %rbx
testq %rax, %rax
je 0x222e5
xorl %eax, %eax
movl $0x8, (%rbx,%rax,4)
incq %rax
cmpq $0x90, %rax
jne 0x22279
movl $0x90, %eax
movl $0x9, (%rbx,%rax,4)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x22290
movl $0x100, %eax            # imm = 0x100
movl $0x7, (%rbx,%rax,4)
incq %rax
cmpq $0x118, %rax            # imm = 0x118
jne 0x222a7
movl $0x118, %eax            # imm = 0x118
movl $0x8, (%rbx,%rax,4)
incq %rax
cmpq $0x120, %rax            # imm = 0x120
jne 0x222be
movl $0x120, %edx            # imm = 0x120
movq %r14, %rdi
movq %rbx, %rsi
movl $0xf, %ecx
callq 0x22395
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: generateDistanceTree(HuffmanTree*)
static unsigned generateDistanceTree(HuffmanTree* tree)
{
  unsigned i, error = 0;
  uivector bitlen;
  uivector_init(&bitlen);
  if(!uivector_resize(&bitlen, NUM_DISTANCE_SYMBOLS)) error = 9910;
  
  /*there are 32 distance codes, but 30-31 are unused*/
  if(!error)
  {
    for(i = 0; i < NUM_DISTANCE_SYMBOLS; i++) bitlen.data[i] = 5;
    error = HuffmanTree_makeFromLengths(tree, bitlen.data, NUM_DISTANCE_SYMBOLS, 15);
  }
  uivector_cleanup(&bitlen);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x100, %edi            # imm = 0x100
callq 0x4410
movq %rax, %rbx
testq %rax, %rax
je 0x22334
xorl %eax, %eax
movl $0x5, (%rbx,%rax,4)
incq %rax
cmpq $0x20, %rax
jne 0x2230f
movl $0x20, %edx
movq %r14, %rdi
movq %rbx, %rsi
movl $0xf, %ecx
callq 0x22395
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: uivector_resize(uivector*, unsigned long)
static unsigned uivector_resize(uivector* p, size_t size) /*returns 1 if success, 0 if failure ==> nothing done*/
{
  if(size * sizeof(unsigned) > p->allocsize)
  {
    size_t newsize = size * sizeof(unsigned) * 2;
    void* data = realloc(p->data, newsize);
    if(data)
    {
      p->allocsize = newsize;
      p->data = (unsigned*)data;
      p->size = size;
    }
    else return 0;
  }
  else p->size = size;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rsi,4), %rax
cmpq 0x10(%rdi), %rax
jbe 0x2237d
leaq (,%rbx,8), %r15
movq (%r14), %rdi
movq %r15, %rsi
callq 0x44f0
testq %rax, %rax
je 0x22391
movq %r15, 0x10(%r14)
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x22386
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: HuffmanTree_makeFromLengths(HuffmanTree*, unsigned int const*, unsigned long, unsigned int)
static unsigned HuffmanTree_makeFromLengths(HuffmanTree* tree, const unsigned* bitlen, size_t numcodes, unsigned maxbitlen)
{
  unsigned i;
  if(!uivector_resize(&tree->lengths, numcodes)) return 9903;
  for(i = 0; i < numcodes; i++) tree->lengths.data[i] = bitlen[i];
  tree->numcodes = (unsigned)numcodes; /*number of symbols*/
  tree->maxbitlen = maxbitlen;
  return HuffmanTree_makeFromLengths2(tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x30(%rdi), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x22340
testl %eax, %eax
je 0x223f8
testq %r15, %r15
je 0x223dd
movq (%r13), %rax
xorl %ecx, %ecx
movl (%r12,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
movl %ecx, %edx
cmpq %r15, %rdx
jb 0x223cc
movl %r15d, 0x4c(%r14)
movl %ebx, 0x48(%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2240c
movl $0x26af, %eax           # imm = 0x26AF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: vector_resize(vector*, unsigned long)
static unsigned vector_resize(vector* p, size_t size) /*returns 1 if success, 0 if failure ==> nothing done*/
{
  if(size * p->typesize > p->allocsize)
  {
    size_t newsize = size * p->typesize * 2;
    void* data = realloc(p->data, newsize);
    if(data)
    {
      p->allocsize = newsize;
      p->data = data;
      p->size = size;
    }
    else return 0;
  }
  else p->size = size;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rdi), %r15d
imulq %rsi, %r15
cmpq 0x10(%rdi), %r15
jbe 0x22d32
addq %r15, %r15
movq (%r14), %rdi
movq %r15, %rsi
callq 0x44f0
testq %rax, %rax
je 0x22d46
movq %r15, 0x10(%r14)
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x22d3b
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/lodepng.cpp
// Function: removePaddingBits(unsigned char*, unsigned char const*, unsigned long, unsigned long, unsigned int)
static void removePaddingBits(unsigned char* out, const unsigned char* in, size_t olinebits, size_t ilinebits, unsigned h)
{
  /*
  After filtering there are still padding bits if scanlines have non multiple of 8 bit amounts. They need to be removed (except at last scanline of (Adam7-reduced) image) before working with pure image buffers for the Adam7 code, the color convert code and the output to the user.
  in and out are allowed to be the same buffer, in may also be higher but still overlapping; in must have >= ilinebits*h bits, out must have >= olinebits*h bits, olinebits must be <= ilinebits
  also used to move bits after earlier such operations happened, e.g. in a sequence of reduced images from Adam7
  only useful if (ilinebits - olinebits) is a value in the range 1..7
  */
  unsigned y;
  size_t diff = ilinebits - olinebits;
  size_t obp = 0, ibp = 0; /*bit pointers*/
  for(y = 0; y < h; y++)
  {
    size_t x;
    for(x = 0; x < olinebits; x++)
    {
      unsigned char bit = readBitFromReversedStream(&ibp, in);
      setBitOfReversedStream(&obp, out, bit);
    }
    ibp += diff;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, -0x30(%rbp)
testl %r8d, %r8d
je 0x23b77
subq %rdx, -0x30(%rbp)
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %r11d, %r11d
testq %rdx, %rdx
je 0x23b6b
leaq (%r11,%rdx), %rbx
movq %rdx, %r14
movq %r10, %r15
movq %r15, %rcx
shrq $0x3, %rcx
movl %r15d, %r12d
notb %r12b
movzbl (%rsi,%rcx), %r13d
movzbl %r12b, %eax
andl $0x7, %eax
movl %r11d, %ecx
notb %cl
andb $0x7, %cl
movb $0x1, %r12b
shlb %cl, %r12b
btl %eax, %r13d
jae 0x23b4c
movq %r11, %rax
shrq $0x3, %rax
orb %r12b, (%rdi,%rax)
jmp 0x23b5a
notb %r12b
movq %r11, %rax
shrq $0x3, %rax
andb %r12b, (%rdi,%rax)
incq %r11
incq %r15
decq %r14
jne 0x23b12
addq %rdx, %r10
movq %rbx, %r11
addq -0x30(%rbp), %r10
incl %r9d
cmpl %r8d, %r9d
jne 0x23b03
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x38(%rbp)
movl %r8d, -0x2c(%rbp)
testl %r8d, %r8d
je 0x23d5f
movq %rcx, %rax
movq -0x38(%rbp), %r8
subq %rcx, %r8
xorl %r10d, %r10d
xorl %r11d, %r11d
xorl %r14d, %r14d
testq %rax, %rax
je 0x23d22
leaq (%r14,%rax), %rbx
movq %rax, %r15
movq %r11, %r12
movq %r12, %rcx
shrq $0x3, %rcx
movl %r12d, %r13d
notb %r13b
movzbl (%rsi,%rcx), %r9d
movzbl %r13b, %edx
andl $0x7, %edx
movl %r14d, %ecx
notb %cl
andb $0x7, %cl
movb $0x1, %r13b
shlb %cl, %r13b
btl %edx, %r9d
jae 0x23d04
movq %r14, %rcx
shrq $0x3, %rcx
orb %r13b, (%rdi,%rcx)
jmp 0x23d12
notb %r13b
movq %r14, %rcx
shrq $0x3, %rcx
andb %r13b, (%rdi,%rcx)
incq %r14
incq %r12
decq %r15
jne 0x23cca
addq %rax, %r11
jmp 0x23d25
movq %r14, %rbx
cmpq %rax, -0x38(%rbp)
je 0x23d4f
leaq (%r8,%rbx), %r14
movq %r8, %r15
movl %ebx, %ecx
notb %cl
movb $-0x2, %dl
rolb %cl, %dl
movq %rbx, %rcx
shrq $0x3, %rcx
andb %dl, (%rdi,%rcx)
incq %rbx
decq %r15
jne 0x23d32
movq %r14, %rbx
incl %r10d
movq %rbx, %r14
cmpl -0x2c(%rbp), %r10d
jne 0x23cbb
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r13
cmpl $0x0, (%rsi)
je 0x2466d
movq %rdx, %r14
movq %rsi, %r12
movq %r13, -0x38(%rbp)
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
xorl %ebx, %ebx
leaq -0x40(%rbp), %r13
xorl %r15d, %r15d
movq 0x8(%r12,%rbx,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %r13, %rdx
callq *0x10(%rax)
testb %al, %al
je 0x245f1
movsd -0x40(%rbp), %xmm0
testq %r15, %r15
je 0x245e7
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x245f1
movq 0x8(%r12,%rbx,8), %r15
movsd %xmm0, -0x30(%rbp)
incq %rbx
movl (%r12), %eax
cmpq %rax, %rbx
jb 0x245bd
testq %r15, %r15
movq -0x38(%rbp), %r13
je 0x2466d
movsd 0x18(%r14), %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
movsd 0x20(%r14), %xmm1
mulsd %xmm2, %xmm1
mulsd 0x28(%r14), %xmm2
addsd (%r14), %xmm0
addsd 0x8(%r14), %xmm1
movq 0x8(%r15), %rbx
addsd 0x10(%r14), %xmm2
leaq -0x70(%rbp), %rdx
movsd %xmm0, (%rdx)
movsd %xmm1, 0x8(%rdx)
movsd %xmm2, 0x10(%rdx)
movq (%r15), %rax
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r13)
movupd (%rbx), %xmm0
movupd %xmm0, (%r13)
jmp 0x2467f
xorpd %xmm0, %xmm0
movupd %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl 0xc(%rsi), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
jle 0x2483b
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
movq %rax, -0x40(%rbp)
leaq 0x380(%rdi), %r15
movq $0x0, -0x38(%rbp)
movsd 0xc023(%rip), %xmm5     # 0x306f8
cmpl $0x0, -0x40(%rbp)
jle 0x24828
movq -0x38(%rbp), %rcx
movl %ecx, %eax
notl %eax
addl -0x2c(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x60(%rbp)
xorpd %xmm0, %xmm0
movslq %ecx, %r12
xorl %r13d, %r13d
movsd %xmm0, -0x68(%rbp)
subsd 0x380(%r14), %xmm0
movsd -0x60(%rbp), %xmm1
subsd 0x388(%r14), %xmm1
xorpd %xmm2, %xmm2
subsd 0x390(%r14), %xmm2
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
movapd %xmm0, %xmm4
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm4, %xmm3
sqrtsd %xmm3, %xmm3
movapd %xmm5, %xmm4
divsd %xmm3, %xmm4
mulsd %xmm4, %xmm0
mulsd %xmm4, %xmm1
mulsd %xmm2, %xmm4
movq 0x10(%r15), %rax
movq %rax, -0x90(%rbp)
movups (%r15), %xmm2
movaps %xmm2, -0xa0(%rbp)
movsd %xmm0, -0x88(%rbp)
movsd %xmm1, -0x80(%rbp)
movsd %xmm4, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
leaq -0xa0(%rbp), %rdx
callq 0x24584
movsd 0xbf54(%rip), %xmm5     # 0x306f8
movsd -0x58(%rbp), %xmm0
ucomisd %xmm5, %xmm0
jbe 0x247bd
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x58(%rbp)
movsd -0x50(%rbp), %xmm0
ucomisd %xmm5, %xmm0
jbe 0x247d6
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
ucomisd %xmm5, %xmm0
jbe 0x247ef
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x48(%rbp)
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
imulq %r12, %rcx
addq %r13, %rcx
leaq (%rcx,%rcx,2), %rcx
movq -0x48(%rbp), %rdx
movq %rdx, 0x10(%rax,%rcx,8)
movups -0x58(%rbp), %xmm0
movups %xmm0, (%rax,%rcx,8)
movsd -0x68(%rbp), %xmm0
addsd %xmm5, %xmm0
incq %r13
cmpl %r13d, -0x40(%rbp)
jne 0x24700
movq -0x38(%rbp), %rax
incl %eax
movq %rax, -0x38(%rbp)
cmpl -0x2c(%rbp), %eax
jne 0x246d5
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x249c3
movl %edx, %ebx
movl %esi, %r14d
movq (%rdi), %rdx
xorl %edi, %edi
movl $0x1, %esi
xorl %eax, %eax
movsbl (%rdx,%rdi), %edi
leal -0x61(%rdi), %r9d
movl $0xffffffa9, %r8d       # imm = 0xFFFFFFA9
cmpb $0x6, %r9b
jb 0x249b0
leal -0x41(%rdi), %r9d
movl $0xffffffc9, %r8d       # imm = 0xFFFFFFC9
cmpb $0x6, %r9b
jb 0x249b0
leal -0x30(%rdi), %r9d
movl $0xffffffd0, %r8d       # imm = 0xFFFFFFD0
cmpb $0xa, %r9b
jae 0x249d0
shll $0x4, %eax
addl %r8d, %eax
addl %edi, %eax
movl %esi, %edi
incl %esi
cmpq %rdi, %rcx
ja 0x2497c
jmp 0x249c5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x4140
movq %rax, %r15
leaq 0x17ff4(%rip), %rcx     # 0x3c9d8
movq %rax, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x257ee
leaq 0x15c60(%rip), %rsi     # 0x3a658
leaq -0xb1fd(%rip), %rdx     # 0x19802
movq %r15, %rdi
callq 0x4510
movq %rax, %rbx
movq %r15, %rdi
callq 0x4230
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movl (%r14), %eax
cmpl $0x2, %eax
je 0x25989
cmpl $0x1, %eax
jne 0x25996
addq $0x8, 0x8(%r14)
jmp 0x25996
movq 0x10(%r14), %rdi
callq 0x4360
movq %rax, 0x10(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x42c0
movq (%r14), %r14
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
movl (%r14), %eax
cmpl $0x2, %eax
je 0x259de
cmpl $0x1, %eax
jne 0x259eb
addq $0x8, 0x8(%r14)
jmp 0x259eb
movq 0x10(%r14), %rdi
callq 0x4360
movq %rax, 0x10(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq (%rdi), %rcx
movl (%rcx), %edi
movq (%rsi), %rdx
cmpl (%rdx), %edi
jne 0x25b7f
cmpl $0x1, %edi
je 0x25b83
movb $0x1, %al
cmpl $0x2, %edi
jne 0x25b93
movl $0x10, %eax
jmp 0x25b88
xorl %eax, %eax
jmp 0x25b93
movl $0x8, %eax
movq (%rcx,%rax), %rcx
cmpq (%rdx,%rax), %rcx
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
leaq 0x10(%rdi), %r12
cmpq %r12, %r14
je 0x25ca3
movq 0x20(%r14), %r15
testq %r15, %r15
je 0x25c68
movq %r15, %rdi
callq 0x26b36
movl $0x58, %esi
movq %r15, %rdi
callq 0x42d0
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x25c86
movq %r15, %rdi
callq 0x26b36
movl $0x58, %esi
movq %r15, %rdi
callq 0x42d0
movq %r14, %rdi
callq 0x4360
movq %rax, %r14
cmpq %r12, %rax
jne 0x25c57
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x26778
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x25c3c
movq %r14, %rdi
callq 0x2ab2c
movl 0x4(%rax), %eax
cmpl $0x8, %eax
je 0x25d3f
cmpl $0x4, %eax
jne 0x25d57
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x25d62
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2600e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/map.cpp
// Function: YAML::Map::Write(std::ostream&, int, bool, bool)
void Map::Write(std::ostream& out, int indent, bool startedLine, bool onlyOneCharOnLine)
	{
		if(startedLine && !onlyOneCharOnLine)
			out << "\n";

		for(node_map::const_iterator it=m_data.begin();it!=m_data.end();++it) {
			if((startedLine && !onlyOneCharOnLine) || it != m_data.begin()) {
				for(int i=0;i<indent;i++)
					out << "  ";
			}

			out << "? ";
			it->first->Write(out, indent + 1, true, it!= m_data.begin() || !startedLine || onlyOneCharOnLine);

			for(int i=0;i<indent;i++)
				out << "  ";
			out << ": ";
			it->second->Write(out, indent + 1, true, true);
		}

		if(m_data.empty())
			out << "\n";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
xorb $0x1, %cl
orb %r8b, %cl
movl %ecx, -0x30(%rbp)
jne 0x262a6
leaq 0xac56(%rip), %rsi      # 0x30eef
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4350
movq -0x38(%rbp), %rax
movq 0x20(%rax), %r13
addq $0x10, %rax
movq %rax, -0x40(%rbp)
cmpq %rax, %r13
je 0x26397
leal 0x1(%r15), %eax
movl %eax, -0x2c(%rbp)
leaq 0xab09(%rip), %r14      # 0x30dd6
testl %r15d, %r15d
setle %al
movq -0x38(%rbp), %rcx
cmpq 0x20(%rcx), %r13
sete %cl
andb -0x30(%rbp), %cl
orb %al, %cl
jne 0x262fd
movl %r15d, %r12d
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4350
decl %r12d
jne 0x262e8
movl $0x2, %edx
movq %rbx, %rdi
leaq 0xaacd(%rip), %rsi      # 0x30dd9
callq 0x4350
movq -0x38(%rbp), %rax
cmpq 0x20(%rax), %r13
movq 0x20(%r13), %rdi
setne %al
orb -0x30(%rbp), %al
movzbl %al, %r8d
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
movl $0x1, %ecx
callq 0x26ffa
movl %r15d, %r12d
testl %r15d, %r15d
jle 0x26354
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4350
decl %r12d
jne 0x2633f
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x9e92(%rip), %rsi      # 0x301f5
callq 0x4350
movq 0x28(%r13), %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x26ffa
movq %r13, %rdi
callq 0x4360
movq %rax, %r13
cmpq -0x40(%rbp), %rax
jne 0x262cd
movq -0x38(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x263b1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xab37(%rip), %rsi      # 0x30eef
movl $0x1, %edx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4350
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq 0x20(%rdi), %r14
movq 0x20(%rsi), %rbx
addq $0x10, %rdi
addq $0x10, %rsi
cmpq %rdi, %r14
je 0x26433
cmpq %rsi, %rbx
je 0x2643f
movq 0x20(%r14), %rdi
movq 0x20(%rbx), %rsi
callq 0x27746
testl %eax, %eax
jne 0x26444
movq 0x28(%r14), %rdi
movq 0x28(%rbx), %rsi
callq 0x27746
testl %eax, %eax
je 0x2640f
jmp 0x26444
xorl %eax, %eax
cmpq %rsi, %rbx
setne %al
negl %eax
jmp 0x26444
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::ltnode::operator()(YAML::Node const*, 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:
movq 0x48(%rsi), %rdi
movq 0x48(%rdx), %rsi
testq %rdi, %rdi
je 0x26ad0
testq %rsi, %rsi
je 0x26ad7
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
callq *0xa8(%rax)
shrl $0x1f, %eax
popq %rbp
retq
testq %rsi, %rsi
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/mhe[P]raytracerframework_cpp/yaml/node.cpp
// Function: YAML::Node::Parse(YAML::Scanner*, YAML::ParserState const&)
void Node::Parse(Scanner *pScanner, const ParserState& state)
	{
		Clear();

		// save location
		m_line = pScanner->peek().line;
		m_column = pScanner->peek().column;

		ParseHeader(pScanner, state);

		// is this an alias? if so, it can have no content
		if(m_alias)
			return;

		// now split based on what kind of node we should be
		switch(pScanner->peek().type) {
			case TT_SCALAR:
				m_pContent = new Scalar;
				m_pContent->Parse(pScanner, state);
				break;
			case TT_FLOW_SEQ_START:
			case TT_BLOCK_SEQ_START:
			case TT_BLOCK_ENTRY:
				m_pContent = new Sequence;
				m_pContent->Parse(pScanner, state);
				break;
			case TT_FLOW_MAP_START:
			case TT_BLOCK_MAP_START:
				m_pContent = new Map;
				m_pContent->Parse(pScanner, state);
				break;
			default:
				break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x26be7
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x48(%r15)
movb $0x0, 0x50(%r15)
movq %r14, %rdi
callq 0x2ab2c
movl 0x8(%rax), %eax
movl %eax, (%r15)
movq %r14, %rdi
callq 0x2ab2c
movl 0xc(%rax), %eax
movl %eax, 0x4(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x26ce6
cmpb $0x0, 0x50(%r15)
je 0x26c2f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x2ab2c
movl 0x4(%rax), %eax
cmpl $0x11, %eax
ja 0x26c26
movl $0xc8, %ecx
btl %eax, %ecx
jb 0x26c6a
movl $0x110, %ecx            # imm = 0x110
btl %eax, %ecx
jae 0x26c81
movl $0x38, %edi
callq 0x42c0
movq %rax, %r12
movq %rax, %rdi
callq 0x25bd0
jmp 0x26c9b
movl $0x20, %edi
callq 0x42c0
movq %rax, %r12
movq %rax, %rdi
callq 0x2e400
jmp 0x26c9b
cmpl $0x11, %eax
jne 0x26c26
movl $0x28, %edi
callq 0x42c0
movq %rax, %r12
movq %rax, %rdi
callq 0x29eb4
movq %r12, 0x48(%r15)
movq (%r12), %rax
movq 0x10(%rax), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rax, %rbx
movl $0x28, %esi
jmp 0x26cd6
movq %rax, %rbx
movl $0x38, %esi
jmp 0x26cd6
movq %rax, %rbx
movl $0x20, %esi
movq %r12, %rdi
callq 0x42d0
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2aa98
testb %al, %al
jne 0x26d4c
movq %r14, %rdi
callq 0x2ab2c
movl 0x4(%rax), %eax
cmpl $0xe, %eax
je 0x26d3c
cmpl $0xf, %eax
je 0x26d2f
cmpl $0x10, %eax
jne 0x26d4c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x26d58
jmp 0x26d47
movq %r15, %rdi
movq %r14, %rsi
callq 0x26f1a
jmp 0x26d47
movq %r15, %rdi
movq %r14, %rsi
callq 0x26e76
movq %r14, %rdi
jmp 0x26cfc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2ab2c
movq %rax, %rbx
addq $0x28, %r15
leaq 0x9f7a(%rip), %rsi      # 0x30d02
movq %r15, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x26e2a
movq %rbx, %rdx
addq $0x10, %rdx
leaq -0x48(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2878e
movq %r15, %rdi
movq %r13, %rsi
callq 0x43b0
movq (%r13), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x26dd2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x26e13
movl $0x1, %r12d
xorl %ecx, %ecx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %r15, %rdi
callq 0x40d0
movl %r12d, %ecx
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0x26de4
movq %r14, %rdi
callq 0x2aafa
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x4140
movq %rax, %r14
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
leaq 0x169cc(%rip), %rcx     # 0x3d810
movq %rax, %rdi
callq 0x257ee
leaq 0x13805(%rip), %rsi     # 0x3a658
leaq -0xd658(%rip), %rdx     # 0x19802
movq %r14, %rdi
callq 0x4510
movq %rax, %rbx
movq %r14, %rdi
callq 0x4230
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2ab2c
movq %rax, %r14
leaq 0x8(%r15), %r12
leaq 0x9e65(%rip), %rsi      # 0x30d02
movq %r12, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x26ecd
addq $0x10, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x4160
movb $0x0, 0x50(%r15)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2aafa
movl $0x30, %edi
callq 0x4140
movq %rax, %rbx
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
leaq 0x16947(%rip), %rcx     # 0x3d830
movq %rax, %rdi
callq 0x257ee
leaq 0x13760(%rip), %rsi     # 0x3a658
leaq -0xd6fd(%rip), %rdx     # 0x19802
movq %rbx, %rdi
callq 0x4510
movq %rax, %r14
movq %rbx, %rdi
callq 0x4230
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2ab2c
movq %rax, %r14
leaq 0x8(%r15), %r12
leaq 0x9dc1(%rip), %rsi      # 0x30d02
movq %r12, %rdi
callq 0x40c0
testl %eax, %eax
jne 0x26f85
leaq 0x28(%r15), %rdi
leaq 0x9daa(%rip), %rsi      # 0x30d02
callq 0x40c0
testl %eax, %eax
jne 0x26fab
addq $0x10, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x4160
movb $0x1, 0x50(%r15)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2aafa
movl $0x30, %edi
callq 0x4140
movq %rax, %rbx
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
leaq 0x168af(%rip), %rcx     # 0x3d850
movq %rax, %rdi
callq 0x257ee
jmp 0x26fcf
movl $0x30, %edi
callq 0x4140
movq %rax, %rbx
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
leaq 0x168a9(%rip), %rcx     # 0x3d870
movq %rax, %rdi
callq 0x257ee
leaq 0x13682(%rip), %rsi     # 0x3a658
leaq -0xd7db(%rip), %rdx     # 0x19802
movq %rbx, %rdi
callq 0x4510
jmp 0x26fe7
movq %rax, %r14
movq %rbx, %rdi
callq 0x4230
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x2738e
movq (%rdi), %rax
callq *0x50(%rax)
movl %eax, %ecx
movl $0x1, %eax
testb %cl, %cl
jne 0x27390
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movl %eax, %ecx
movl $0x2, %eax
testb %cl, %cl
jne 0x27390
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movzbl %al, %eax
leal (%rax,%rax,2), %eax
jmp 0x27390
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rsi), %rdi
testq %rdi, %rdi
je 0x27433
movq %rsi, %r14
leaq -0x20(%rbp), %rsi
movq $0x0, (%rsi)
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
je 0x273ed
movl $0x18, %edi
callq 0x42c0
movq -0x20(%rbp), %rcx
movl $0x1, (%rax)
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
jmp 0x27426
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x27433
movl $0x18, %edi
callq 0x42c0
movq -0x18(%rbp), %rcx
movl $0x2, (%rax)
movq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x258ce
jmp 0x2743b
movq %rbx, %rdi
callq 0x2589c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rsi), %rdi
testq %rdi, %rdi
je 0x274e3
movq %rsi, %r14
leaq -0x20(%rbp), %rsi
movq $0x0, (%rsi)
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2749d
movl $0x18, %edi
callq 0x42c0
movq -0x20(%rbp), %rcx
movl $0x1, (%rax)
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
jmp 0x274d6
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb %al, %al
je 0x274e3
movl $0x18, %edi
callq 0x42c0
movq -0x18(%rbp), %rcx
movl $0x2, (%rax)
movq $0x0, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x258ce
jmp 0x274eb
movq %rbx, %rdi
callq 0x2589c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, -0x14(%rbp)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x2754a
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
jne 0x27541
leaq -0x14(%rbp), %rsi
movq %rbx, %rdi
callq 0x2777a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x30, %edi
callq 0x4140
movq %rax, %rbx
movq %rax, %rdi
callq 0x19596
leaq 0x13122(%rip), %rsi     # 0x3a688
leaq -0xdd6b(%rip), %rdx     # 0x19802
movq %rbx, %rdi
callq 0x4510
movq %rax, %r14
movq %rbx, %rdi
callq 0x4230
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, -0x14(%rbp)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x275c2
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
jne 0x275b9
leaq -0x14(%rbp), %rsi
movq %rbx, %rdi
callq 0x278ba
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x30, %edi
callq 0x4140
movq %rax, %rbx
movq %rax, %rdi
callq 0x19596
leaq 0x130aa(%rip), %rsi     # 0x3a688
leaq -0xdde3(%rip), %rdx     # 0x19802
movq %rbx, %rdi
callq 0x4510
movq %rax, %r14
movq %rbx, %rdi
callq 0x4230
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x26b98
movq %rbx, %rdi
callq 0x27b7e
movq (%rbx), %rdi
callq 0x2aa98
testb %al, %al
je 0x27b34
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rdi
callq 0x2ab2c
cmpl $0x1, 0x4(%rax)
jne 0x27b4a
movq (%rbx), %rdi
callq 0x2aafa
movq (%rbx), %rsi
leaq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x26bc4
movq (%rbx), %rdi
callq 0x2aa98
testb %al, %al
jne 0x27b2f
movq (%rbx), %rdi
callq 0x2ab2c
cmpl $0x2, 0x4(%rax)
jne 0x27b2f
movq (%rbx), %rdi
callq 0x2aafa
jmp 0x27b59
nop