LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__pnm_info(stbi__context*, int*, int*, int*)
static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
{
   int maxv;
   char c, p, t;

   stbi__rewind( s );

   // Get identifier
   p = (char) stbi__get8(s);
   t = (char) stbi__get8(s);
   if (p != 'P' || (t != '5' && t != '6')) {
       stbi__rewind( s );
       return 0;
   }

   *comp = (t == '6') ? 3 : 1;  // '5' is 1-component .pgm; '6' is 3-component .ppm

   c = (char) stbi__get8(s);
   stbi__pnm_skip_whitespace(s, &c);

   *x = stbi__pnm_getinteger(s, &c); // read width
   stbi__pnm_skip_whitespace(s, &c);

   *y = stbi__pnm_getinteger(s, &c); // read height
   stbi__pnm_skip_whitespace(s, &c);

   maxv = stbi__pnm_getinteger(s, &c);  // read max value

   if (maxv > 255)
      return stbi__err("max value > 255", "PPM image not 8-bit");
   else
      return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b420
movq -0x10(%rbp), %rdi
callq 0x2ce50
movb %al, -0x2e(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ce50
movb %al, -0x2f(%rbp)
movsbl -0x2e(%rbp), %eax
cmpl $0x50, %eax
jne 0x35114
movsbl -0x2f(%rbp), %eax
cmpl $0x35, %eax
je 0x35129
movsbl -0x2f(%rbp), %eax
cmpl $0x36, %eax
je 0x35129
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x351d1
movsbl -0x2f(%rbp), %edx
movl $0x1, %ecx
movl $0x3, %eax
cmpl $0x36, %edx
cmovel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2ce50
movb %al, -0x2d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2d(%rbp), %rsi
callq 0x351e0
movq -0x10(%rbp), %rdi
leaq -0x2d(%rbp), %rsi
callq 0x352c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x2d(%rbp), %rsi
callq 0x351e0
movq -0x10(%rbp), %rdi
leaq -0x2d(%rbp), %rsi
callq 0x352c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x2d(%rbp), %rsi
callq 0x351e0
movq -0x10(%rbp), %rdi
leaq -0x2d(%rbp), %rsi
callq 0x352c0
movl %eax, -0x2c(%rbp)
cmpl $0xff, -0x2c(%rbp)
jle 0x351ca
leaq 0x133ec(%rip), %rdi     # 0x485ac
callq 0x275b0
movl %eax, -0x4(%rbp)
jmp 0x351d1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__pnm_skip_whitespace(stbi__context*, char*)
static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)
{
   for (;;) {
      while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
         *c = (char) stbi__get8(s);

      if (stbi__at_eof(s) || *c != '#')
         break;

      while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' )
         *c = (char) stbi__get8(s);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x351f2
movq -0x8(%rbp), %rdi
callq 0x2c540
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x3521c
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x35340
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x35225
jmp 0x35238
movq -0x8(%rbp), %rdi
callq 0x2ce50
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x351f2
movq -0x8(%rbp), %rdi
callq 0x2c540
cmpl $0x0, %eax
jne 0x35252
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x35254
jmp 0x352ad
jmp 0x35256
movq -0x8(%rbp), %rdi
callq 0x2c540
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
jne 0x3528c
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x12(%rbp)
je 0x3528c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x35295
jmp 0x352a8
movq -0x8(%rbp), %rdi
callq 0x2ce50
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x35256
jmp 0x351f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__pnm_getinteger(stbi__context*, char*)
static int      stbi__pnm_getinteger(stbi__context *s, char *c)
{
   int value = 0;

   while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
      value = value*10 + (*c - '0');
      *c = (char) stbi__get8(s);
   }

   return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2c540
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x35301
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x353b0
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x3530a
jmp 0x35330
imull $0xa, -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ce50
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x352d7
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__hdr_gettoken(stbi__context*, char*)
static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
{
   int len=0;
   char c = '\0';

   c = (char) stbi__get8(z);

   while (!stbi__at_eof(z) && c != '\n') {
      buffer[len++] = c;
      if (len == STBI__HDR_BUFLEN-1) {
         // flush to end of line
         while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
            ;
         break;
      }
      c = (char) stbi__get8(z);
   }

   buffer[len] = 0;
   return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ce50
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2c540
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x16(%rbp)
jne 0x35429
movsbl -0x15(%rbp), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x35432
jmp 0x3549d
movb -0x15(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
cmpl $0x3ff, -0x14(%rbp)     # imm = 0x3FF
jne 0x3548c
jmp 0x35455
movq -0x8(%rbp), %rdi
callq 0x2c540
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x17(%rbp)
jne 0x3547f
movq -0x8(%rbp), %rdi
callq 0x2ce50
movzbl %al, %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
testb $0x1, %al
jne 0x35488
jmp 0x3548a
jmp 0x35455
jmp 0x3549d
movq -0x8(%rbp), %rdi
callq 0x2ce50
movb %al, -0x15(%rbp)
jmp 0x35407
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__hdr_convert(float*, unsigned char*, int)
static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
{
   if ( input[3] != 0 ) {
      float f1;
      // Exponent
      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
      if (req_comp <= 2)
         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
      else {
         output[0] = input[0] * f1;
         output[1] = input[1] * f1;
         output[2] = input[2] * f1;
      }
      if (req_comp == 2) output[1] = 1;
      if (req_comp == 4) output[3] = 1;
   } else {
      switch (req_comp) {
         case 4: output[3] = 1; /* fallthrough */
         case 3: output[0] = output[1] = output[2] = 0;
                 break;
         case 2: output[1] = 1; /* fallthrough */
         case 1: output[0] = 0;
                 break;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
je 0x355c0
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %edi
subl $0x88, %edi
movss 0x127e6(%rip), %xmm0    # 0x47ce0
callq 0x376c0
movss %xmm0, -0x18(%rbp)
cmpl $0x2, -0x14(%rbp)
jg 0x35544
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
cvtsi2ss %eax, %xmm0
mulss -0x18(%rbp), %xmm0
movss 0x127b6(%rip), %xmm1    # 0x47cec
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x35590
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cvtsi2ss %eax, %xmm0
mulss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cvtsi2ss %eax, %xmm0
mulss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cvtsi2ss %eax, %xmm0
mulss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
cmpl $0x2, -0x14(%rbp)
jne 0x355a7
movq -0x8(%rbp), %rax
movss 0x1273e(%rip), %xmm0    # 0x47ce0
movss %xmm0, 0x4(%rax)
cmpl $0x4, -0x14(%rbp)
jne 0x355be
movq -0x8(%rbp), %rax
movss 0x12727(%rip), %xmm0    # 0x47ce0
movss %xmm0, 0xc(%rax)
jmp 0x35638
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x35636
movq -0x20(%rbp), %rax
leaq 0x127e1(%rip), %rcx     # 0x47dbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movss 0x126f0(%rip), %xmm0    # 0x47ce0
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
jmp 0x35636
movq -0x8(%rbp), %rax
movss 0x126ba(%rip), %xmm0    # 0x47ce0
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
jmp 0x35638
addq $0x20, %rsp
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__tga_get_comp(int, int, int*)
static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
{
   // only RGB or RGBA (incl. 16bit) or grey allowed
   if(is_rgb16) *is_rgb16 = 0;
   switch(bits_per_pixel) {
      case 8:  return STBI_grey;
      case 16: if(is_grey) return STBI_grey_alpha;
            // else: fall-through
      case 15: if(is_rgb16) *is_rgb16 = 1;
            return STBI_rgb;
      case 24: // fall-through
      case 32: return bits_per_pixel/8;
      default: return 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3565f
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl -0x8(%rbp), %eax
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x18, %eax
ja 0x356c8
movq -0x20(%rbp), %rax
leaq 0x12751(%rip), %rcx     # 0x47dcc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x356cf
cmpl $0x0, -0xc(%rbp)
je 0x3569c
movl $0x2, -0x4(%rbp)
jmp 0x356cf
jmp 0x3569e
cmpq $0x0, -0x18(%rbp)
je 0x356af
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x356cf
movl -0x8(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
jmp 0x356cf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__float_postprocess(float*, int*, int*, int*, int)
static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)
{
   if (stbi__vertically_flip_on_load && result != NULL) {
      int w = *x, h = *y;
      int depth = req_comp ? req_comp : *comp;
      int row,col,z;
      float temp;

      // @OPTIMIZE: use a bigger temp buffer and memcpy multiple pixels at once
      for (row = 0; row < (h>>1); row++) {
         for (col = 0; col < w; col++) {
            for (z = 0; z < depth; z++) {
               temp = result[(row * w + col) * depth + z];
               result[(row * w + col) * depth + z] = result[((h - row - 1) * w + col) * depth + z];
               result[((h - row - 1) * w + col) * depth + z] = temp;
            }
         }
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, 0x27589(%rip)     # 0x5cc88
je 0x35836
cmpq $0x0, -0x8(%rbp)
je 0x35836
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x35730
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x35739
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl -0x2c(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0x35834
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x35824
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x35814
movq -0x8(%rbp), %rax
movl -0x34(%rbp), %ecx
imull -0x28(%rbp), %ecx
addl -0x38(%rbp), %ecx
imull -0x30(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl -0x34(%rbp), %ecx
subl $0x1, %ecx
imull -0x28(%rbp), %ecx
addl -0x38(%rbp), %ecx
imull -0x30(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movl -0x34(%rbp), %ecx
imull -0x28(%rbp), %ecx
addl -0x38(%rbp), %ecx
imull -0x30(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl -0x34(%rbp), %ecx
subl $0x1, %ecx
imull -0x28(%rbp), %ecx
addl -0x38(%rbp), %ecx
imull -0x30(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x35770
jmp 0x35816
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3575d
jmp 0x35826
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x35746
jmp 0x35836
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__ldr_to_hdr(unsigned char*, int, int, int)
static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
{
   int i,k,n;
   float *output = (float *) stbi__malloc(x * y * comp * sizeof(float));
   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
   // compute number of non-alpha components
   if (comp & 1) n = comp; else n = comp-1;
   for (i=0; i < x*y; ++i) {
      for (k=0; k < n; ++k) {
         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
      }
      if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f;
   }
   STBI_FREE(data);
   return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x27f20
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x358a0
movq -0x10(%rbp), %rdi
callq 0x54c0
leaq 0x1275e(%rip), %rdi     # 0x47fe5
callq 0x275b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x359a3
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x358b3
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x358bc
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x35992
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x3593f
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x123df(%rip), %xmm1    # 0x47ce4
divss %xmm1, %xmm0
movss 0x26b0f(%rip), %xmm1    # 0x5c420
callq 0x376f0
mulss 0x26b06(%rip), %xmm0    # 0x5c424
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x358dc
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x35982
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x1237c(%rip), %xmm1    # 0x47ce4
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x35984
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x358c3
movq -0x10(%rbp), %rdi
callq 0x54c0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__parse_zlib(stbi__zbuf*, int)
static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
{
   int final, type;
   if (parse_header)
      if (!stbi__parse_zlib_header(a)) return 0;
   a->num_bits = 0;
   a->code_buffer = 0;
   do {
      final = stbi__zreceive(a,1);
      type = stbi__zreceive(a,2);
      if (type == 0) {
         if (!stbi__parse_uncomperssed_block(a)) return 0;
      } else if (type == 3) {
         return 0;
      } else {
         if (type == 1) {
            // use fixed code lengths
            if (!stbi__zdefault_distance[31]) stbi__init_zdefaults();
            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , 288)) return 0;
            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
         } else {
            if (!stbi__compute_huffman_codes(a)) return 0;
         }
         if (!stbi__parse_huffman_block(a)) return 0;
      }
   } while (!final);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x359e1
movq -0x10(%rbp), %rdi
callq 0x35b10
cmpl $0x0, %eax
jne 0x359df
movl $0x0, -0x4(%rbp)
jmp 0x35b05
jmp 0x359e1
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x35bb0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x35bb0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x35a3e
movq -0x10(%rbp), %rdi
callq 0x35c20
cmpl $0x0, %eax
jne 0x35a39
movl $0x0, -0x4(%rbp)
jmp 0x35b05
jmp 0x35aeb
cmpl $0x3, -0x1c(%rbp)
jne 0x35a50
movl $0x0, -0x4(%rbp)
jmp 0x35b05
cmpl $0x1, -0x1c(%rbp)
jne 0x35ab7
cmpb $0x0, 0x27262(%rip)     # 0x5ccbf
jne 0x35a64
callq 0x35df0
movq -0x10(%rbp), %rdi
addq $0x34, %rdi
leaq 0x2724d(%rip), %rsi     # 0x5ccc0
movl $0x120, %edx            # imm = 0x120
callq 0x35ec0
cmpl $0x0, %eax
jne 0x35a8b
movl $0x0, -0x4(%rbp)
jmp 0x35b05
movq -0x10(%rbp), %rdi
addq $0x818, %rdi            # imm = 0x818
leaq 0x27203(%rip), %rsi     # 0x5cca0
movl $0x20, %edx
callq 0x35ec0
cmpl $0x0, %eax
jne 0x35ab5
movl $0x0, -0x4(%rbp)
jmp 0x35b05
jmp 0x35ad0
movq -0x10(%rbp), %rdi
callq 0x361d0
cmpl $0x0, %eax
jne 0x35ace
movl $0x0, -0x4(%rbp)
jmp 0x35b05
jmp 0x35ad0
movq -0x10(%rbp), %rdi
callq 0x36520
cmpl $0x0, %eax
jne 0x35ae7
movl $0x0, -0x4(%rbp)
jmp 0x35b05
jmp 0x35ae9
jmp 0x35aeb
jmp 0x35aed
cmpl $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x359f7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__parse_zlib_header(stbi__zbuf*)
static int stbi__parse_zlib_header(stbi__zbuf *a)
{
   int cmf   = stbi__zget8(a);
   int cm    = cmf & 15;
   /* int cinfo = cmf >> 4; */
   int flg   = stbi__zget8(a);
   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x367b0
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x367b0
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
shll $0x8, %eax
addl -0x1c(%rbp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x35b6a
leaq 0x12b3d(%rip), %rdi     # 0x4869d
callq 0x275b0
movl %eax, -0x4(%rbp)
jmp 0x35ba4
movl -0x1c(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x35b86
leaq 0x12b31(%rip), %rdi     # 0x486ad
callq 0x275b0
movl %eax, -0x4(%rbp)
jmp 0x35ba4
cmpl $0x8, -0x18(%rbp)
je 0x35b9d
leaq 0x129eb(%rip), %rdi     # 0x4857e
callq 0x275b0
movl %eax, -0x4(%rbp)
jmp 0x35ba4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__zreceive(stbi__zbuf*, int)
stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
{
   unsigned int k;
   if (z->num_bits < n) stbi__fill_bits(z);
   k = z->code_buffer & ((1 << n) - 1);
   z->code_buffer >>= n;
   z->num_bits -= n;
   return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x35bd4
movq -0x8(%rbp), %rdi
callq 0x367f0
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x14(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__init_zdefaults()
static void stbi__init_zdefaults(void)
{
   int i;   // use <= to match clearly with spec
   for (i=0; i <= 143; ++i)     stbi__zdefault_length[i]   = 8;
   for (   ; i <= 255; ++i)     stbi__zdefault_length[i]   = 9;
   for (   ; i <= 279; ++i)     stbi__zdefault_length[i]   = 7;
   for (   ; i <= 287; ++i)     stbi__zdefault_length[i]   = 8;

   for (i=0; i <=  31; ++i)     stbi__zdefault_distance[i] = 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x8f, -0x4(%rbp)
jg 0x35e1e
movslq -0x4(%rbp), %rcx
leaq 0x26eb1(%rip), %rax     # 0x5ccc0
movb $0x8, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x35dfb
jmp 0x35e20
cmpl $0xff, -0x4(%rbp)
jg 0x35e43
movslq -0x4(%rbp), %rcx
leaq 0x26e8c(%rip), %rax     # 0x5ccc0
movb $0x9, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x35e20
jmp 0x35e45
cmpl $0x117, -0x4(%rbp)      # imm = 0x117
jg 0x35e68
movslq -0x4(%rbp), %rcx
leaq 0x26e67(%rip), %rax     # 0x5ccc0
movb $0x7, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x35e45
jmp 0x35e6a
cmpl $0x11f, -0x4(%rbp)      # imm = 0x11F
jg 0x35e8d
movslq -0x4(%rbp), %rcx
leaq 0x26e42(%rip), %rax     # 0x5ccc0
movb $0x8, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x35e6a
movl $0x0, -0x4(%rbp)
cmpl $0x1f, -0x4(%rbp)
jg 0x35eb4
movslq -0x4(%rbp), %rcx
leaq 0x26dfb(%rip), %rax     # 0x5cca0
movb $0x5, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x35e94
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__fill_bits(stbi__zbuf*)
static void stbi__fill_bits(stbi__zbuf *z)
{
   do {
      STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
      z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
      z->num_bits += 8;
   } while (z->num_bits <= 24);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jae 0x36819
jmp 0x36838
leaq 0x11e9c(%rip), %rdi     # 0x486bc
leaq 0x1188e(%rip), %rsi     # 0x480b5
movl $0xdee, %edx            # imm = 0xDEE
leaq 0x11eae(%rip), %rcx     # 0x486e1
callq 0x52c0
movq -0x8(%rbp), %rdi
callq 0x367b0
movzbl %al, %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
orl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x18, 0x10(%rax)
jle 0x367fc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__zexpand(stbi__zbuf*, char*, int)
static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
{
   char *q;
   int cur, limit, old_limit;
   z->zout = zout;
   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
   cur   = (int) (z->zout     - z->zout_start);
   limit = old_limit = (int) (z->zout_end - z->zout_start);
   while (cur + n > limit)
      limit *= 2;
   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
   STBI_NOTUSED(old_limit);
   if (q == NULL) return stbi__err("outofmem", "Out of memory");
   z->zout_start = q;
   z->zout       = q + cur;
   z->zout_end   = q + limit;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x368bd
leaq 0x11eb4(%rip), %rdi     # 0x48764
callq 0x275b0
movl %eax, -0x4(%rbp)
jmp 0x36967
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addl -0x1c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jle 0x36901
movl -0x30(%rbp), %eax
shll %eax
movl %eax, -0x30(%rbp)
jmp 0x368ec
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x30(%rbp), %rsi
callq 0x5670
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3692e
leaq 0x116c1(%rip), %rdi     # 0x47fe5
callq 0x275b0
movl %eax, -0x4(%rbp)
jmp 0x36967
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movslq -0x30(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__bitreverse16(int)
stbi_inline static int stbi__bitreverse16(int n)
{
  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xaaaa, %eax           # imm = 0xAAAA
sarl %eax
movl -0x4(%rbp), %ecx
andl $0x5555, %ecx           # imm = 0x5555
shll %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xcccc, %eax           # imm = 0xCCCC
sarl $0x2, %eax
movl -0x4(%rbp), %ecx
andl $0x3333, %ecx           # imm = 0x3333
shll $0x2, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xf0f0, %eax           # imm = 0xF0F0
sarl $0x4, %eax
movl -0x4(%rbp), %ecx
andl $0xf0f, %ecx            # imm = 0xF0F
shll $0x4, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl -0x4(%rbp), %ecx
andl $0xff, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__zhuffman_decode(stbi__zbuf*, stbi__zhuffman*)
stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)
{
   int b,s;
   if (a->num_bits < 16) stbi__fill_bits(a);
   b = z->fast[a->code_buffer & STBI__ZFAST_MASK];
   if (b) {
      s = b >> 9;
      a->code_buffer >>= s;
      a->num_bits -= s;
      return b & 511;
   }
   return stbi__zhuffman_decode_slowpath(a, z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x10, 0x10(%rax)
jge 0x36a63
movq -0x10(%rbp), %rdi
callq 0x367f0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movl %ecx, %ecx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x36ab9
movl -0x1c(%rbp), %eax
sarl $0x9, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x14(%rax)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
movl -0x1c(%rbp), %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, -0x4(%rbp)
jmp 0x36ac9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36ae0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__zhuffman_decode_slowpath(stbi__zbuf*, stbi__zhuffman*)
static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
{
   int b,s,k;
   // not resolved by fast table, so compute it the slow way
   // use jpeg approach, which requires MSbits at top
   k = stbi__bit_reverse(a->code_buffer, 16);
   for (s=STBI__ZFAST_BITS+1; ; ++s)
      if (k < z->maxcode[s])
         break;
   if (s == 16) return -1; // invalid code!
   // code size is s, so:
   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
   STBI_ASSERT(z->size[b] == s);
   a->code_buffer >>= s;
   a->num_bits -= s;
   return z->value[b];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edi
movl $0x10, %esi
callq 0x36970
movl %eax, -0x24(%rbp)
movl $0xa, -0x20(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
cmpl 0x420(%rcx,%rdx,4), %eax
jge 0x36b21
jmp 0x36b2e
jmp 0x36b23
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x36b0b
cmpl $0x10, -0x20(%rbp)
jne 0x36b40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x36bdd
movl -0x24(%rbp), %eax
movl $0x10, %ecx
subl -0x20(%rbp), %ecx
sarl %cl, %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzwl 0x400(%rcx,%rdx,2), %ecx
subl %ecx, %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzwl 0x464(%rcx,%rdx,2), %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl 0x484(%rax,%rcx), %eax
cmpl -0x20(%rbp), %eax
jne 0x36b8b
jmp 0x36baa
leaq 0x11c61(%rip), %rdi     # 0x487f3
leaq 0x1151c(%rip), %rsi     # 0x480b5
movl $0xe0a, %edx            # imm = 0xE0A
leaq 0x11c5e(%rip), %rcx     # 0x48803
callq 0x52c0
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x14(%rax)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzwl 0x5a4(%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__hdr_test_core(stbi__context*)
static int stbi__hdr_test_core(stbi__context *s)
{
   const char *signature = "#?RADIANCE\n";
   int i;
   for (i=0; signature[i]; ++i)
      if (stbi__get8(s) != signature[i])
         return 0;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x11c4c(%rip), %rax     # 0x4884f
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x36c4e
movq -0x10(%rbp), %rdi
callq 0x2ce50
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x36c41
movl $0x0, -0x4(%rbp)
jmp 0x36c55
jmp 0x36c43
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x36c0e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__bmp_info(stbi__context*, int*, int*, int*)
static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
{
   void *p;
   stbi__bmp_data info;

   info.all_a = 255;   
   p = stbi__bmp_parse_header(s, &info);
   stbi__rewind( s );
   if (p == NULL)
      return 0;
   *x = s->img_x;
   *y = s->img_y;
   *comp = info.ma ? 4 : 3;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xff, -0x34(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x33400
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b420
cmpq $0x0, -0x30(%rbp)
jne 0x36d79
movl $0x0, -0x4(%rbp)
jmp 0x36db2
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x38(%rbp), %edx
movl $0x3, %ecx
movl $0x4, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__psd_info(stbi__context*, int*, int*, int*)
static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
{
   int channelCount;
   if (stbi__get32be(s) != 0x38425053) {
       stbi__rewind( s );
       return 0;
   }
   if (stbi__get16be(s) != 1) {
       stbi__rewind( s );
       return 0;
   }
   stbi__skip(s, 6);
   channelCount = stbi__get16be(s);
   if (channelCount < 0 || channelCount > 16) {
       stbi__rewind( s );
       return 0;
   }
   *y = stbi__get32be(s);
   *x = stbi__get32be(s);
   if (stbi__get16be(s) != 8) {
       stbi__rewind( s );
       return 0;
   }
   if (stbi__get16be(s) != 3) {
       stbi__rewind( s );
       return 0;
   }
   *comp = 4;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31510
cmpl $0x38425053, %eax       # imm = 0x38425053
je 0x36dfd
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x36ecb
movq -0x10(%rbp), %rdi
callq 0x2cf90
cmpl $0x1, %eax
je 0x36e20
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x36ecb
movq -0x10(%rbp), %rdi
movl $0x6, %esi
callq 0x2d340
movq -0x10(%rbp), %rdi
callq 0x2cf90
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x36e46
cmpl $0x10, -0x2c(%rbp)
jle 0x36e58
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x36ecb
movq -0x10(%rbp), %rdi
callq 0x31510
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x31510
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x2cf90
cmpl $0x8, %eax
je 0x36e9a
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x36ecb
movq -0x10(%rbp), %rdi
callq 0x2cf90
cmpl $0x3, %eax
je 0x36eba
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x36ecb
movq -0x28(%rbp), %rax
movl $0x4, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__hdr_info(stbi__context*, int*, int*, int*)
static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
{
   char buffer[STBI__HDR_BUFLEN];
   char *token;
   int valid = 0;

   if (stbi__hdr_test(s) == 0) {
       stbi__rewind( s );
       return 0;
   }

   for(;;) {
      token = stbi__hdr_gettoken(s,buffer);
      if (token[0] == 0) break;
      if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1;
   }

   if (!valid) {
       stbi__rewind( s );
       return 0;
   }
   token = stbi__hdr_gettoken(s,buffer);
   if (strncmp(token, "-Y ", 3)) {
       stbi__rewind( s );
       return 0;
   }
   token += 3;
   *y = (int) strtol(token, &token, 10);
   while (*token == ' ') ++token;
   if (strncmp(token, "+X ", 3)) {
       stbi__rewind( s );
       return 0;
   }
   token += 3;
   *x = (int) strtol(token, NULL, 10);
   *comp = 3;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x43c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27cd0
cmpl $0x0, %eax
jne 0x37108
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x37281
jmp 0x3710a
movq -0x10(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x353e0
movq %rax, -0x438(%rbp)
movq -0x438(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x37132
jmp 0x37156
movq -0x438(%rbp), %rdi
leaq 0x1148f(%rip), %rsi     # 0x485cf
callq 0x55b0
cmpl $0x0, %eax
jne 0x37154
movl $0x1, -0x43c(%rbp)
jmp 0x3710a
cmpl $0x0, -0x43c(%rbp)
jne 0x37174
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x37281
movq -0x10(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x353e0
movq %rax, -0x438(%rbp)
movq -0x438(%rbp), %rdi
leaq 0x11460(%rip), %rsi     # 0x485f9
movl $0x3, %edx
callq 0x5200
cmpl $0x0, %eax
je 0x371bd
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x37281
movq -0x438(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x438(%rbp)
movq -0x438(%rbp), %rdi
leaq -0x438(%rbp), %rsi
movl $0xa, %edx
callq 0x55c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x438(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x37212
movq -0x438(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x438(%rbp)
jmp 0x371ef
movq -0x438(%rbp), %rdi
leaq 0x113f5(%rip), %rsi     # 0x48615
movl $0x3, %edx
callq 0x5200
cmpl $0x0, %eax
je 0x37241
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x37281
movq -0x438(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x438(%rbp)
movq -0x438(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x55c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl $0x3, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__jpeg_info_raw(stbi__jpeg*, int*, int*, int*)
static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)
{
   if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {
      stbi__rewind( j->s );
      return 0;
   }
   if (x) *x = j->s->img_x;
   if (y) *y = j->s->img_y;
   if (comp) *comp = j->s->img_n;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x2b2d0
cmpl $0x0, %eax
jne 0x37530
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x3757b
cmpq $0x0, -0x18(%rbp)
je 0x37546
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x3755d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x37574
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__png_info_raw(stbi__png*, int*, int*, int*)
static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
{
   if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
      stbi__rewind( p->s );
      return 0;
   }
   if (x) *x = p->s->img_x;
   if (y) *y = p->s->img_y;
   if (comp) *comp = p->s->img_n;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x302b0
cmpl $0x0, %eax
jne 0x375d2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x3761d
cmpq $0x0, -0x18(%rbp)
je 0x375e8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x375ff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x37616
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__gif_info_raw(stbi__context*, int*, int*, int*)
static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)
{
   stbi__gif g;
   if (!stbi__gif_header(s, &g, comp, 1)) {
      stbi__rewind( s );
      return 0;
   }
   if (x) *x = g.w;
   if (y) *y = g.h;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4890, %rsp           # imm = 0x4890
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x4888(%rbp), %rsi
movl $0x1, %ecx
callq 0x340f0
cmpl $0x0, %eax
jne 0x3767b
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x376a8
cmpq $0x0, -0x18(%rbp)
je 0x3768e
movl -0x4888(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x376a1
movl -0x4884(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x4890, %rsp           # imm = 0x4890
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbi_write_bmp_core(stbi__write_context*, int, int, int, void const*)
static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)
{
   int pad = (-x*3) & 3;
   return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad,
           "11 4 22 4" "4 44 22 444444",
           'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40,  // file header
            40, x,y, 1,24, 0,0,0,0,0,0);             // bitmap header
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
xorl %eax, %eax
subl -0x24(%rbp), %eax
imull $0x3, %eax, %eax
andl $0x3, %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
movq -0x38(%rbp), %r15
movl -0x3c(%rbp), %r14d
imull $0x3, -0x24(%rbp), %r11d
addl -0x3c(%rbp), %r11d
imull -0x28(%rbp), %r11d
addl $0x36, %r11d
movl -0x24(%rbp), %r10d
movl -0x28(%rbp), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %esi, %esi
leaq 0x112b1(%rip), %rbx     # 0x48abe
movl %edx, %esi
movl $0x1, (%rsp)
movq %r15, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl %r14d, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movl $0x42, 0x28(%rsp)
movl $0x4d, 0x30(%rsp)
movl %r11d, 0x38(%rsp)
movl $0x0, 0x40(%rsp)
movl $0x0, 0x48(%rsp)
movl $0x36, 0x50(%rsp)
movl $0x28, 0x58(%rsp)
movl %r10d, 0x60(%rsp)
movl %eax, 0x68(%rsp)
movl $0x1, 0x70(%rsp)
movl $0x18, 0x78(%rsp)
movl $0x0, 0x80(%rsp)
movl $0x0, 0x88(%rsp)
movl $0x0, 0x90(%rsp)
movl $0x0, 0x98(%rsp)
movl $0x0, 0xa0(%rsp)
movl $0x0, 0xa8(%rsp)
movb $0x0, %al
callq 0x3a3b0
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image_write.hpp
// Function: stbi_write_bmp
STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_bmp_core(&s, x, y, comp, 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 0x37935
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdi
callq 0x377a0
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x379a0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3793c
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: stbi_write_tga
int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_tga_core(&s, x, y, comp, (void *) 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 0x37f15
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdi
callq 0x37a10
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x379a0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x37f1c
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__linear_to_rgbe(unsigned char*, float*)
void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
{
   int exponent;
   float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));

   if (maxcomp < 1e-32f) {
      rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
   } else {
      float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp;

      rgbe[0] = (unsigned char)(linear[0] * normalize);
      rgbe[1] = (unsigned char)(linear[1] * normalize);
      rgbe[2] = (unsigned char)(linear[2] * normalize);
      rgbe[3] = (unsigned char)(exponent + 128);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
ucomiss 0x8(%rax), %xmm0
jbe 0x37f70
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
jmp 0x37f7e
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x20(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x37f9c
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0x37fd7
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
ucomiss 0x8(%rax), %xmm0
jbe 0x37fbf
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
jmp 0x37fcd
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x10873(%rip), %xmm0    # 0x4885c
ucomiss -0x18(%rbp), %xmm0
jbe 0x38013
movq -0x8(%rbp), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x380a7
movss -0x18(%rbp), %xmm0
leaq -0x14(%rbp), %rdi
callq 0x3ab60
movss 0x10837(%rip), %xmm1    # 0x48860
mulss %xmm1, %xmm0
movss -0x18(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
addl $0x80, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)