LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: RacineN(double*&)
void  RacineN(double*&p)
{double v2=*p--,v1=*p;
if(v1==ErrVal||v2==ErrVal||!v1||v2*logl(fabsl(v1))<DBL_MIN_EXP){*p=ErrVal;return;};
if(v2>=0){*p=powl(v2,1/v1);return;};
*p=((fabsl(fmodl(v1,2))==1)?-powl(-v2,1/v1):ErrVal);}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, (%rcx)
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x21bb5(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x25dad
jp 0x25dad
jmp 0x25e0c
movsd -0x10(%rbp), %xmm0
movsd 0x21b9e(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x25dc4
jp 0x25dc4
jmp 0x25e0c
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x25dd6
jp 0x25dd6
jmp 0x25e0c
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movaps 0x21d24(%rip), %xmm1    # 0x47b10
pand %xmm1, %xmm0
callq 0x5350
movsd -0x20(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x21b7a(%rip), %xmm0    # 0x47980
ucomisd %xmm1, %xmm0
jbe 0x25e24
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x21b3d(%rip), %xmm0    # 0x47958
movsd %xmm0, (%rax)
jmp 0x25eee
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x25e59
movsd -0x10(%rbp), %xmm0
movsd 0x212f9(%rip), %xmm1    # 0x47138
divsd -0x18(%rbp), %xmm1
callq 0x5710
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd %xmm0, (%rax)
jmp 0x25eee
movsd -0x18(%rbp), %xmm0
movl $0x2, %edi
callq 0x273e0
movaps 0x21ca1(%rip), %xmm1    # 0x47b10
pand %xmm1, %xmm0
movsd 0x212bd(%rip), %xmm1    # 0x47138
ucomisd %xmm1, %xmm0
jne 0x25ecf
jp 0x25ecf
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x21291(%rip), %xmm1    # 0x47138
divsd -0x18(%rbp), %xmm1
callq 0x5710
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x25ede
movsd 0x21a81(%rip), %xmm0    # 0x47958
movsd %xmm0, -0x28(%rbp)
jmp 0x25ede
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd %xmm0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/mathexpr.cpp
// Function: Puiss10(double*&)
void  Puiss10(double*&p)
{if(fabsl(*p)<sqrtminfloat){*(--p)=0;return;};
if(*p==ErrVal||fabsl(*p)>DBL_MAX_10_EXP){*(--p)=ErrVal;return;};
if(fabsl(*(--p))<sqrtminfloat)*p=0;else if(*p==ErrVal||fabsl(*p)>sqrtmaxfloat)
{*p=ErrVal;return;};
*p*=pow10l(*(p+1));}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm1
movaps 0x21bf2(%rip), %xmm0    # 0x47b10
pand %xmm0, %xmm1
movsd 0x36d46(%rip), %xmm0    # 0x5cc70
ucomisd %xmm1, %xmm0
jbe 0x25f4e
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rax)
jmp 0x2606a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd 0x219f7(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x25f6b
jp 0x25f6b
jmp 0x25f8f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movaps 0x21b93(%rip), %xmm1    # 0x47b10
pand %xmm1, %xmm0
movsd 0x219ff(%rip), %xmm1    # 0x47988
ucomisd %xmm1, %xmm0
jbe 0x25fb2
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, (%rcx)
movsd 0x219b0(%rip), %xmm0    # 0x47958
movsd %xmm0, -0x8(%rax)
jmp 0x2606a
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, (%rcx)
movsd -0x8(%rax), %xmm1
movaps 0x21b41(%rip), %xmm0    # 0x47b10
pand %xmm0, %xmm1
movsd 0x36c95(%rip), %xmm0    # 0x5cc70
ucomisd %xmm1, %xmm0
jbe 0x25ff1
movq -0x8(%rbp), %rax
movq (%rax), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x26045
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd 0x21954(%rip), %xmm1    # 0x47958
ucomisd %xmm1, %xmm0
jne 0x2600e
jp 0x2600e
jmp 0x2602e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movaps 0x21af0(%rip), %xmm1    # 0x47b10
pand %xmm1, %xmm0
ucomisd 0x36c3c(%rip), %xmm0    # 0x5cc68
jbe 0x26043
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x2191b(%rip), %xmm0    # 0x47958
movsd %xmm0, (%rax)
jmp 0x2606a
jmp 0x26045
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movl $0xa, %edi
callq 0x27410
movq -0x8(%rbp), %rax
movq (%rax), %rax
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_load
STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   FILE *f = stbi__fopen(filename, "rb");
   unsigned char *result;
   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
   result = stbi_load_from_file(f,x,y,comp,req_comp);
   fclose(f);
   return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x209d5(%rip), %rsi     # 0x47eec
callq 0x27580
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x27544
leaq 0x209c1(%rip), %rdi     # 0x47eef
callq 0x275b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x27572
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x275d0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x53f0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_load_from_file
STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *result;
   stbi__context s;
   stbi__start_file(&s,f);
   result = stbi__load_flip(&s,x,y,comp,req_comp);
   if (result) {
      // need to 'unget' all the characters in the IO buffer
      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
   }
   return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x27660
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
leaq -0x108(%rbp), %rdi
callq 0x27690
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x27648
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movslq %eax, %rsi
movl $0x1, %edx
callq 0x5490
movq -0x30(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__load_flip(stbi__context*, int*, int*, int*, int)
static unsigned char *stbi__load_flip(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *result = stbi__load_main(s, x, y, comp, 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;
      stbi_uc 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;
            }
         }
      }
   }

   return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x28770
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x355b8(%rip)     # 0x5cc88
je 0x277fb
cmpq $0x0, -0x30(%rbp)
je 0x277fb
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x27701
movl -0x24(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0x2770a
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl -0x38(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0x277f9
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x277e9
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x277d9
movq -0x30(%rbp), %rax
movl -0x40(%rbp), %ecx
imull -0x34(%rbp), %ecx
addl -0x44(%rbp), %ecx
imull -0x3c(%rbp), %ecx
addl -0x48(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
movq -0x30(%rbp), %rax
movl -0x38(%rbp), %ecx
subl -0x40(%rbp), %ecx
subl $0x1, %ecx
imull -0x34(%rbp), %ecx
addl -0x44(%rbp), %ecx
imull -0x3c(%rbp), %ecx
addl -0x48(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movl -0x40(%rbp), %ecx
imull -0x34(%rbp), %ecx
addl -0x44(%rbp), %ecx
imull -0x3c(%rbp), %ecx
addl -0x48(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x49(%rbp), %dl
movq -0x30(%rbp), %rax
movl -0x38(%rbp), %ecx
subl -0x40(%rbp), %ecx
subl $0x1, %ecx
imull -0x34(%rbp), %ecx
addl -0x44(%rbp), %ecx
imull -0x3c(%rbp), %ecx
addl -0x48(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x27741
jmp 0x277db
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2772e
jmp 0x277eb
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x27717
jmp 0x277fb
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__start_mem(stbi__context*, unsigned char const*, int)
static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)
{
   s->io.read = NULL;
   s->read_from_callbacks = 0;
   s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;
   s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0xc0(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__start_callbacks(stbi__context*, stbi_io_callbacks*, void*)
static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
{
   s->io = *c;
   s->io_user_data = user;
   s->buflen = sizeof(s->buffer_start);
   s->read_from_callbacks = 1;
   s->img_buffer_original = s->buffer_start;
   stbi__refill_buffer(s);
   s->img_buffer_original_end = s->img_buffer_end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x80, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x8(%rbp), %rcx
addq $0x38, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x8(%rbp), %rdi
callq 0x2cee0
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__loadf_main(stbi__context*, int*, int*, int*, int)
static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *data;
   #ifndef STBI_NO_HDR
   if (stbi__hdr_test(s)) {
      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp);
      if (hdr_data)
         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
      return hdr_data;
   }
   #endif
   data = stbi__load_flip(s, x, y, comp, req_comp);
   if (data)
      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27cd0
cmpl $0x0, %eax
je 0x27aa4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x2a130
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x27a97
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x356e0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27b2c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x27690
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x27b11
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x27af0
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x27af9
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movl -0x44(%rbp), %edx
movl -0x48(%rbp), %esi
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %ecx
callq 0x35840
movq %rax, -0x8(%rbp)
jmp 0x27b2c
leaq 0x203e3(%rip), %rdi     # 0x47efb
callq 0x275b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_loadf
STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   float *result;
   FILE *f = stbi__fopen(filename, "rb");
   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
   fclose(f);
   return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x20325(%rip), %rsi     # 0x47eec
callq 0x27580
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x27bf4
leaq 0x20311(%rip), %rdi     # 0x47eef
callq 0x275b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x27c22
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x27c30
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x53f0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_is_hdr
STBIDEF int      stbi_is_hdr          (char const *filename)
{
   FILE *f = stbi__fopen(filename, "rb");
   int result=0;
   if (f) {
      result = stbi_is_hdr_from_file(f);
      fclose(f);
   }
   return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x201d5(%rip), %rsi     # 0x47eec
callq 0x27580
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27d43
movq -0x10(%rbp), %rdi
callq 0x27d50
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x53f0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_zlib_decode_malloc_guesssize
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(initial_size);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer + len;
   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x18(%rbp), %rdi
callq 0x27f20
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
jne 0x27e90
movq $0x0, -0x8(%rbp)
jmp 0x27f12
movq -0x10(%rbp), %rax
movq %rax, -0x1020(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x1018(%rbp)
movq -0x1028(%rbp), %rsi
movl -0x18(%rbp), %edx
leaq -0x1020(%rbp), %rdi
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x27f40
cmpl $0x0, %eax
je 0x27efe
cmpq $0x0, -0x20(%rbp)
je 0x27ef1
movq -0x1008(%rbp), %rax
movq -0x1000(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x1000(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27f12
movq -0x1000(%rbp), %rdi
callq 0x54c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__do_zlib(stbi__zbuf*, char*, int, int, int)
static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)
{
   a->zout_start = obuf;
   a->zout       = obuf;
   a->zout_end   = obuf + olen;
   a->z_expandable = exp;

   return stbi__parse_zlib(a, parse_header);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x359b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_zlib_decode_malloc_guesssize_headerflag
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(initial_size);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer + len;
   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movslq -0x18(%rbp), %rdi
callq 0x27f20
movq %rax, -0x1030(%rbp)
cmpq $0x0, -0x1030(%rbp)
jne 0x28024
movq $0x0, -0x8(%rbp)
jmp 0x280a6
movq -0x10(%rbp), %rax
movq %rax, -0x1028(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x1020(%rbp)
movq -0x1030(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x24(%rbp), %r8d
leaq -0x1028(%rbp), %rdi
movl $0x1, %ecx
callq 0x27f40
cmpl $0x0, %eax
je 0x28092
cmpq $0x0, -0x20(%rbp)
je 0x28085
movq -0x1010(%rbp), %rax
movq -0x1008(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x1008(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x280a6
movq -0x1008(%rbp), %rdi
callq 0x54c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_zlib_decode_buffer
STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)
{
   stbi__zbuf a;
   a.zbuffer = (stbi_uc *) ibuffer;
   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
   if (stbi__do_zlib(&a, obuffer, olen, 0, 1))
      return (int) (a.zout - a.zout_start);
   else
      return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x1028(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x1020(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x1028(%rbp), %rdi
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x27f40
cmpl $0x0, %eax
je 0x2812c
movq -0x1010(%rbp), %rax
movq -0x1008(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x28133
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_zlib_decode_noheader_malloc
STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(16384);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer+len;
   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x4000, %edi           # imm = 0x4000
callq 0x27f20
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
jne 0x2817e
movq $0x0, -0x8(%rbp)
jmp 0x28201
movq -0x10(%rbp), %rax
movq %rax, -0x1020(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x1018(%rbp)
movq -0x1028(%rbp), %rsi
leaq -0x1020(%rbp), %rdi
movl $0x4000, %edx           # imm = 0x4000
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x27f40
cmpl $0x0, %eax
je 0x281ed
cmpq $0x0, -0x20(%rbp)
je 0x281e0
movq -0x1008(%rbp), %rax
movq -0x1000(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x1000(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28201
movq -0x1000(%rbp), %rdi
callq 0x54c0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_zlib_decode_noheader_buffer
STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)
{
   stbi__zbuf a;
   a.zbuffer = (stbi_uc *) ibuffer;
   a.zbuffer_end = (stbi_uc *) ibuffer + ilen;
   if (stbi__do_zlib(&a, obuffer, olen, 0, 0))
      return (int) (a.zout - a.zout_start);
   else
      return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x1028(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x1020(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x1028(%rbp), %rdi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x27f40
cmpl $0x0, %eax
je 0x2827a
movq -0x1010(%rbp), %rax
movq -0x1008(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x28281
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__tga_read_rgb16(stbi__context*, unsigned char*)
void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
{
   stbi__uint16 px = stbi__get16le(s);
   stbi__uint16 fiveBitMask = 31;
   // we have 3 channels with 5bits each
   int r = (px >> 10) & fiveBitMask;
   int g = (px >> 5) & fiveBitMask;
   int b = px & fiveBitMask;
   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
   out[0] = (r * 255)/31;
   out[1] = (g * 255)/31;
   out[2] = (b * 255)/31;

   // some people claim that the most significant bit might be used for alpha
   // (possibly if an alpha-bit is set in the "image descriptor byte")
   // but that only made 16bit test images completely translucent..
   // so let's treat all 15 and 16bit TGAs as RGB with no alpha.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28370
movw %ax, -0x12(%rbp)
movw $0x1f, -0x14(%rbp)
movzwl -0x12(%rbp), %eax
sarl $0xa, %eax
movzwl -0x14(%rbp), %ecx
andl %ecx, %eax
movl %eax, -0x18(%rbp)
movzwl -0x12(%rbp), %eax
sarl $0x5, %eax
movzwl -0x14(%rbp), %ecx
andl %ecx, %eax
movl %eax, -0x1c(%rbp)
movzwl -0x12(%rbp), %eax
movzwl -0x14(%rbp), %ecx
andl %ecx, %eax
movl %eax, -0x20(%rbp)
imull $0xff, -0x18(%rbp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
imull $0xff, -0x1c(%rbp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
imull $0xff, -0x20(%rbp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_info
STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
{
    FILE *f = stbi__fopen(filename, "rb");
    int result;
    if (!f) return stbi__err("can't fopen", "Unable to open file");
    result = stbi_info_from_file(f, x, y, comp);
    fclose(f);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1fb19(%rip), %rsi     # 0x47eec
callq 0x27580
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x283f4
leaq 0x1fb05(%rip), %rdi     # 0x47eef
callq 0x275b0
movl %eax, -0x4(%rbp)
jmp 0x2841b
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x28430
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x53f0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi_info_from_file
STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
{
   int r;
   stbi__context s;
   long pos = ftell(f);
   stbi__start_file(&s, f);
   r = stbi__info_main(&s,x,y,comp);
   fseek(f,pos,SEEK_SET);
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5030
movq %rax, -0x108(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x27660
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x100(%rbp), %rdi
callq 0x284b0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x108(%rbp), %rsi
xorl %edx, %edx
callq 0x5490
movl -0x24(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__info_main(stbi__context*, int*, int*, int*)
static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)
{
   #ifndef STBI_NO_JPEG
   if (stbi__jpeg_info(s, x, y, comp)) return 1;
   #endif

   #ifndef STBI_NO_PNG
   if (stbi__png_info(s, x, y, comp))  return 1;
   #endif

   #ifndef STBI_NO_GIF
   if (stbi__gif_info(s, x, y, comp))  return 1;
   #endif

   #ifndef STBI_NO_BMP
   if (stbi__bmp_info(s, x, y, comp))  return 1;
   #endif

   #ifndef STBI_NO_PSD
   if (stbi__psd_info(s, x, y, comp))  return 1;
   #endif

   #ifndef STBI_NO_PIC
   if (stbi__pic_info(s, x, y, comp))  return 1;
   #endif

   #ifndef STBI_NO_PNM
   if (stbi__pnm_info(s, x, y, comp))  return 1;
   #endif

   #ifndef STBI_NO_HDR
   if (stbi__hdr_info(s, x, y, comp))  return 1;
   #endif

   // test tga last because it's a crappy test!
   #ifndef STBI_NO_TGA
   if (stbi__tga_info(s, x, y, comp))
       return 1;
   #endif
   return stbi__err("unknown image type", "Image not of any known type, or corrupt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x36c60
cmpl $0x0, %eax
je 0x284ee
movl $0x1, -0x4(%rbp)
jmp 0x28621
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x36cb0
cmpl $0x0, %eax
je 0x28514
movl $0x1, -0x4(%rbp)
jmp 0x28621
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x36cf0
cmpl $0x0, %eax
je 0x2853a
movl $0x1, -0x4(%rbp)
jmp 0x28621
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x36d30
cmpl $0x0, %eax
je 0x28560
movl $0x1, -0x4(%rbp)
jmp 0x28621
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x36dc0
cmpl $0x0, %eax
je 0x28586
movl $0x1, -0x4(%rbp)
jmp 0x28621
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x36ee0
cmpl $0x0, %eax
je 0x285a9
movl $0x1, -0x4(%rbp)
jmp 0x28621
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x350c0
cmpl $0x0, %eax
je 0x285cc
movl $0x1, -0x4(%rbp)
jmp 0x28621
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x370c0
cmpl $0x0, %eax
je 0x285ef
movl $0x1, -0x4(%rbp)
jmp 0x28621
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x37290
cmpl $0x0, %eax
je 0x28612
movl $0x1, -0x4(%rbp)
jmp 0x28621
leaq 0x1f8e2(%rip), %rdi     # 0x47efb
callq 0x275b0
movl %eax, -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__jpeg_test(stbi__context*)
static int stbi__jpeg_test(stbi__context *s)
{
   int r;
   stbi__jpeg j;
   j.s = s;
   stbi__setup_jpeg(&j);
   r = stbi__decode_jpeg_header(&j, STBI__SCAN_type);
   stbi__rewind(s);
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4790, %rsp           # imm = 0x4790
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x4790(%rbp)
leaq -0x4790(%rbp), %rdi
callq 0x2b290
leaq -0x4790(%rbp), %rdi
movl $0x1, %esi
callq 0x2b2d0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2b420
movl -0xc(%rbp), %eax
addq $0x4790, %rsp           # imm = 0x4790
popq %rbp
retq
nop
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__gif_load(stbi__context*, int*, int*, int*, int)
static stbi_uc *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   stbi_uc *u = 0;
   stbi__gif g;
   memset(&g, 0, sizeof(g));

   u = stbi__gif_load_next(s, &g, comp, req_comp);
   if (u == (stbi_uc *) s) u = 0;  // end of animated gif marker
   if (u) {
      *x = g.w;
      *y = g.h;
      if (req_comp && req_comp != 4)
         u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
   }
   else if (g.out)
      STBI_FREE(g.out);

   return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4890, %rsp           # imm = 0x4890
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x4890(%rbp), %rdi
xorl %esi, %esi
movl $0x4860, %edx           # imm = 0x4860
callq 0x5230
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x4890(%rbp), %rsi
callq 0x33ab0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x29807
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x29856
movl -0x4890(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x488c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
je 0x29854
cmpl $0x4, -0x24(%rbp)
je 0x29854
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x4890(%rbp), %ecx
movl -0x488c(%rbp), %r8d
movl $0x4, %esi
callq 0x30f30
movq %rax, -0x30(%rbp)
jmp 0x2986e
cmpq $0x0, -0x4888(%rbp)
je 0x2986c
movq -0x4888(%rbp), %rdi
callq 0x54c0
jmp 0x2986e
movq -0x30(%rbp), %rax
addq $0x4890, %rsp           # imm = 0x4890
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__pic_load(stbi__context*, int*, int*, int*, int)
static stbi_uc *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp)
{
   stbi_uc *result;
   int i, x,y;

   for (i=0; i<92; ++i)
      stbi__get8(s);

   x = stbi__get16be(s);
   y = stbi__get16be(s);
   if (stbi__at_eof(s))  return stbi__errpuc("bad file","file too short (pic header)");
   if ((1 << 28) / x < y) return stbi__errpuc("too large", "Image too large to decode");

   stbi__get32be(s); //skip `ratio'
   stbi__get16be(s); //skip `fields'
   stbi__get16be(s); //skip `pad'

   // intermediate buffer is RGBA
   result = (stbi_uc *) stbi__malloc(x*y*4);
   memset(result, 0xff, x*y*4);

   if (!stbi__pic_load_core(s,x,y,comp, result)) {
      STBI_FREE(result);
      result=0;
   }
   *px = x;
   *py = y;
   if (req_comp == 0) req_comp = *comp;
   result=stbi__convert_format(result,4,req_comp,x,y);

   return result;
}

// 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 %r8d, -0x2c(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x5c, -0x3c(%rbp)
jge 0x29e3d
movq -0x10(%rbp), %rdi
callq 0x2ce50
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x29e23
movq -0x10(%rbp), %rdi
callq 0x2cf90
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2cf90
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2c540
cmpl $0x0, %eax
je 0x29e83
leaq 0x1e72e(%rip), %rdi     # 0x48598
callq 0x275b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x29f70
movl $0x10000000, %eax       # imm = 0x10000000
cltd
idivl -0x40(%rbp)
cmpl -0x44(%rbp), %eax
jge 0x29eb1
leaq 0x1e143(%rip), %rdi     # 0x47fdb
callq 0x275b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x29f70
movq -0x10(%rbp), %rdi
callq 0x31510
movq -0x10(%rbp), %rdi
callq 0x2cf90
movq -0x10(%rbp), %rdi
callq 0x2cf90
movl -0x40(%rbp), %eax
imull -0x44(%rbp), %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x27f20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movl -0x40(%rbp), %eax
imull -0x44(%rbp), %eax
shll $0x2, %eax
movslq %eax, %rdx
movl $0xff, %esi
callq 0x5230
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x44(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x34a40
cmpq $0x0, %rax
jne 0x29f2b
movq -0x38(%rbp), %rdi
callq 0x54c0
movq $0x0, -0x38(%rbp)
movl -0x40(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x44(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x2c(%rbp)
jne 0x29f4c
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %edx
movl -0x40(%rbp), %ecx
movl -0x44(%rbp), %r8d
movl $0x4, %esi
callq 0x30f30
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__pnm_test(stbi__context*)
static int      stbi__pnm_test(stbi__context *s)
{
   char p, t;
   p = (char) stbi__get8(s);
   t = (char) stbi__get8(s);
   if (p != 'P' || (t != '5' && t != '6')) {
       stbi__rewind( s );
       return 0;
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ce50
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ce50
movb %al, -0x12(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x50, %eax
jne 0x29fbf
movsbl -0x12(%rbp), %eax
cmpl $0x35, %eax
je 0x29fd1
movsbl -0x12(%rbp), %eax
cmpl $0x36, %eax
je 0x29fd1
movq -0x10(%rbp), %rdi
callq 0x2b420
movl $0x0, -0x4(%rbp)
jmp 0x29fd8
movl $0x1, -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__pnm_load(stbi__context*, int*, int*, int*, int)
static stbi_uc *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   stbi_uc *out;
   if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n))
      return 0;
   *x = s->img_x;
   *y = s->img_y;
   *comp = s->img_n;

   out = (stbi_uc *) stbi__malloc(s->img_n * s->img_x * s->img_y);
   if (!out) return stbi__errpuc("outofmem", "Out of memory");
   stbi__getn(s, out, s->img_n * s->img_x * s->img_y);

   if (req_comp && req_comp != s->img_n) {
      out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
      if (out == NULL) return out; // stbi__convert_format frees input on failure
   }
   return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
callq 0x350c0
cmpl $0x0, %eax
jne 0x2a03b
movq $0x0, -0x8(%rbp)
jmp 0x2a11d
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)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull (%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x4(%rcx), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x27f20
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2a0a8
leaq 0x1df53(%rip), %rdi     # 0x47fe5
callq 0x275b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x2a11d
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
imull (%rax), %edx
movq -0x10(%rbp), %rax
imull 0x4(%rax), %edx
callq 0x31550
cmpl $0x0, -0x2c(%rbp)
je 0x2a115
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x2a115
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x2c(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %r8d
callq 0x30f30
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2a113
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a11d
jmp 0x2a115
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__decode_jpeg_header(stbi__jpeg*, int)
static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
{
   int m;
   z->marker = STBI__MARKER_none; // initialize cached marker to empty
   m = stbi__get_marker(z);
   if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG");
   if (scan == STBI__SCAN_type) return 1;
   m = stbi__get_marker(z);
   while (!stbi__SOF(m)) {
      if (!stbi__process_marker(z,m)) return 0;
      m = stbi__get_marker(z);
      while (m == STBI__MARKER_none) {
         // some files have extra padding after their blocks, so ok, we'll scan
         if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG");
         m = stbi__get_marker(z);
      }
   }
   z->progressive = stbi__SOF_progressive(m);
   if (!stbi__process_frame_header(z, scan)) return 0;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movb $-0x1, 0x4728(%rax)
movq -0x10(%rbp), %rdi
callq 0x2c0b0
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0xd8, -0x18(%rbp)
je 0x2b316
leaq 0x1cc05(%rip), %rdi     # 0x47f0e
callq 0x275b0
movl %eax, -0x4(%rbp)
jmp 0x2b412
cmpl $0x1, -0x14(%rbp)
jne 0x2b328
movl $0x1, -0x4(%rbp)
jmp 0x2b412
movq -0x10(%rbp), %rdi
callq 0x2c0b0
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movb $0x1, %al
cmpl $0xc0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x2b360
movb $0x1, %al
cmpl $0xc1, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x2b360
cmpl $0xc2, -0x18(%rbp)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2b36b
jmp 0x2b3d8
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2c140
cmpl $0x0, %eax
jne 0x2b388
movl $0x0, -0x4(%rbp)
jmp 0x2b412
movq -0x10(%rbp), %rdi
callq 0x2c0b0
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0xff, -0x18(%rbp)
jne 0x2b3d3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2c540
cmpl $0x0, %eax
je 0x2b3c2
leaq 0x1cb5d(%rip), %rdi     # 0x47f15
callq 0x275b0
movl %eax, -0x4(%rbp)
jmp 0x2b412
movq -0x10(%rbp), %rdi
callq 0x2c0b0
movzbl %al, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b397
jmp 0x2b337
cmpl $0xc2, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4730(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2c5c0
cmpl $0x0, %eax
jne 0x2b40b
movl $0x0, -0x4(%rbp)
jmp 0x2b412
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__resample_row_hv_2(unsigned char*, unsigned char*, unsigned char*, int, int)
static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
   // need to generate 2x2 samples for every one in input
   int i,t0,t1;
   if (w == 1) {
      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
      return out;
   }

   t1 = 3*in_near[0] + in_far[0];
   out[0] = stbi__div4(t1+2);
   for (i=1; i < w; ++i) {
      t0 = t1;
      t1 = 3*in_near[i]+in_far[i];
      out[i*2-1] = stbi__div16(3*t0 + t1 + 8);
      out[i*2  ] = stbi__div16(3*t1 + t0 + 8);
   }
   out[w*2-1] = stbi__div4(t1+2);

   STBI_NOTUSED(hs);

   return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x2bf92
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
imull $0x3, %eax, %eax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c05d
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
imull $0x3, %eax, %eax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x2c038
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
imull $0x3, %eax, %eax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x34(%rbp)
imull $0x3, -0x30(%rbp), %eax
addl -0x34(%rbp), %eax
addl $0x8, %eax
sarl $0x4, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
imull $0x3, -0x34(%rbp), %eax
addl -0x30(%rbp), %eax
addl $0x8, %eax
sarl $0x4, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2bfc0
movl -0x34(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
shll %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__clamp(int)
stbi_inline static stbi_uc stbi__clamp(int x)
{
   // trick to use a single test to catch both cases
   if ((unsigned int) x > 255) {
      if (x < 0) return 0;
      if (x > 255) return 255;
   }
   return (stbi_uc) x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xff, -0x8(%rbp)
jbe 0x2c09d
cmpl $0x0, -0x8(%rbp)
jge 0x2c08c
movb $0x0, -0x1(%rbp)
jmp 0x2c0a3
cmpl $0xff, -0x8(%rbp)
jle 0x2c09b
movb $-0x1, -0x1(%rbp)
jmp 0x2c0a3
jmp 0x2c09d
movl -0x8(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__get_marker(stbi__jpeg*)
static stbi_uc stbi__get_marker(stbi__jpeg *j)
{
   stbi_uc x;
   if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
   x = stbi__get8(j->s);
   if (x != 0xff) return STBI__MARKER_none;
   while (x == 0xff)
      x = stbi__get8(j->s);
   return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4728(%rax), %eax
cmpl $0xff, %eax
je 0x2c0ee
movq -0x10(%rbp), %rax
movb 0x4728(%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb $-0x1, 0x4728(%rax)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x2c132
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2ce50
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0xff, %eax
je 0x2c10e
movb $-0x1, -0x1(%rbp)
jmp 0x2c132
jmp 0x2c110
movzbl -0x11(%rbp), %eax
cmpl $0xff, %eax
jne 0x2c12c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2ce50
movb %al, -0x11(%rbp)
jmp 0x2c110
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__at_eof(stbi__context*)
stbi_inline static int stbi__at_eof(stbi__context *s)
{
   if (s->io.read) {
      if (!(s->io.eof)(s->io_user_data)) return 0;
      // if feof() is true, check if buffer = end
      // special case: we've only got the special 0 character at the end
      if (s->read_from_callbacks == 0) return 1;
   }

   return s->img_buffer >= s->img_buffer_end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2c58c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
jne 0x2c577
movl $0x0, -0x4(%rbp)
jmp 0x2c5ad
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x2c58a
movl $0x1, -0x4(%rbp)
jmp 0x2c5ad
jmp 0x2c58c
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xc0(%rcx), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: srajangarg[P]raytracer/src/core/stb_image.hpp
// Function: stbi__get8(stbi__context*)
stbi_inline static stbi_uc stbi__get8(stbi__context *s)
{
   if (s->img_buffer < s->img_buffer_end)
      return *s->img_buffer++;
   if (s->read_from_callbacks) {
      stbi__refill_buffer(s);
      return *s->img_buffer++;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xc0(%rcx), %rax
jae 0x2ce94
movq -0x10(%rbp), %rcx
movq 0xb8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0xb8(%rcx)
movb (%rax), %al
movb %al, -0x1(%rbp)
jmp 0x2cecb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x2cec7
movq -0x10(%rbp), %rdi
callq 0x2cee0
movq -0x10(%rbp), %rcx
movq 0xb8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0xb8(%rcx)
movb (%rax), %al
movb %al, -0x1(%rbp)
jmp 0x2cecb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)