LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__write_run_data(stbi__write_context*, int, unsigned char)
void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
{
   unsigned char lengthbyte = STBIW_UCHAR(length+128);
   STBIW_ASSERT(length+128 <= 255);
   s->func(s->context, &lengthbyte, 1);
   s->func(s->context, &databyte, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
addl $0x80, %eax
andl $0xff, %eax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
addl $0x80, %eax
cmpl $0xff, %eax
jg 0x380e5
jmp 0x38104
leaq 0x1083b(%rip), %rdi     # 0x48927
leaq 0x10846(%rip), %rsi     # 0x48939
movl $0x1f5, %edx            # imm = 0x1F5
leaq 0x10857(%rip), %rcx     # 0x48956
callq 0x52c0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0xe(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0xd(%rbp), %rsi
movl $0x1, %edx
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__write_dump_data(stbi__write_context*, int, unsigned char*)
void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
{
   unsigned char lengthbyte = STBIW_UCHAR(length);
   STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
   s->func(s->context, &lengthbyte, 1);
   s->func(s->context, data, length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0x19(%rbp)
cmpl $0x80, -0xc(%rbp)
jg 0x38169
jmp 0x38188
leaq 0x1082c(%rip), %rdi     # 0x4899c
leaq 0x107c2(%rip), %rsi     # 0x48939
movl $0x1fd, %edx            # imm = 0x1FD
leaq 0x10827(%rip), %rcx     # 0x489aa
callq 0x52c0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbi_write_hdr_core(stbi__write_context*, int, int, int, float*)
static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
{
   if (y <= 0 || x <= 0 || data == NULL)
      return 0;
   else {
      // Each component is stored separately. Allocate scratch space for full output scanline.
      unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
      int i, len;
      char buffer[128];
      char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
      s->func(s->context, header, sizeof(header)-1);

      len = sprintf(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
      s->func(s->context, buffer, len);

      for(i=0; i < y; i++)
         stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*i*x);
      STBIW_FREE(scratch);
      return 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x3862f
cmpl $0x0, -0x14(%rbp)
jle 0x3862f
cmpq $0x0, -0x28(%rbp)
jne 0x3863b
movl $0x0, -0x4(%rbp)
jmp 0x38710
movl -0x14(%rbp), %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x5550
movq %rax, -0x30(%rbp)
leaq -0x110(%rbp), %rdi
leaq 0x10545(%rip), %rsi     # 0x48ba0
movl $0x42, %edx
callq 0x5370
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x110(%rbp), %rsi
movl $0x41, %edx
callq *%rax
leaq -0xc0(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x1049a(%rip), %rsi     # 0x48b30
movb $0x0, %al
callq 0x50d0
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0xc0(%rbp), %rsi
movl -0x38(%rbp), %edx
callq *%rax
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x38700
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x1c(%rbp), %eax
imull -0x34(%rbp), %eax
imull -0x14(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %r8
callq 0x381c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x386c2
movq -0x30(%rbp), %rdi
callq 0x54c0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbi_write_hdr
int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data);
      stbi__end_write_file(&s);
      return r;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x37950
cmpl $0x0, %eax
je 0x38775
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdi
callq 0x38600
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x379a0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3877c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__sbgrowf(void**, int, int)
static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
{
   int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
   void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
   STBIW_ASSERT(p);
   if (p) {
      if (!*arr) ((int *) p)[1] = 0;
      *arr = (void *) ((int *) p + 2);
      stbiw__sbm(*arr) = m;
   }
   return *arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x39450
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x8(%rax), %eax
shll %eax
addl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x39459
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3947a
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x39482
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x39482
movq -0x30(%rbp), %rdi
movl -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movslq %eax, %rsi
addq $0x8, %rsi
callq 0x5670
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x394a6
jmp 0x394c5
leaq 0xdb7a(%rip), %rdi      # 0x47027
leaq 0xf485(%rip), %rsi      # 0x48939
movl $0x29b, %edx            # imm = 0x29B
leaq 0xf6a1(%rip), %rcx      # 0x48b61
callq 0x52c0
cmpq $0x0, -0x20(%rbp)
je 0x394fd
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x394e1
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, -0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__zlib_flushf(unsigned char*, unsigned int*, int*)
static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
{
   while (*bitcount >= 8) {
      stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));
      *bitbuffer >>= 8;
      *bitcount -= 8;
   }
   return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jl 0x39599
cmpq $0x0, -0x8(%rbp)
je 0x39547
movq -0x8(%rbp), %rax
movl -0x4(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl -0x8(%rcx), %eax
jl 0x39559
leaq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x39420
jmp 0x3955b
jmp 0x3955b
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movl -0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, -0x4(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shrl $0x8, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl $0x8, %ecx
movl %ecx, (%rax)
jmp 0x39524
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__zhash(unsigned char*)
static unsigned int stbiw__zhash(unsigned char *data)
{
   stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
   hash ^= hash << 3;
   hash += hash >> 5;
   hash ^= hash << 4;
   hash += hash >> 17;
   hash ^= hash << 25;
   hash += hash >> 6;
   return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x3, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x5, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x4, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x11, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x19, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x6, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__zlib_countm(unsigned char*, unsigned char*, int)
static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)
{
   int i;
   for (i=0; i < limit && i < 258; ++i)
      if (a[i] != b[i]) break;
   return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x19(%rbp)
jge 0x39660
cmpl $0x102, -0x18(%rbp)     # imm = 0x102
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x39669
jmp 0x39694
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x39687
jmp 0x39694
jmp 0x39689
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x39646
movl -0x18(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__zlib_bitrev(int, int)
static int stbiw__zlib_bitrev(int code, int codebits)
{
   int res=0;
   while (codebits--) {
      res = (res << 1) | (code & 1);
      code >>= 1;
   }
   return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
je 0x396db
movl -0xc(%rbp), %eax
shll %eax
movl -0x4(%rbp), %ecx
andl $0x1, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
sarl %eax
movl %eax, -0x4(%rbp)
jmp 0x396b1
movl -0xc(%rbp), %eax
popq %rbp
retq
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__paeth(int, int, int)
static unsigned char stbiw__paeth(int a, int b, int c)
{
   int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c);
   if (pa <= pb && pa <= pc) return STBIW_UCHAR(a);
   if (pb <= pc) return STBIW_UCHAR(b);
   return STBIW_UCHAR(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x3a1b6
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x3a1b6
movl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, -0x1(%rbp)
jmp 0x3a1d6
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x3a1cb
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0x1(%rbp)
jmp 0x3a1d6
movl -0x10(%rbp), %eax
andl $0xff, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbi_write_png
STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
   FILE *f;
   int len;
   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (png == NULL) return 0;
   f = fopen(filename, "wb");
   if (!f) { STBIW_FREE(png); return 0; }
   fwrite(png, 1, len, f);
   fclose(f);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
leaq -0x3c(%rbp), %r9
callq 0x396e0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x3a2cb
movl $0x0, -0x4(%rbp)
jmp 0x3a327
movq -0x10(%rbp), %rdi
leaq 0xe7e5(%rip), %rsi      # 0x48abb
callq 0x54b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3a2f8
movq -0x48(%rbp), %rdi
callq 0x54c0
movl $0x0, -0x4(%rbp)
jmp 0x3a327
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
callq 0x57a0
movq -0x38(%rbp), %rdi
callq 0x53f0
movq -0x48(%rbp), %rdi
callq 0x54c0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbi_write_png_to_func
STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
{
   int len;
   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (png == NULL) return 0;
   func(context, png, len);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl 0x10(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
leaq -0x34(%rbp), %r9
callq 0x396e0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3a37f
movl $0x0, -0x4(%rbp)
jmp 0x3a3a0
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %edx
callq *%rax
movq -0x40(%rbp), %rdi
callq 0x54c0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__outfile(stbi__write_context*, int, int, int, int, int, int, void*, int, int, char const*, ...)
static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)
{
   if (y < 0 || x < 0) {
      return 0;
   } else {
      va_list v;
      va_start(v, fmt);
      stbiw__writefv(s, fmt, v);
      va_end(v);
      stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono);
      return 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
testb %al, %al
je 0x3a3ef
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq 0x30(%rbp), %rax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x3a421
cmpl $0x0, -0x24(%rbp)
jge 0x3a42a
movl $0x0, -0xc(%rbp)
jmp 0x3a4a5
leaq -0x50(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x30, (%rax)
movq -0x18(%rbp), %rdi
movq 0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x3a4c0
leaq -0x50(%rbp), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
movq 0x18(%rbp), %rbx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x10(%rbp), %eax
movq %rbx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x3a6e0
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbiw__write_pixels(stbi__write_context*, int, int, int, int, int, void*, int, int, int)
static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)
{
   stbiw_uint32 zero = 0;
   int i,j, j_end;

   if (y <= 0)
      return;

   if (vdir < 0)
      j_end = -1, j = y-1;
   else
      j_end =  y, j = 0;

   for (; j != j_end; j += vdir) {
      for (i=0; i < x; ++i) {
         unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
         stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d);
      }
      s->func(s->context, &zero, scanline_pad);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jg 0x3a71c
jmp 0x3a7be
cmpl $0x0, -0x10(%rbp)
jge 0x3a734
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3a741
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
jmp 0x3a743
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x3a7be
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3a79b
movq 0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x24(%rbp), %ecx
imull -0x1c(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
movl 0x18(%rbp), %ecx
movl 0x28(%rbp), %r8d
movq -0x38(%rbp), %r9
callq 0x3a7d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3a752
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl 0x20(%rbp), %edx
leaq -0x20(%rbp), %rsi
callq *%rax
movl -0x10(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x3a743
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/Frame.cpp
// Function: Frame::setColor(Sample const&, RGB)
void
Frame::setColor(Sample const & s, RGB c)
{
  c.clip(0, 1);

  int xi = (int)std::floor(s.x() * image.width());
  int yi = (int)std::floor((1 - s.y()) * image.height());

  unsigned char * pixel = image.pixel(yi, xi);
  pixel[0] = c.getBMPR(0, 1);
  pixel[1] = c.getBMPG(0, 1);
  pixel[2] = c.getBMPB(0, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, %rax
movq -0x50(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd 0xc4c2(%rip), %xmm1     # 0x47138
callq 0x3add0
movq -0x10(%rbp), %rdi
callq 0x3ae70
movq -0x38(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
addq $0x8, %rdi
callq 0x3ae90
movsd -0x48(%rbp), %xmm0
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
callq 0x56b0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3aea0
movq -0x38(%rbp), %rdi
movaps %xmm0, %xmm1
movsd 0xc471(%rip), %xmm0     # 0x47138
subsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x8, %rdi
callq 0x3aec0
movsd -0x40(%rbp), %xmm0
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
callq 0x56b0
movq -0x38(%rbp), %rdi
cvttsd2si %xmm0, %eax
movl %eax, -0x20(%rbp)
addq $0x8, %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x3aee0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd 0xc420(%rip), %xmm1     # 0x47138
callq 0x3af10
movq -0x30(%rbp), %rdi
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
xorps %xmm0, %xmm0
movsd 0xc404(%rip), %xmm1     # 0x47138
callq 0x3af60
movq -0x30(%rbp), %rdi
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x1(%rax)
xorps %xmm0, %xmm0
movsd 0xc3e7(%rip), %xmm1     # 0x47138
callq 0x3afb0
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x2(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/Lights.cpp
// Function: Light::Light()
Light::Light()
{
  RGB black(0, 0, 0);
  illumination_ = black;
  falloff_ = 0;
  angular_falloff_ = 0;
  dead_distance_ = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x209cd(%rip), %rax     # 0x5bab8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x3bce0
leaq -0x20(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x9640
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0x20(%rbp), %rsi
callq 0x96c0
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0xbffe(%rip), %xmm0     # 0x47138
movsd %xmm0, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/Lights.cpp
// Function: AreaLight::getShadowRays(Vec3 const&, bool&) const
vector<Ray>
AreaLight::getShadowRays(Vec3 const & position, bool & use_dist) const
{
  use_dist = true;
  vector<Ray> v;

  // generated rays from position to all the offset point lights
  for (double i = -1; i < 2; i++)
    for (double j = -1; j < 2; j++)
        for (double k = -1; k < 2; k++)
          v.push_back(Ray::fromOriginAndEnd(position, pos_ 
                                          + Vec3(i*offset_, j*offset_, k*offset_)));
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movb $0x0, -0x21(%rbp)
callq 0x3bf80
movsd 0xb881(%rip), %xmm0     # 0x471b0
movsd %xmm0, -0x30(%rbp)
movsd 0xc024(%rip), %xmm0     # 0x47960
ucomisd -0x30(%rbp), %xmm0
jbe 0x3ba94
movsd 0xb861(%rip), %xmm0     # 0x471b0
movsd %xmm0, -0x38(%rbp)
movsd 0xc004(%rip), %xmm0     # 0x47960
ucomisd -0x38(%rbp), %xmm0
jbe 0x3ba7b
movsd 0xb841(%rip), %xmm0     # 0x471b0
movsd %xmm0, -0x40(%rbp)
movsd 0xbfe4(%rip), %xmm0     # 0x47960
ucomisd -0x40(%rbp), %xmm0
jbe 0x3ba62
movq -0xc8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0xe8(%rbp)
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0xe0(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x38(%rax), %xmm3
mulsd %xmm3, %xmm0
movsd -0x38(%rbp), %xmm1
mulsd %xmm3, %xmm1
movsd -0x40(%rbp), %xmm2
mulsd %xmm3, %xmm2
leaq -0xb0(%rbp), %rdi
callq 0x147b0
jmp 0x3b9d5
movq -0xe0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0x3bfd0
jmp 0x3b9f1
callq 0x3be50
movq -0xe8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x98(%rbp), %rdx
movsd 0xb728(%rip), %xmm1     # 0x47138
callq 0x3bde0
jmp 0x3ba17
movq -0xd8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3bfa0
jmp 0x3ba29
jmp 0x3ba2b
movsd 0xb705(%rip), %xmm0     # 0x47138
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x3b974
movq -0xd8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x3bf20
jmp 0x3baba
jmp 0x3ba64
movsd 0xb6cc(%rip), %xmm0     # 0x47138
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x3b954
jmp 0x3ba7d
movsd 0xb6b3(%rip), %xmm0     # 0x47138
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x3b934
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x3baaa
movq -0xd8(%rbp), %rdi
callq 0x3bf20
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x5720
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/Types.hpp
// Function: Ray::Ray(Vec3 const&, Vec3 const&, double, double)
inline Ray::Ray(Vec3 const & start, Vec3 const & dir, double min_t, double mu)
{
  e_ = start;
  d_ = dir;
  min_t_ = min_t;
  mu_ = mu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6fc0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x6fc0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x72d0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rdi
callq 0x72d0
movq -0x30(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x38(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: srajangarg[P]raytracer/src/core/Types.hpp
// Function: Ray::Ray(Ray const&)
inline Ray::Ray(Ray const & r)
{
  e_ = r.e_;
  d_ = r.d_;
  min_t_ = r.min_t_;
  mu_ = r.mu_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x6fc0
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x6fc0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x72d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x72d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x30(%rcx), %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x10(%rbp), %rcx
movsd 0x38(%rcx), %xmm0
movsd %xmm0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: srajangarg[P]raytracer/src/Primitives.cpp
// Function: Primitive::Primitive(RGB const&, Material const&, Mat4 const&)
Primitive::Primitive(RGB const & c, Material const & m, Mat4 const & modelToWorld)
{
  c_ = c;
  m_ = m;
  modelToWorld_ = modelToWorld;
  worldToModel_ = modelToWorld.inverse();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq 0x1ea8b(%rip), %rax     # 0x5bc68
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x3ddf0
movq -0xa8(%rbp), %rdi
addq $0x88, %rdi
callq 0x3ddf0
movq -0xa8(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x3bce0
movq -0xa8(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x3de40
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x108, %rdi            # imm = 0x108
callq 0x96c0
movq -0xa8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x120(%rdi)
movq 0x8(%rax), %rcx
movq %rcx, 0x128(%rdi)
movq 0x10(%rax), %rcx
movq %rcx, 0x130(%rdi)
movq 0x18(%rax), %rax
movq %rax, 0x138(%rdi)
movq -0x20(%rbp), %rsi
addq $0x8, %rdi
callq 0xa020
movq -0x20(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x3de50
movq -0xa8(%rbp), %rdi
addq $0x88, %rdi
leaq -0xa0(%rbp), %rsi
callq 0xa020
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/Primitives.cpp
// Function: Sphere::intersect(Ray&) const
bool
Sphere::intersect(Ray & ray) const
{
  Vec3 s, d;
  double dis, t;

  Ray new_ray = ray;
  new_ray.transform(worldToModel_);
  s = new_ray.start();
  d = new_ray.direction();

  dis = ((d*s)*(d*s)) - (d.length2() * (s.length2() - r_*r_));

  if (dis < 0)
    return false;

  dis = std::sqrt(dis);
  t = ((-d*s) - dis)/d.length2();

  if (t < -EPS)
    t = ((-d*s) + dis)/d.length2();

  if (t > EPS and ray.minT() > t)
  {
    ray.setMinT(t);
    return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6fc0
leaq -0x48(%rbp), %rdi
callq 0x6fc0
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x3c940
movq -0xe8(%rbp), %rsi
addq $0x88, %rsi
leaq -0x98(%rbp), %rdi
callq 0x3e1a0
leaq -0x98(%rbp), %rdi
callq 0x3e280
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x72d0
leaq -0x98(%rbp), %rdi
callq 0x3e290
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x72d0
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3e2b0
movsd %xmm0, -0xd0(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3e2b0
movsd %xmm0, -0xd8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x14ea0
movsd %xmm0, -0xe0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x14ea0
movq -0xe8(%rbp), %rax
movsd -0xe0(%rbp), %xmm1
movsd -0xd8(%rbp), %xmm2
movaps %xmm0, %xmm4
movsd -0xd0(%rbp), %xmm0
movsd 0x140(%rax), %xmm3
movsd 0x140(%rax), %xmm5
movq %xmm3, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm3
mulsd %xmm5, %xmm3
addsd %xmm4, %xmm3
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x50(%rbp), %xmm0
jbe 0x3d49a
movb $0x0, -0x1(%rbp)
jmp 0x3d587
movsd -0x50(%rbp), %xmm0
callq 0x5330
movsd %xmm0, -0x50(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3c030
leaq -0xb0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3e2b0
subsd -0x50(%rbp), %xmm0
movsd %xmm0, -0xf0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x14ea0
movaps %xmm0, %xmm1
movsd -0xf0(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0xb80d(%rip), %xmm0     # 0x48d08
ucomisd -0x58(%rbp), %xmm0
jbe 0x3d54c
leaq -0xc8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3c030
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3e2b0
addsd -0x50(%rbp), %xmm0
movsd %xmm0, -0xf8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x14ea0
movaps %xmm0, %xmm1
movsd -0xf8(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movsd 0xb7b7(%rip), %xmm1     # 0x48d10
ucomisd %xmm1, %xmm0
jbe 0x3d583
movq -0x18(%rbp), %rdi
callq 0x3e310
ucomisd -0x58(%rbp), %xmm0
jbe 0x3d583
movq -0x18(%rbp), %rdi
movsd -0x58(%rbp), %xmm0
callq 0x3e330
movb $0x1, -0x1(%rbp)
jmp 0x3d587
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/Primitives.cpp
// Function: Triangle::Triangle(Vec3 const&, Vec3 const&, Vec3 const&, RGB const&, Material const&, Mat4 const&, bool)
Triangle::Triangle(Vec3 const & v0, Vec3 const & v1, Vec3 const & v2, RGB const & c, Material const & m,
                   Mat4 const & modelToWorld, bool smooth)
: Primitive(c, m, modelToWorld)
{
  verts[0] = v0;
  verts[1] = v1;
  verts[2] = v2;
  smooth_normals = smooth;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb 0x18(%rbp), %al
movq 0x10(%rbp), %r10
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0x3d1b0
movq -0x60(%rbp), %rax
leaq 0x1e605(%rip), %rcx     # 0x5bcc8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x140, %rax            # imm = 0x140
movq %rax, %rcx
addq $0x48, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6fc0
jmp 0x3d6ee
movq -0x58(%rbp), %rcx
movq -0x68(%rbp), %rax
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x3d6df
movq -0x60(%rbp), %rax
addq $0x190, %rax            # imm = 0x190
movq %rax, %rcx
addq $0x48, %rcx
movq %rcx, -0x78(%rbp)
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6fc0
jmp 0x3d72b
movq -0x78(%rbp), %rcx
movq -0x80(%rbp), %rax
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, -0x70(%rbp)
jne 0x3d71c
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x190, %rdi            # imm = 0x190
callq 0x72d0
jmp 0x3d756
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x72d0
jmp 0x3d76c
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x72d0
jmp 0x3d782
movq -0x60(%rbp), %rax
movb -0x31(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x188(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3d2c0
movq -0x40(%rbp), %rdi
callq 0x5720
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/Algebra3.hpp
// Function: Mat4::transpose() const
inline Mat4 Mat4::transpose() const
{
  return Mat4(Vec4(v[0][0], v[1][0], v[2][0], v[3][0]),
              Vec4(v[0][1], v[1][1], v[2][1], v[3][1]),
              Vec4(v[0][2], v[1][2], v[2][2], v[3][2]),
              Vec4(v[0][3], v[1][3], v[2][3], v[3][3]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
xorl %esi, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xf8(%rbp)
addq $0x20, %rdi
xorl %esi, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0x108(%rbp)
addq $0x40, %rdi
xorl %esi, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0x100(%rbp)
addq $0x60, %rdi
xorl %esi, %esi
callq 0xb590
movsd -0x108(%rbp), %xmm1
movsd -0x100(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xf8(%rbp), %xmm0
leaq -0x30(%rbp), %rdi
callq 0xb390
movq -0xc0(%rbp), %rdi
movl $0x1, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xe0(%rbp)
addq $0x20, %rdi
movl $0x1, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xf0(%rbp)
addq $0x40, %rdi
movl $0x1, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xe8(%rbp)
addq $0x60, %rdi
movl $0x1, %esi
callq 0xb590
movsd -0xf0(%rbp), %xmm1
movsd -0xe8(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xe0(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0xb390
movq -0xc0(%rbp), %rdi
movl $0x2, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xc8(%rbp)
addq $0x20, %rdi
movl $0x2, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xd8(%rbp)
addq $0x40, %rdi
movl $0x2, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xd0(%rbp)
addq $0x60, %rdi
movl $0x2, %esi
callq 0xb590
movsd -0xd8(%rbp), %xmm1
movsd -0xd0(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xc8(%rbp), %xmm0
leaq -0x70(%rbp), %rdi
callq 0xb390
movq -0xc0(%rbp), %rdi
movl $0x3, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xa8(%rbp)
addq $0x20, %rdi
movl $0x3, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xb8(%rbp)
addq $0x40, %rdi
movl $0x3, %esi
callq 0xb590
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xb0(%rbp)
addq $0x60, %rdi
movl $0x3, %esi
callq 0xb590
movsd -0xb8(%rbp), %xmm1
movsd -0xb0(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xa8(%rbp), %xmm0
leaq -0x90(%rbp), %rdi
callq 0xb390
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq -0x90(%rbp), %r8
callq 0xb3e0
movq -0x98(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/Algebra3.hpp
// Function: Vec3::Vec3(Vec4 const&, int)
inline Vec3::Vec3(Vec4 const & v, int dropAxis)
{
  switch (dropAxis)
  {
    case 0: n[0] = v.n[1]; n[1] = v.n[2]; n[2] = v.n[3]; break;
    case 1: n[0] = v.n[0]; n[1] = v.n[2]; n[2] = v.n[3]; break;
    case 2: n[0] = v.n[0]; n[1] = v.n[1]; n[2] = v.n[3]; break;
    default: n[0] = v.n[0]; n[1] = v.n[1]; n[2] = v.n[2]; break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x3e86a
jmp 0x3e853
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x3e89c
jmp 0x3e85d
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x3e8ca
jmp 0x3e8f8
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0x3e924
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0x3e924
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0x3e924
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/Algebra3.hpp
// Function: Vec3::Vec3(Vec4 const&)
inline Vec3::Vec3(Vec4 const & v)  // caller should avoid divide-by-zero, the test here is not foolproof
{
  n[0] = v.n[0];
  n[1] = v.n[1];
  n[2] = v.n[2];

  if (v.n[3] != 0)  // dangerous test!
  {
    n[0] /= v.n[3];
    n[1] /= v.n[3];
    n[2] /= v.n[3];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3ee52
jp 0x3ee52
jmp 0x3ee99
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm1
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm1
movsd 0x10(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/View.cpp
// Function: View::View(Vec3 const&, Vec3 const&, Vec3 const&, Vec3 const&, Vec3 const&, int, int, int)
View::View(Vec3 const & eye, Vec3 const & ll, Vec3 const & ul, Vec3 const & lr, Vec3 const & ur,
           int pixels_wide, int pixels_high, int rays_per_pixel_edge)
{
  eye_ = eye;	 // you should use this for the viewing ray
  LL_ = ll;
  UL_ = ul;
  LR_ = lr;
  UR_ = ur;
  pixels_wide_ = pixels_wide;
  pixels_high_ = pixels_high;
  rays_per_pixel_edge_ = rays_per_pixel_edge;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq 0x1cdb0(%rip), %rax     # 0x5bd38
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x6fc0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x6fc0
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x6fc0
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
callq 0x6fc0
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
callq 0x6fc0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
callq 0x72d0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rdi
callq 0x72d0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x38, %rdi
callq 0x72d0
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x50, %rdi
callq 0x72d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x68, %rdi
callq 0x72d0
movq -0x38(%rbp), %rax
movl 0x10(%rbp), %ecx
movl %ecx, 0x80(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x84(%rax)
movl 0x20(%rbp), %ecx
movl %ecx, 0x88(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/View.cpp
// Function: View::getSample(int, int, int, Sample&) const
void
View::getSample(int pixel_x, int pixel_y, int ray_index, Sample & s) const
{
  // Some random jitter to break up patterns
  double jitter_x = 0.25 * (std::rand() / (double)RAND_MAX);
  double jitter_y = 0.25 * (std::rand() / (double)RAND_MAX);

  double pixel_sub_x = (ray_index % rays_per_pixel_edge_ + 0.5 + jitter_x) / (double)rays_per_pixel_edge_;
  double pixel_sub_y = (ray_index / rays_per_pixel_edge_ + 0.5 + jitter_y) / (double)rays_per_pixel_edge_;

  s.setX((pixel_x + pixel_sub_x) / (double)pixels_wide_);
  s.setY((pixel_y + pixel_sub_y) / (double)pixels_high_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x5130
cvtsi2sd %eax, %xmm1
movsd 0x9ca6(%rip), %xmm0     # 0x48d68
divsd %xmm0, %xmm1
movsd 0x9c92(%rip), %xmm0     # 0x48d60
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
callq 0x5130
movq -0x48(%rbp), %rcx
cvtsi2sd %eax, %xmm1
movsd 0x9c7c(%rip), %xmm0     # 0x48d68
divsd %xmm0, %xmm1
movsd 0x9c68(%rip), %xmm0     # 0x48d60
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x14(%rbp), %eax
cltd
idivl 0x88(%rcx)
cvtsi2sd %edx, %xmm0
movsd 0x9c41(%rip), %xmm1     # 0x48d58
addsd %xmm1, %xmm0
addsd -0x28(%rbp), %xmm0
cvtsi2sdl 0x88(%rcx), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x14(%rbp), %eax
cltd
idivl 0x88(%rcx)
movl %eax, %ecx
movq -0x48(%rbp), %rax
cvtsi2sd %ecx, %xmm0
movsd 0x9c0b(%rip), %xmm1     # 0x48d58
addsd %xmm1, %xmm0
addsd -0x30(%rbp), %xmm0
cvtsi2sdl 0x88(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rdi
cvtsi2sdl -0xc(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
cvtsi2sdl 0x80(%rax), %xmm1
divsd %xmm1, %xmm0
callq 0x3f460
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rdi
cvtsi2sdl -0x10(%rbp), %xmm0
addsd -0x40(%rbp), %xmm0
cvtsi2sdl 0x84(%rax), %xmm1
divsd %xmm1, %xmm0
callq 0x3f480
addq $0x50, %rsp
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/World.cpp
// Function: World::intersect(Ray&) const
Primitive *
World::intersect(Ray & r) const
{
  Primitive * intersecting = NULL;
    
  // iterate over primitives to find a smaller intersection
  for (auto it = primitivesBegin(); it != primitivesEnd(); it++)
  	if ((*it)->intersect(r))
  		intersecting = *it;

  return intersecting;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x3f8c0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3f930
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3f8f0
testb $0x1, %al
jne 0x3f5e9
jmp 0x3f628
leaq -0x20(%rbp), %rdi
callq 0x3f960
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x3f605
jmp 0x3f615
leaq -0x20(%rbp), %rdi
callq 0x3f960
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3f617
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3f980
movq %rax, -0x30(%rbp)
jmp 0x3f5c9
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/main.cpp
// Function: traceRay(Ray&, int)
RGB
traceRay(Ray & ray, int depth)
{   
  if (depth > max_trace_depth)
    return RGB(0, 0, 0);

  auto z = world->intersect(ray);

  if (z != NULL) {

    // intersection point
    auto pos = ray.getPos(ray.minT());
    // get color at that point
    auto col = getShadedColor(*z, pos, ray);

    // reflection
    Ray refl = getReflectedRay(z, pos, ray);
    col += z->getMaterial().getMR() * z->getColor() * traceRay(refl, depth+1);

    // refraction
    if (z->getMaterial().getMT() > 0)
    {
      Ray refr = getRefractedRay(z, pos, ray);
      col += z->getMaterial().getMT() * traceRay(refr, depth+1);
    }

    return col;
  }
    
  return RGB(0, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x140(%rbp)
movq %rdi, %rax
movq %rax, -0x138(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x1b5d0(%rip), %eax     # 0x5cc50
jle 0x4169c
movq -0x140(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x9640
jmp 0x41831
movq 0x1b755(%rip), %rdi     # 0x5cdf8
movq -0x10(%rbp), %rsi
callq 0x3f5a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4181c
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e310
movq -0x150(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x430b0
movq -0x140(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq -0x38(%rbp), %rdx
callq 0x40d60
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x43110
movq -0x20(%rbp), %rdi
callq 0x42cc0
movq %rax, %rdi
callq 0x43260
movsd %xmm0, -0x148(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42ca0
movsd -0x148(%rbp), %xmm0
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x42de0
movl -0x14(%rbp), %edx
addl $0x1, %edx
leaq -0xc0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x41650
leaq -0x90(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x42d80
movq -0x140(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x42fc0
movq -0x20(%rbp), %rdi
callq 0x42cc0
movq %rax, %rdi
callq 0x42f20
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4181a
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq -0x100(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x43280
movq -0x20(%rbp), %rdi
callq 0x42cc0
movq %rax, %rdi
callq 0x42f20
movsd %xmm0, -0x158(%rbp)
movl -0x14(%rbp), %edx
addl $0x1, %edx
leaq -0x130(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x41650
movsd -0x158(%rbp), %xmm0
leaq -0x118(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x42de0
movq -0x140(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x42fc0
jmp 0x41831
movq -0x140(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x9640
movq -0x138(%rbp), %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)