LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: addChunk_zTXt(ucvector*, char const*, char const*, LodePNGCompressSettings*)
static unsigned addChunk_zTXt(ucvector* out, const char* keyword, const char* textstring,
                              LodePNGCompressSettings* zlibsettings) {
  unsigned error = 0;
  ucvector data, compressed;
  size_t i, textsize = lodepng_strlen(textstring);

  ucvector_init(&data);
  ucvector_init(&compressed);
  for(i = 0; keyword[i] != 0; ++i) ucvector_push_back(&data, (unsigned char)keyword[i]);
  if(i < 1 || i > 79) return 89; /*error: invalid keyword size*/
  ucvector_push_back(&data, 0); /*0 termination char*/
  ucvector_push_back(&data, 0); /*compression method: 0*/

  error = zlib_compress(&compressed.data, &compressed.size,
                        (const unsigned char*)textstring, textsize, zlibsettings);
  if(!error) {
    for(i = 0; i != compressed.size; ++i) ucvector_push_back(&data, compressed.data[i]);
    error = addChunk(out, "zTXt", data.data, data.size);
  }

  ucvector_cleanup(&compressed);
  ucvector_cleanup(&data);
  return error;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movq 0x58(%rsp), %rdi
callq 0x13ef90
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x148440
leaq 0x18(%rsp), %rdi
callq 0x148440
movq $0x0, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x149af7
movq 0x60(%rsp), %rax
movq 0x10(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movzbl (%rax,%rcx), %esi
callq 0x14e670
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x149abc
cmpq $0x1, 0x10(%rsp)
jb 0x149b07
cmpq $0x4f, 0x10(%rsp)
jbe 0x149b14
movl $0x59, 0x74(%rsp)
jmp 0x149bd1
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x14e670
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x14e670
leaq 0x18(%rsp), %rdi
leaq 0x18(%rsp), %rsi
addq $0x8, %rsi
movq 0x58(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x50(%rsp), %r8
callq 0x14ac70
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x149bb5
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x149b96
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movzbl (%rax,%rcx), %esi
callq 0x14e670
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x149b62
movq 0x68(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq 0x2cb35(%rip), %rsi     # 0x1766e1
callq 0x1532d0
movl %eax, 0x4c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x14ff20
leaq 0x30(%rsp), %rdi
callq 0x14ff20
movl 0x4c(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: zlib_decompress(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*)
static unsigned zlib_decompress(unsigned char** out, size_t* outsize, const unsigned char* in,
                                size_t insize, const LodePNGDecompressSettings* settings) {
  if(settings->custom_zlib) {
    return settings->custom_zlib(out, outsize, in, insize, settings);
  } else {
    return lodepng_zlib_decompress(out, outsize, in, insize, settings);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x14ab13
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0x14ab35
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x13e820
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: zlib_compress(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGCompressSettings const*)
static unsigned zlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in,
                              size_t insize, const LodePNGCompressSettings* settings) {
  if(settings->custom_zlib) {
    return settings->custom_zlib(out, outsize, in, insize, settings);
  } else {
    return lodepng_zlib_compress(out, outsize, in, insize, settings);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x14acc3
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0x14ace5
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x13ea80
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng::decode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, LodePNGColorType, unsigned int)
unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const std::string& filename,
                LodePNGColorType colortype, unsigned bitdepth) {
  std::vector<unsigned char> buffer;
  /* safe output values in case error happens */
  w = h = 0;
  unsigned error = load_file(buffer, filename);
  if(error) return error;
  return decode(out, w, h, buffer, colortype, bitdepth);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movl %r8d, 0x4c(%rsp)
movl %r9d, 0x48(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x13c0d0
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rax
movl $0x0, (%rax)
movq 0x60(%rsp), %rax
movl $0x0, (%rax)
movq 0x50(%rsp), %rsi
callq 0x14a8e0
movl %eax, 0x14(%rsp)
jmp 0x14b24c
movl 0x14(%rsp), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x14b287
movl 0x2c(%rsp), %eax
movl %eax, 0x74(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x14b2c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x13c1a0
jmp 0x14b2d3
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
movl 0x4c(%rsp), %r8d
movl 0x48(%rsp), %r9d
leaq 0x30(%rsp), %rcx
callq 0x14afa0
movl %eax, 0x4(%rsp)
jmp 0x14b2b0
movl 0x4(%rsp), %eax
movl %eax, 0x74(%rsp)
movl $0x1, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x13c1a0
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xd0a10
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: ucvector_reserve(ucvector*, unsigned long)
static unsigned ucvector_reserve(ucvector* p, size_t allocsize) {
  if(allocsize > p->allocsize) {
    size_t newsize = (allocsize > p->allocsize * 2u) ? allocsize : ((allocsize * 3u) >> 1u);
    void* data = lodepng_realloc(p->data, newsize);
    if(data) {
      p->allocsize = newsize;
      p->data = (unsigned char*)data;
    }
    else return 0; /*error: not enough memory*/
  }
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x14bf44
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
jbe 0x14bee4
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x14bef2
imulq $0x3, 0x20(%rsp), %rax
shrq %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x13f5e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x14bf38
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x14bf42
movl $0x0, 0x34(%rsp)
jmp 0x14bf4c
jmp 0x14bf44
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: HuffmanTree_init(HuffmanTree*)
static void HuffmanTree_init(HuffmanTree* tree) {
  tree->codes = 0;
  tree->lengths = 0;
  tree->table_len = 0;
  tree->table_value = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: huffmanDecodeSymbol(LodePNGBitReader*, HuffmanTree const*)
static unsigned huffmanDecodeSymbol(LodePNGBitReader* reader, const HuffmanTree* codetree) {
  unsigned short code = peekBits(reader, FIRSTBITS);
  unsigned short l = codetree->table_len[code];
  unsigned short value = codetree->table_value[code];
  if(l <= FIRSTBITS) {
    advanceBits(reader, l);
    return value;
  } else {
    unsigned index2;
    advanceBits(reader, FIRSTBITS);
    index2 = value + peekBits(reader, l - FIRSTBITS);
    advanceBits(reader, codetree->table_len[index2] - FIRSTBITS);
    return codetree->table_value[index2];
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x9, %esi
callq 0x14b7c0
movw %ax, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movzwl 0xe(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movw %ax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movzwl 0xe(%rsp), %ecx
movw (%rax,%rcx,2), %ax
movw %ax, 0xa(%rsp)
movzwl 0xc(%rsp), %eax
cmpl $0x9, %eax
ja 0x14c656
movq 0x18(%rsp), %rdi
movzwl 0xc(%rsp), %eax
movl %eax, %esi
callq 0x14b7f0
movzwl 0xa(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x14c6c5
movq 0x18(%rsp), %rdi
movl $0x9, %esi
callq 0x14b7f0
movzwl 0xa(%rsp), %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
movzwl 0xc(%rsp), %eax
subl $0x9, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x14b7c0
movl %eax, %ecx
movl (%rsp), %eax
addl %ecx, %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x4(%rsp), %ecx
movzbl (%rax,%rcx), %eax
subl $0x9, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x14b7f0
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x4(%rsp), %ecx
movzwl (%rax,%rcx,2), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: HuffmanTree_cleanup(HuffmanTree*)
static void HuffmanTree_cleanup(HuffmanTree* tree) {
  lodepng_free(tree->codes);
  lodepng_free(tree->lengths);
  lodepng_free(tree->table_len);
  lodepng_free(tree->table_value);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x13e2d0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x13e2d0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x13e2d0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x13e2d0
popq %rax
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: generateFixedLitLenTree(HuffmanTree*)
static unsigned generateFixedLitLenTree(HuffmanTree* tree) {
  unsigned i, error = 0;
  unsigned* bitlen = (unsigned*)lodepng_malloc(NUM_DEFLATE_CODE_SYMBOLS * sizeof(unsigned));
  if(!bitlen) return 83; /*alloc fail*/

  /*288 possible codes: 0-255=literals, 256=endcode, 257-285=lengthcodes, 286-287=unused*/
  for(i =   0; i <= 143; ++i) bitlen[i] = 8;
  for(i = 144; i <= 255; ++i) bitlen[i] = 9;
  for(i = 256; i <= 279; ++i) bitlen[i] = 7;
  for(i = 280; i <= 287; ++i) bitlen[i] = 8;

  error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DEFLATE_CODE_SYMBOLS, 15);

  lodepng_free(bitlen);
  return error;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x480, %edi            # imm = 0x480
callq 0x13ce80
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x14c745
movl $0x53, 0x24(%rsp)
jmp 0x14c830
movl $0x0, 0x14(%rsp)
cmpl $0x8f, 0x14(%rsp)
ja 0x14c774
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl $0x8, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x14c74d
movl $0x90, 0x14(%rsp)
cmpl $0xff, 0x14(%rsp)
ja 0x14c7a3
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl $0x9, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x14c77c
movl $0x100, 0x14(%rsp)      # imm = 0x100
cmpl $0x117, 0x14(%rsp)      # imm = 0x117
ja 0x14c7d2
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl $0x7, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x14c7ab
movl $0x118, 0x14(%rsp)      # imm = 0x118
cmpl $0x11f, 0x14(%rsp)      # imm = 0x11F
ja 0x14c801
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl $0x8, (%rax,%rcx,4)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x14c7da
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x120, %edx            # imm = 0x120
movl $0xf, %ecx
callq 0x14c8e0
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x13e2d0
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: reverseBits(unsigned int, unsigned int)
static unsigned reverseBits(unsigned bits, unsigned num) {
  /*TODO: implement faster lookup table based version when needed*/
  unsigned i, result = 0;
  for(i = 0; i < num; i++) result |= ((bits >> (num - i - 1u)) & 1u) << i;
  return result;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl $0x0, -0x10(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
cmpl -0x8(%rsp), %eax
jae 0x14d311
movl -0x4(%rsp), %eax
movl -0x8(%rsp), %ecx
subl -0xc(%rsp), %ecx
subl $0x1, %ecx
shrl %cl, %eax
andl $0x1, %eax
movl -0xc(%rsp), %ecx
shll %cl, %eax
orl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x14d2d8
movl -0x10(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: writeBits(LodePNGBitWriter*, unsigned int, unsigned long)
static void writeBits(LodePNGBitWriter* writer, unsigned value, size_t nbits) {
  if(nbits == 1) { /* compiler should statically compile this case if nbits == 1 */
    WRITEBIT(writer, value);
  } else {
    /* TODO: increase output size nly once here rather than in each WRITEBIT */
    size_t i;
    for(i = 0; i != nbits; ++i) {
      WRITEBIT(writer, (unsigned char)((value >> i) & 1));
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x1, 0x10(%rsp)
jne 0x14e76b
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x14e71c
movq 0x20(%rsp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x14e670
movl 0x1c(%rsp), %esi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x7, %rax
movl %eax, %ecx
shll %cl, %esi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x14e812
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x14e810
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x14e7a6
movq 0x20(%rsp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x14e670
movl 0x1c(%rsp), %eax
movq 0x8(%rsp), %rcx
shrl %cl, %eax
andl $0x1, %eax
movzbl %al, %esi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x7, %rax
movl %eax, %ecx
shll %cl, %esi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x14e774
jmp 0x14e812
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: writeBitsReversed(LodePNGBitWriter*, unsigned int, unsigned long)
static void writeBitsReversed(LodePNGBitWriter* writer, unsigned value, size_t nbits) {
  size_t i;
  for(i = 0; i != nbits; ++i) {
    /* TODO: increase output size only once here rather than in each WRITEBIT */
    WRITEBIT(writer, (unsigned char)((value >> (nbits - 1u - i)) & 1u));
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x14f400
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x14f38d
movq 0x20(%rsp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x14e670
movl 0x1c(%rsp), %eax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
subq 0x8(%rsp), %rcx
shrl %cl, %eax
andl $0x1, %eax
movzbl %al, %esi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
andq $0x7, %rax
movl %eax, %ecx
shll %cl, %esi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x14f35b
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: uivector_reserve(uivector*, unsigned long)
static unsigned uivector_reserve(uivector* p, size_t allocsize) {
  if(allocsize > p->allocsize) {
    size_t newsize = (allocsize > p->allocsize * 2u) ? allocsize : ((allocsize * 3u) >> 1u);
    void* data = lodepng_realloc(p->data, newsize);
    if(data) {
      p->allocsize = newsize;
      p->data = (unsigned*)data;
    }
    else return 0; /*error: not enough memory*/
  }
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x14f904
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
jbe 0x14f8a4
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x14f8b2
imulq $0x3, 0x20(%rsp), %rax
shrq %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x13f5e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x14f8f8
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x14f902
movl $0x0, 0x34(%rsp)
jmp 0x14f90c
jmp 0x14f904
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: uivector_resizev(uivector*, unsigned long, unsigned int)
static unsigned uivector_resizev(uivector* p, size_t size, unsigned value) {
  size_t oldsize = p->size, i;
  if(!uivector_resize(p, size)) return 0;
  for(i = oldsize; i < size; ++i) p->data[i] = value;
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x14f810
cmpl $0x0, %eax
jne 0x14fa0e
movl $0x0, 0x34(%rsp)
jmp 0x14fa50
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x14fa48
movl 0x1c(%rsp), %edx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x14fa18
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: HuffmanTree_makeFromFrequencies(HuffmanTree*, unsigned int const*, unsigned long, unsigned long, unsigned int)
static unsigned HuffmanTree_makeFromFrequencies(HuffmanTree* tree, const unsigned* frequencies,
                                                size_t mincodes, size_t numcodes, unsigned maxbitlen) {
  size_t i;
  unsigned error = 0;
  while(!frequencies[numcodes - 1] && numcodes > mincodes) --numcodes; /*trim zeroes*/
  tree->maxbitlen = maxbitlen;
  tree->numcodes = (unsigned)numcodes; /*number of symbols*/
  tree->lengths = (unsigned*)lodepng_realloc(tree->lengths, numcodes * sizeof(unsigned));
  if(!tree->lengths) return 83; /*alloc fail*/
  /*initialize all lengths to 0*/
  for(i = 0; i < numcodes; i++) tree->lengths[i] = 0;

  error = lodepng_huffman_code_lengths(tree->lengths, frequencies, numcodes, maxbitlen);
  if(!error) error = HuffmanTree_makeFromLengths2(tree);
  return error;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rdx
subq $0x1, %rdx
xorl %eax, %eax
cmpl $0x0, (%rcx,%rdx,4)
movb %al, 0xb(%rsp)
jne 0x14fab0
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
seta %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x14faba
jmp 0x14faca
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x14fa85
movl 0x1c(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rax
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rsi
shlq $0x2, %rsi
callq 0x13f5e0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x14fb1e
movl $0x53, 0x44(%rsp)
jmp 0x14fb95
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x14fb58
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x14fb27
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0x13d800
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x14fb8d
movq 0x38(%rsp), %rdi
callq 0x14c990
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: update_adler32(unsigned int, unsigned char const*, unsigned int)
static unsigned update_adler32(unsigned adler, const unsigned char* data, unsigned len) {
  unsigned s1 = adler & 0xffffu;
  unsigned s2 = (adler >> 16u) & 0xffffu;

  while(len != 0u) {
    unsigned i;
    /*at least 5552 sums can be done before the sums overflow, saving a lot of module divisions*/
    unsigned amount = len > 5552u ? 5552u : len;
    len -= amount;
    for(i = 0; i != amount; ++i) {
      s1 += (*data++);
      s2 += s1;
    }
    s1 %= 65521u;
    s2 %= 65521u;
  }

  return (s2 << 16u) | s1;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x4(%rsp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x18(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x14(%rsp)
je 0x14fc76
cmpl $0x15b0, -0x14(%rsp)    # imm = 0x15B0
jbe 0x14fbea
movl $0x15b0, %eax           # imm = 0x15B0
movl %eax, -0x28(%rsp)
jmp 0x14fbf2
movl -0x14(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %ecx
movl -0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x24(%rsp), %eax
je 0x14fc4f
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movzbl (%rax), %eax
addl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
addl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x14fc10
movl -0x18(%rsp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x18(%rsp)
movl -0x1c(%rsp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x1c(%rsp)
jmp 0x14fbca
movl -0x1c(%rsp), %eax
shll $0x10, %eax
orl -0x18(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: readBitsFromReversedStream(unsigned long*, unsigned char const*, unsigned long)
static unsigned readBitsFromReversedStream(size_t* bitpointer, const unsigned char* bitstream, size_t nbits) {
  unsigned result = 0;
  size_t i;
  for(i = 0 ; i < nbits; ++i) {
    result <<= 1u;
    result |= (unsigned)readBitFromReversedStream(bitpointer, bitstream);
  }
  return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x14fcf0
movl 0xc(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x14fd00
movzbl %al, %eax
orl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x14fcb3
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_pixel_overflow(unsigned int, unsigned int, LodePNGColorMode const*, LodePNGColorMode const*)
static int lodepng_pixel_overflow(unsigned w, unsigned h,
                                  const LodePNGColorMode* pngcolor, const LodePNGColorMode* rawcolor) {
  size_t bpp = LODEPNG_MAX(lodepng_get_bpp(pngcolor), lodepng_get_bpp(rawcolor));
  size_t numpixels, total;
  size_t line; /* bytes per line in worst case */

  if(lodepng_mulofl((size_t)w, (size_t)h, &numpixels)) return 1;
  if(lodepng_mulofl(numpixels, 8, &total)) return 1; /* bit pointer with 8-bit color, or 8 bytes per channel color */

  /* Bytes per scanline with the expression "(w / 8u) * bpp) + ((w & 7u) * bpp + 7u) / 8u" */
  if(lodepng_mulofl((size_t)(w / 8u), bpp, &line)) return 1;
  if(lodepng_addofl(line, ((w & 7u) * bpp + 7u) / 8u, &line)) return 1;

  if(lodepng_addofl(line, 5, &line)) return 1; /* 5 bytes overhead per line: 1 filterbyte, 4 for Adam7 worst case */
  if(lodepng_mulofl(line, h, &total)) return 1; /* Total bytes in worst case */

  return 0; /* no overflow */
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x13fb50
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
callq 0x13fb50
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jbe 0x14ffa7
movq 0x30(%rsp), %rdi
callq 0x13fb50
movl %eax, (%rsp)
jmp 0x14ffb4
movq 0x28(%rsp), %rdi
callq 0x13fb50
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, %eax
movq %rax, 0x20(%rsp)
movl 0x40(%rsp), %eax
movl %eax, %edi
movl 0x3c(%rsp), %eax
movl %eax, %esi
leaq 0x18(%rsp), %rdx
callq 0x14b760
cmpl $0x0, %eax
je 0x14ffe6
movl $0x1, 0x44(%rsp)
jmp 0x1500be
movq 0x18(%rsp), %rdi
movl $0x8, %esi
leaq 0x10(%rsp), %rdx
callq 0x14b760
cmpl $0x0, %eax
je 0x15000c
movl $0x1, 0x44(%rsp)
jmp 0x1500be
movl 0x40(%rsp), %eax
shrl $0x3, %eax
movl %eax, %eax
movl %eax, %edi
movq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x14b760
cmpl $0x0, %eax
je 0x150038
movl $0x1, 0x44(%rsp)
jmp 0x1500be
movq 0x8(%rsp), %rdi
movl 0x40(%rsp), %eax
andl $0x7, %eax
movl %eax, %eax
movl %eax, %esi
imulq 0x20(%rsp), %rsi
addq $0x7, %rsi
shrq $0x3, %rsi
leaq 0x8(%rsp), %rdx
callq 0x13f260
cmpl $0x0, %eax
je 0x15006f
movl $0x1, 0x44(%rsp)
jmp 0x1500be
movq 0x8(%rsp), %rdi
movl $0x5, %esi
leaq 0x8(%rsp), %rdx
callq 0x13f260
cmpl $0x0, %eax
je 0x150092
movl $0x1, 0x44(%rsp)
jmp 0x1500be
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
leaq 0x10(%rsp), %rdx
callq 0x14b760
cmpl $0x0, %eax
je 0x1500b6
movl $0x1, 0x44(%rsp)
jmp 0x1500be
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: lodepng_get_raw_size_idat(unsigned int, unsigned int, LodePNGColorMode const*)
static size_t lodepng_get_raw_size_idat(unsigned w, unsigned h, const LodePNGColorMode* color) {
  size_t bpp = lodepng_get_bpp(color);
  /* + 1 for the filter byte, and possibly plus padding bits per line */
  size_t line = ((size_t)(w / 8u) * bpp) + 1u + ((w & 7u) * bpp + 7u) / 8u;
  return (size_t)h * line;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x13fb50
movl %eax, %eax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %eax
shrl $0x3, %eax
movl %eax, %eax
imulq 0x10(%rsp), %rax
addq $0x1, %rax
movl 0x24(%rsp), %ecx
andl $0x7, %ecx
movl %ecx, %ecx
imulq 0x10(%rsp), %rcx
addq $0x7, %rcx
shrq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x20(%rsp), %eax
imulq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: unfilter(unsigned char*, unsigned char const*, unsigned int, unsigned int, unsigned int)
static unsigned unfilter(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp) {
  /*
  For PNG filter method 0
  this function unfilters a single image (e.g. without interlacing this is called once, with Adam7 seven times)
  out must have enough bytes allocated already, in must have the scanlines + 1 filtertype byte per scanline
  w and h are image dimensions or dimensions of reduced image, bpp is bits per pixel
  in and out are allowed to be the same memory address (but aren't the same size since in has the extra filter bytes)
  */

  unsigned y;
  unsigned char* prevline = 0;

  /*bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise*/
  size_t bytewidth = (bpp + 7u) / 8u;
  size_t linebytes = (w * bpp + 7u) / 8u;

  for(y = 0; y < h; ++y) {
    size_t outindex = linebytes * y;
    size_t inindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/
    unsigned char filterType = in[inindex];

    CERROR_TRY_RETURN(unfilterScanline(&out[outindex], &in[inindex + 1], prevline, bytewidth, filterType, linebytes));

    prevline = &out[outindex];
  }

  return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq $0x0, 0x28(%rsp)
movl 0x34(%rsp), %eax
addl $0x7, %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, 0x20(%rsp)
movl 0x3c(%rsp), %eax
imull 0x34(%rsp), %eax
addl $0x7, %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x38(%rsp), %eax
jae 0x150572
movq 0x18(%rsp), %rax
movl 0x30(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movl 0x30(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x7(%rsp)
movq 0x48(%rsp), %rdi
addq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x8(%rsp), %rax
addq $0x1, %rax
addq %rax, %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movb 0x7(%rsp), %al
movq 0x18(%rsp), %r9
movzbl %al, %r8d
callq 0x150c70
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0x150553
movl (%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x15057a
movq 0x48(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x1504c3
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/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 ibp = 0, obp = 0; /*input and output 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq 0x38(%rsp), %rax
subq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0x150648
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x15062c
movq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x14fd00
movb %al, 0xf(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movzbl 0xf(%rsp), %edx
callq 0x151a10
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1505e9
movq 0x28(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x1505d6
addq $0x58, %rsp
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: paethPredictor(short, short, short)
static unsigned char paethPredictor(short a, short b, short c) {
  short pa = LODEPNG_ABS(b - c);
  short pb = LODEPNG_ABS(a - c);
  short pc = LODEPNG_ABS(a + b - c - c);
  /* return input value associated with smallest of pa, pb, pc (with certain priority if equal) */
  if(pb < pa) { a = b; pa = pb; }
  return (pc < pa) ? c : a;
}

// Assembly:
movw %dx, %ax
movw %si, %cx
movw %di, %dx
movw %dx, -0x2(%rsp)
movw %cx, -0x4(%rsp)
movw %ax, -0x6(%rsp)
movswl -0x4(%rsp), %eax
movswl -0x6(%rsp), %ecx
subl %ecx, %eax
cmpl $0x0, %eax
jge 0x1518ff
movswl -0x4(%rsp), %ecx
movswl -0x6(%rsp), %eax
subl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x10(%rsp)
jmp 0x15190f
movswl -0x4(%rsp), %eax
movswl -0x6(%rsp), %ecx
subl %ecx, %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
movw %ax, -0x8(%rsp)
movswl -0x2(%rsp), %eax
movswl -0x6(%rsp), %ecx
subl %ecx, %eax
cmpl $0x0, %eax
jge 0x15193f
movswl -0x2(%rsp), %ecx
movswl -0x6(%rsp), %eax
subl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x14(%rsp)
jmp 0x15194f
movswl -0x2(%rsp), %eax
movswl -0x6(%rsp), %ecx
subl %ecx, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movw %ax, -0xa(%rsp)
movswl -0x2(%rsp), %eax
movswl -0x4(%rsp), %ecx
addl %ecx, %eax
movswl -0x6(%rsp), %ecx
subl %ecx, %eax
movswl -0x6(%rsp), %ecx
subl %ecx, %eax
cmpl $0x0, %eax
jge 0x15199b
movswl -0x2(%rsp), %ecx
movswl -0x4(%rsp), %eax
addl %eax, %ecx
movswl -0x6(%rsp), %eax
subl %eax, %ecx
movswl -0x6(%rsp), %eax
subl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x18(%rsp)
jmp 0x1519b9
movswl -0x2(%rsp), %eax
movswl -0x4(%rsp), %ecx
addl %ecx, %eax
movswl -0x6(%rsp), %ecx
subl %ecx, %eax
movswl -0x6(%rsp), %ecx
subl %ecx, %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movw %ax, -0xc(%rsp)
movswl -0xa(%rsp), %eax
movswl -0x8(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1519e4
movw -0x4(%rsp), %ax
movw %ax, -0x2(%rsp)
movw -0xa(%rsp), %ax
movw %ax, -0x8(%rsp)
movswl -0xc(%rsp), %eax
movswl -0x8(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1519fe
movw -0x6(%rsp), %ax
movw %ax, -0x1a(%rsp)
jmp 0x151a08
movw -0x2(%rsp), %ax
movw %ax, -0x1a(%rsp)
movw -0x1a(%rsp), %ax
retq
nop
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: setBitOfReversedStream(unsigned long*, unsigned char*, unsigned char)
static void setBitOfReversedStream(size_t* bitpointer, unsigned char* bitstream, unsigned char bit) {
  /*the current bit in bitstream may be 0 or 1 for this to work*/
  if(bit == 0) bitstream[(*bitpointer) >> 3u] &=  (unsigned char)(~(1u << (7u - ((*bitpointer) & 7u))));
  else         bitstream[(*bitpointer) >> 3u] |=  (1u << (7u - ((*bitpointer) & 7u)));
  ++(*bitpointer);
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movzbl -0x11(%rsp), %eax
cmpl $0x0, %eax
jne 0x151a69
movq -0x8(%rsp), %rax
movq (%rax), %rcx
andq $0x7, %rcx
movl $0x7, %eax
subq %rcx, %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
xorl $-0x1, %eax
movzbl %al, %esi
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
shrq $0x3, %rcx
movzbl (%rax,%rcx), %edx
andl %esi, %edx
movb %dl, (%rax,%rcx)
jmp 0x151aa0
movq -0x8(%rsp), %rax
movq (%rax), %rcx
andq $0x7, %rcx
movl $0x7, %eax
subq %rcx, %rax
movl %eax, %ecx
movl $0x1, %esi
shll %cl, %esi
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
shrq $0x3, %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
retq
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: ilog2i(unsigned long)
static size_t ilog2i(size_t i) {
  size_t l;
  if(i == 0) return 0;
  l = ilog2(i);
  /* approximate i*log2(i): l is integer logarithm, ((i - (1u << l)) << 1u)
  linearly approximates the missing fractional part multiplied by i */
  return i * l + (unsigned long) ((i - (unsigned long) (1u << l)) << 1u);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x1531bc
movq $0x0, 0x20(%rsp)
jmp 0x153201
movq 0x18(%rsp), %rdi
callq 0x153210
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
imulq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movl $0x1, %edx
shll %cl, %edx
movq 0x8(%rsp), %rcx
movl %edx, %edx
subq %rdx, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/LodePNG.cpp
// Function: ilog2(unsigned long)
static size_t ilog2(size_t i) {
  size_t result = 0;
  while(i >= 65536) { result += 16; i >>= 16; }
  while(i >= 256) { result += 8; i >>= 8; }
  while(i >= 16) { result += 4; i >>= 4; }
  while(i >= 2) { result += 1; i >>= 1; }
  return result;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
cmpq $0x10000, -0x8(%rsp)    # imm = 0x10000
jb 0x153247
movq -0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
shrq $0x10, %rax
movq %rax, -0x8(%rsp)
jmp 0x15321e
jmp 0x153249
cmpq $0x100, -0x8(%rsp)      # imm = 0x100
jb 0x153272
movq -0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
shrq $0x8, %rax
movq %rax, -0x8(%rsp)
jmp 0x153249
jmp 0x153274
cmpq $0x10, -0x8(%rsp)
jb 0x15329a
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
shrq $0x4, %rax
movq %rax, -0x8(%rsp)
jmp 0x153274
jmp 0x15329c
cmpq $0x2, -0x8(%rsp)
jb 0x1532c1
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
shrq %rax
movq %rax, -0x8(%rsp)
jmp 0x15329c
movq -0x10(%rsp), %rax
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/Vec3.cpp
// Function: RayTracer::Vec3::operator=(RayTracer::Vec3 const&)
Vec3& Vec3::operator=(const Vec3& other) {
    this->x = other.x;
    this->y = other.y;
    this->z = other.z;
    return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
retq
nopl (%rax)
// File: Lut99[P]RayTracer/src/lib/Vec3.cpp
// Function: RayTracer::Vec3::operator+=(double)
Vec3& Vec3::operator+=(const double other) {
    this->x += other;
    this->y += other;
    this->z += other;

    return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movsd -0x10(%rsp), %xmm0
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rsp), %xmm0
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rsp), %xmm0
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/Vec3.cpp
// Function: RayTracer::Vec3::operator[](int)
double& Vec3::operator[](int index) {
    if (index == 0) {
        return this->x;
    } else if (index == 1) {
        return this->y;
    } else if (index == 2) {
        return this->z;
    }
    throw out_of_range("Index " + to_string(index) + " is out of range for Vec3");
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x84(%rsp)
jne 0x154b73
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x90(%rsp)
jmp 0x154cae
cmpl $0x1, 0x84(%rsp)
jne 0x154b93
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x90(%rsp)
jmp 0x154cae
cmpl $0x2, 0x84(%rsp)
jne 0x154bb3
movq 0x8(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x90(%rsp)
jmp 0x154cae
jmp 0x154bb5
jmp 0x154bb7
movb $0x1, 0x13(%rsp)
movl $0x10, %edi
callq 0xd02b0
movq %rax, (%rsp)
movl 0x84(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x122740
jmp 0x154bdd
leaq 0x22d6c(%rip), %rsi     # 0x177950
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x12d820
jmp 0x154bf5
leaq 0x22d5b(%rip), %rdx     # 0x177957
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xe6bb0
jmp 0x154c0d
movq (%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xd08a0
jmp 0x154c1d
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0x5737b(%rip), %rsi     # 0x1abfa8
movq 0x5735c(%rip), %rdx     # 0x1abf90
callq 0xd09b0
jmp 0x154cc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x154c9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x154c90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x154c86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd0b38
leaq 0x40(%rsp), %rdi
callq 0xd0b38
leaq 0x20(%rsp), %rdi
callq 0xd0b38
testb $0x1, 0x13(%rsp)
jne 0x154ca3
jmp 0x154cac
movq (%rsp), %rdi
callq 0xd0430
jmp 0x154cbe
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xd0a10
nopl (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/Vec3.cpp
// Function: RayTracer::Vec3::get(int) const
double Vec3::get(const int index) const {
    if (index == 0) {
        return this->x;
    } else if (index == 1) {
        return this->y;
    } else if (index == 2) {
        return this->z;
    }
    throw out_of_range("Index " + to_string(index) + " is out of range for Vec3");
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x84(%rsp)
jne 0x154d15
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x154e54
cmpl $0x1, 0x84(%rsp)
jne 0x154d37
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x154e54
cmpl $0x2, 0x84(%rsp)
jne 0x154d59
movq 0x8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x154e54
jmp 0x154d5b
jmp 0x154d5d
movb $0x1, 0x13(%rsp)
movl $0x10, %edi
callq 0xd02b0
movq %rax, (%rsp)
movl 0x84(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x122740
jmp 0x154d83
leaq 0x22bc6(%rip), %rsi     # 0x177950
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x12d820
jmp 0x154d9b
leaq 0x22bb5(%rip), %rdx     # 0x177957
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xe6bb0
jmp 0x154db3
movq (%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xd08a0
jmp 0x154dc3
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0x571d5(%rip), %rsi     # 0x1abfa8
movq 0x571b6(%rip), %rdx     # 0x1abf90
callq 0xd09b0
jmp 0x154e6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x154e40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x154e36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x154e2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd0b38
leaq 0x40(%rsp), %rdi
callq 0xd0b38
leaq 0x20(%rsp), %rdi
callq 0xd0b38
testb $0x1, 0x13(%rsp)
jne 0x154e49
jmp 0x154e52
movq (%rsp), %rdi
callq 0xd0430
jmp 0x154e65
movsd 0x90(%rsp), %xmm0
addq $0x98, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xd0a10
nop
// File: Lut99[P]RayTracer/src/lib/Vec3.cpp
// Function: RayTracer::Vec3::normalize() const
Vec3 Vec3::normalize() const {
    double l = this->length();
    return Vec3(
        this->x / l,
        this->y / l,
        this->z / l
    );
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x154e70
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rax), %xmm0
divsd 0x20(%rsp), %xmm0
movsd 0x10(%rax), %xmm1
divsd 0x20(%rsp), %xmm1
movsd 0x18(%rax), %xmm2
divsd 0x20(%rsp), %xmm2
callq 0x154750
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/Vec3.cpp
// Function: RayTracer::Vec3::to_json[abi:cxx11]() const
json Vec3::to_json() const {
    json j = json::array();
    j[0] = this->x;
    j[1] = this->y;
    j[2] = this->z;
    return j;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x28(%rsp)
movb $0x0, 0x97(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x155e60
movq 0x30(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x155e10
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
leaq 0x70(%rsp), %rdi
callq 0x155e80
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x155ed0
movq %rax, 0x38(%rsp)
jmp 0x154fd8
movq 0x38(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x128ba0
movq 0x10(%rsp), %rdi
callq 0xd9f30
movq 0x28(%rsp), %rsi
addq $0x10, %rsi
leaq 0x50(%rsp), %rdi
callq 0x155e80
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x155ed0
movq %rax, 0x18(%rsp)
jmp 0x15501f
movq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x128ba0
movq (%rsp), %rdi
callq 0xd9f30
movq 0x28(%rsp), %rsi
addq $0x18, %rsi
leaq 0x40(%rsp), %rdi
callq 0x155e80
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x155ed0
movq %rax, 0x8(%rsp)
jmp 0x155064
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x128ba0
leaq 0x40(%rsp), %rdi
callq 0xd9f30
movb $0x1, 0x97(%rsp)
testb $0x1, 0x97(%rsp)
jne 0x1550e9
jmp 0x1550df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xd9f30
jmp 0x1550f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd9f30
jmp 0x1550f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd9f30
jmp 0x1550f6
movq 0x30(%rsp), %rdi
callq 0xd9f30
movq 0x20(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xd9f30
movq 0x68(%rsp), %rdi
callq 0xd0a10
nopw (%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/Vec3.cpp
// Function: RayTracer::operator+(RayTracer::Vec3 const&, RayTracer::Vec3 const&)
Vec3 RayTracer::operator+(const Vec3& v1, const Vec3& v2) {
    return Vec3(
        v1.x + v2.x,
        v1.y + v2.y,
        v1.z + v2.z
    );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x10(%rsp), %rax
addsd 0x8(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm1
movq 0x10(%rsp), %rax
addsd 0x10(%rax), %xmm1
movq 0x18(%rsp), %rax
movsd 0x18(%rax), %xmm2
movq 0x10(%rsp), %rax
addsd 0x18(%rax), %xmm2
callq 0x154750
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Lut99[P]RayTracer/src/lib/Vec3.cpp
// Function: RayTracer::operator+(RayTracer::Vec3 const&, double)
Vec3 RayTracer::operator+(const Vec3& v1, const double n) {
    return Vec3(
        v1.x + n,
        v1.y + n,
        v1.z + n
    );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
addsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm1
addsd 0x10(%rsp), %xmm1
movq 0x18(%rsp), %rax
movsd 0x18(%rax), %xmm2
addsd 0x10(%rsp), %xmm2
callq 0x154750
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)