LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__load_and_postprocess_8bit(stbi__context*, int*, int*, int*, int)
static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   stbi__result_info ri;
   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);

   if (result == NULL)
      return NULL;

   if (ri.bits_per_channel != 8) {
      STBI_ASSERT(ri.bits_per_channel == 16);
      result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
      ri.bits_per_channel = 8;
   }

   // @TODO: move stbi__convert_format to here

   if (stbi__vertically_flip_on_load) {
      int channels = req_comp ? req_comp : *comp;
      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));
   }

   return (unsigned char *) result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %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 -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq -0x38(%rbp), %r9
movl $0x8, (%rsp)
callq 0x5b330
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x56178
movq $0x0, -0x8(%rbp)
jmp 0x56240
cmpl $0x8, -0x38(%rbp)
je 0x561f3
cmpl $0x10, -0x38(%rbp)
jne 0x56186
jmp 0x561a5
leaq 0x2aded(%rip), %rdi     # 0x80f7a
leaq 0x2ae00(%rip), %rsi     # 0x80f94
movl $0x468, %edx            # imm = 0x468
leaq 0x2ae08(%rip), %rcx     # 0x80fa8
callq 0x7310
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x561d0
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x561d6
movl -0x2c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x48(%rbp), %edx
movl -0x4c(%rbp), %esi
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %ecx
callq 0x5b5d0
movq %rax, -0x40(%rbp)
movl $0x8, -0x38(%rbp)
cmpl $0x0, 0x5a936(%rip)     # 0xb0b30
je 0x56238
cmpl $0x0, -0x2c(%rbp)
je 0x5620a
movl -0x2c(%rbp), %eax
movl %eax, -0x60(%rbp)
jmp 0x56213
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movslq -0x44(%rbp), %rax
shlq $0x0, %rax
movl %eax, %ecx
callq 0x5b680
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__load_and_postprocess_16bit(stbi__context*, int*, int*, int*, int)
static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   stbi__result_info ri;
   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);

   if (result == NULL)
      return NULL;

   if (ri.bits_per_channel != 16) {
      STBI_ASSERT(ri.bits_per_channel == 8);
      result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);
      ri.bits_per_channel = 16;
   }

   // @TODO: move stbi__convert_format16 to here
   // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision

   if (stbi__vertically_flip_on_load) {
      int channels = req_comp ? req_comp : *comp;
      stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));
   }

   return (stbi__uint16 *) result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %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 -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq -0x38(%rbp), %r9
movl $0x10, (%rsp)
callq 0x5b330
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x56338
movq $0x0, -0x8(%rbp)
jmp 0x563ff
cmpl $0x10, -0x38(%rbp)
je 0x563b3
cmpl $0x8, -0x38(%rbp)
jne 0x56346
jmp 0x56365
leaq 0x2b564(%rip), %rdi     # 0x818b1
leaq 0x2ac40(%rip), %rsi     # 0x80f94
movl $0x480, %edx            # imm = 0x480
leaq 0x2b56a(%rip), %rcx     # 0x818ca
callq 0x7310
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x56390
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x56396
movl -0x2c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x48(%rbp), %edx
movl -0x4c(%rbp), %esi
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %ecx
callq 0x6fdb0
movq %rax, -0x40(%rbp)
movl $0x10, -0x38(%rbp)
cmpl $0x0, 0x5a776(%rip)     # 0xb0b30
je 0x563f7
cmpl $0x0, -0x2c(%rbp)
je 0x563ca
movl -0x2c(%rbp), %eax
movl %eax, -0x60(%rbp)
jmp 0x563d3
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movslq -0x44(%rbp), %rax
shlq %rax
movl %eax, %ecx
callq 0x5b680
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi_load_16
STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   FILE *f = stbi__fopen(filename, "rb");
   stbi__uint16 *result;
   if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
   result = stbi_load_from_file_16(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 0x2aa25(%rip), %rsi     # 0x80e5c
callq 0x56010
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x56464
leaq 0x2aa11(%rip), %rdi     # 0x80e5f
callq 0x56040
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x56492
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x56250
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x74f0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi_load_gif_from_memory
STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
{
   unsigned char *result;
   stbi__context s; 
   stbi__start_mem(&s,buffer,len); 
   
   result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
   if (stbi__vertically_flip_on_load) {
      stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); 
   }

   return result; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x110(%rbp), %rdi
callq 0x56500
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x10(%rbp), %r9
movl 0x18(%rbp), %eax
leaq -0x110(%rbp), %rdi
movl %eax, (%rsp)
callq 0x567c0
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x5a3a3(%rip)     # 0xb0b30
je 0x567b1
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
movq -0x28(%rbp), %rax
movl (%rax), %edx
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movq 0x10(%rbp), %rax
movl (%rax), %r8d
callq 0x56a40
movq -0x38(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__vertical_flip_slices(void*, int, int, int, int)
static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)
{
   int slice;
   int slice_size = w * h * bytes_per_pixel;

   stbi_uc *bytes = (stbi_uc *)image;
   for (slice = 0; slice < z; ++slice) {
      stbi__vertical_flip(bytes, w, h, bytes_per_pixel); 
      bytes += slice_size; 
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x56aac
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x5b680
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x56a76
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__hdr_test(stbi__context*)
static int stbi__hdr_test(stbi__context* s)
{
   int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
   stbi__rewind(s);
   if(!r) {
       r = stbi__hdr_test_core(s, "#?RGBE\n");
       stbi__rewind(s);
   }
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2acff(%rip), %rsi     # 0x81ad6
callq 0x711e0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5ebe0
cmpl $0x0, -0xc(%rbp)
jne 0x56e0a
movq -0x8(%rbp), %rdi
leaq 0x2ace9(%rip), %rsi     # 0x81ae2
callq 0x711e0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5ebe0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi_is_hdr_from_file
STBIDEF int stbi_is_hdr_from_file(FILE *f)
{
   #ifndef STBI_NO_HDR
   long pos = ftell(f);
   int res;
   stbi__context s;
   stbi__start_file(&s,f);
   res = stbi__hdr_test(&s);
   fseek(f, pos, SEEK_SET);
   return res;
   #else
   STBI_NOTUSED(f);
   return 0;
   #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7030
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
callq 0x560f0
leaq -0xf0(%rbp), %rdi
callq 0x56dc0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x75a0
movl -0x14(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi_is_16_bit
STBIDEF int stbi_is_16_bit(char const *filename)
{
    FILE *f = stbi__fopen(filename, "rb");
    int result;
    if (!f) return stbi__err("can't fopen", "Unable to open file");
    result = stbi_is_16_bit_from_file(f);
    fclose(f);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x297b5(%rip), %rsi     # 0x80e5c
callq 0x56010
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x576c8
leaq 0x297a1(%rip), %rdi     # 0x80e5f
callq 0x56040
movl %eax, -0x4(%rbp)
jmp 0x576e3
movq -0x18(%rbp), %rdi
callq 0x576f0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x74f0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi_is_16_bit_from_file
STBIDEF int stbi_is_16_bit_from_file(FILE *f)
{
   int r;
   stbi__context s;
   long pos = ftell(f);
   stbi__start_file(&s, f);
   r = stbi__is_16_main(&s);
   fseek(f,pos,SEEK_SET);
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7030
movq %rax, -0xf0(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x560f0
leaq -0xe8(%rbp), %rdi
callq 0x57750
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
xorl %edx, %edx
callq 0x75a0
movl -0xc(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/stb_image_write.h
// Function: stbi_write_hdr_core(stbi__write_context*, int, int, int, float*)
static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
{
   if (y <= 0 || x <= 0 || data == NULL)
      return 0;
   else {
      // Each component is stored separately. Allocate scratch space for full output scanline.
      unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
      int i, len;
      char buffer[128];
      char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
      s->func(s->context, header, sizeof(header)-1);

#ifdef __STDC_WANT_SECURE_LIB__
      len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
#else
      len = sprintf(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
#endif
      s->func(s->context, buffer, len);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x581cf
cmpl $0x0, -0x14(%rbp)
jle 0x581cf
cmpq $0x0, -0x28(%rbp)
jne 0x581db
movl $0x0, -0x4(%rbp)
jmp 0x5832f
movl -0x14(%rbp), %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x7650
movq %rax, -0x30(%rbp)
leaq -0x110(%rbp), %rdi
leaq 0x29ad5(%rip), %rsi     # 0x81cd0
movl $0x42, %edx
callq 0x7400
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x110(%rbp), %rsi
movl $0x41, %edx
callq *%rax
leaq -0xc0(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x29926(%rip), %rsi     # 0x81b5c
movb $0x0, %al
callq 0x7090
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0xc0(%rbp), %rsi
movl -0x38(%rbp), %edx
callq *%rax
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5831f
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x130(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x12c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x1c(%rbp), %eax
imull -0x14(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x0, 0x58887(%rip)     # 0xb0b3c
je 0x582c8
movl -0x18(%rbp), %eax
subl $0x1, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x13c(%rbp)
jmp 0x582d1
movl -0x34(%rbp), %eax
movl %eax, -0x13c(%rbp)
movq -0x128(%rbp), %rcx
movl -0x12c(%rbp), %edx
movl -0x130(%rbp), %esi
movq -0x138(%rbp), %rdi
movq -0x120(%rbp), %r8
movl -0x114(%rbp), %eax
movl -0x13c(%rbp), %r9d
imull %r9d, %eax
cltq
shlq $0x2, %rax
addq %rax, %r8
callq 0x725f0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x58262
movq -0x30(%rbp), %rdi
callq 0x75e0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image_write.h
// Function: stbi_write_png
STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
   FILE *f;
   int len;
   unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (png == NULL) return 0;

   f = stbiw__fopen(filename, "wb");
   if (!f) { STBIW_FREE(png); return 0; }
   fwrite(png, 1, len, f);
   fclose(f);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
leaq -0x3c(%rbp), %r9
callq 0x59240
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x59e7b
movl $0x0, -0x4(%rbp)
jmp 0x59ed7
movq -0x10(%rbp), %rdi
leaq 0x270cd(%rip), %rsi     # 0x80f53
callq 0x59ee0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x59ea8
movq -0x48(%rbp), %rdi
callq 0x75e0
movl $0x0, -0x4(%rbp)
jmp 0x59ed7
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
callq 0x7900
movq -0x38(%rbp), %rdi
callq 0x74f0
movq -0x48(%rbp), %rdi
callq 0x75e0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: alan0201tw[P]RayTracer/include/stb_image_write.h
// Function: stbi_write_jpg
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
      stbi__end_write_file(&s);
      return r;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x57b30
cmpl $0x0, %eax
je 0x5aa6d
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
leaq -0x40(%rbp), %rdi
callq 0x59ff0
movl %eax, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x57b80
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5aa74
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/src/main.cpp
// Function: main
int main()
{
    //srand48(int(time(nullptr)));

    {
        // since the destructor of ThreadPool joins all threads
        // I use a simple scope to wait for all works to be done
        ThreadPool pool(8);

        // Into the screen is negative z axis
        for(int j = image_height - 1; j >= 0; j--)
        {
            for(int i = 0; i < image_width; i++)
            {
                pool.enqueue(thread_entry, i, j);
            }
        }
    }
    
    stbi_flip_vertically_on_write(true);
    if(stbi_write_png("output.png", image_width, image_height, 3, image, 0) == 0)
    {
        std::cerr << "Error when saving image\n";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
leaq -0xd0(%rbp), %rdi
movl $0x8, %esi
callq 0x742d0
movl $0x31f, -0xd4(%rbp)     # imm = 0x31F
cmpl $0x0, -0xd4(%rbp)
jl 0x5b23d
movl $0x0, -0xd8(%rbp)
cmpl $0x320, -0xd8(%rbp)     # imm = 0x320
jge 0x5b227
leaq -0x3f7(%rip), %rdx      # 0x5add0
leaq -0xe8(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rcx
leaq -0xd4(%rbp), %r8
callq 0x743b0
jmp 0x5b1ea
leaq -0xe8(%rbp), %rdi
callq 0x745d0
movl -0xd8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd8(%rbp)
jmp 0x5b1b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x745f0
jmp 0x5b299
jmp 0x5b229
movl -0xd4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xd4(%rbp)
jmp 0x5b19d
leaq -0xd0(%rbp), %rdi
callq 0x745f0
movl $0x1, %edi
callq 0x578e0
leaq 0x25cfc(%rip), %rdi     # 0x80f56
movl $0x320, %edx            # imm = 0x320
movl $0x3, %ecx
leaq 0x55975(%rip), %r8      # 0xb0be0
xorl %r9d, %r9d
movl %edx, %esi
callq 0x59e30
cmpl $0x0, %eax
jne 0x5b28d
movq 0x54d5f(%rip), %rdi     # 0xaffe0
leaq 0x25cd9(%rip), %rsi     # 0x80f61
callq 0x74e0
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xf0(%rbp), %rdi
callq 0x7860
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__convert_16_to_8(unsigned short*, int, int, int)
static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
{
   int i;
   int img_len = w * h * channels;
   stbi_uc *reduced;

   reduced = (stbi_uc *) stbi__malloc(img_len);
   if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");

   for (i = 0; i < img_len; ++i)
      reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling

   STBI_FREE(orig);
   return reduced;
}

// 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
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
callq 0x57060
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5b624
leaq 0x25af4(%rip), %rdi     # 0x81102
callq 0x56040
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x5b670
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x5b65f
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5b62b
movq -0x10(%rbp), %rdi
callq 0x75e0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__vertical_flip(void*, int, int, int)
static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
{
   int row;
   size_t bytes_per_row = (size_t)w * bytes_per_pixel;
   stbi_uc temp[2048];
   stbi_uc *bytes = (stbi_uc *)image;

   for (row = 0; row < (h>>1); row++) {
      stbi_uc *row0 = bytes + row*bytes_per_row;
      stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;
      // swap row0 with row1
      size_t bytes_left = bytes_per_row;
      while (bytes_left) {
         size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);
         memcpy(temp, row0, bytes_copy);
         memcpy(row0, row1, bytes_copy);
         memcpy(row1, temp, bytes_copy);
         row0 += bytes_copy;
         row1 += bytes_copy;
         bytes_left -= bytes_copy;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movslq -0xc(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x828(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0x5b7fd
movq -0x828(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x830(%rbp)
movq -0x828(%rbp), %rax
movl -0x10(%rbp), %ecx
subl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x838(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x840(%rbp)
cmpq $0x0, -0x840(%rbp)
je 0x5b7ed
cmpq $0x800, -0x840(%rbp) # imm = 0x800
jae 0x5b73c
movq -0x840(%rbp), %rax
movq %rax, -0x850(%rbp)
jmp 0x5b74a
movl $0x800, %eax            # imm = 0x800
movq %rax, -0x850(%rbp)
jmp 0x5b74a
movq -0x850(%rbp), %rax
movq %rax, -0x848(%rbp)
leaq -0x820(%rbp), %rdi
movq -0x830(%rbp), %rsi
movq -0x848(%rbp), %rdx
callq 0x7400
movq -0x830(%rbp), %rdi
movq -0x838(%rbp), %rsi
movq -0x848(%rbp), %rdx
callq 0x7400
movq -0x838(%rbp), %rdi
leaq -0x820(%rbp), %rsi
movq -0x848(%rbp), %rdx
callq 0x7400
movq -0x848(%rbp), %rax
addq -0x830(%rbp), %rax
movq %rax, -0x830(%rbp)
movq -0x848(%rbp), %rax
addq -0x838(%rbp), %rax
movq %rax, -0x838(%rbp)
movq -0x848(%rbp), %rcx
movq -0x840(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x840(%rbp)
jmp 0x5b711
jmp 0x5b7ef
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5b6ba
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__jpeg_test(stbi__context*)
static int stbi__jpeg_test(stbi__context *s)
{
   int r;
   stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
   j->s = s;
   stbi__setup_jpeg(j);
   r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
   stbi__rewind(s);
   STBI_FREE(j);
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4888, %edi           # imm = 0x4888
callq 0x57060
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x5e9e0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5ea70
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5ebe0
movq -0x18(%rbp), %rdi
callq 0x75e0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__jpeg_load(stbi__context*, int*, int*, int*, int, stbi__result_info*)
static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
   unsigned char* result;
   stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));
   STBI_NOTUSED(ri);
   j->s = s;
   stbi__setup_jpeg(j);
   result = load_jpeg_image(j, x,y,comp,req_comp);
   STBI_FREE(j);
   return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x4888, %edi           # imm = 0x4888
callq 0x57060
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rdi
callq 0x5e9e0
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x66630
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x75e0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__gif_load(stbi__context*, int*, int*, int*, int, stbi__result_info*)
static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
   stbi_uc *u = 0;
   stbi__gif g;
   memset(&g, 0, sizeof(g));
   STBI_NOTUSED(ri);

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

      // moved conversion to after successful load so that the same
      // can be done for multiple frames. 
      if (req_comp && req_comp != 4)
         u = stbi__convert_format(u, 4, req_comp, g.w, g.h);
   } else if (g.out) {
      // if there was an error and we allocated an image buffer, free it!
      STBI_FREE(g.out);
   }

   // free buffers needed for multiple frame loading; 
   STBI_FREE(g.history);
   STBI_FREE(g.background); 

   return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x88b0, %rsp           # imm = 0x88B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x88a8(%rbp), %rdi
xorl %esi, %esi
movl $0x8870, %edx           # imm = 0x8870
callq 0x7290
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x88a8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
callq 0x6ddc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x5c8a0
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x5c8ef
movl -0x88a8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x88a4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x24(%rbp)
je 0x5c8ed
cmpl $0x4, -0x24(%rbp)
je 0x5c8ed
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x88a8(%rbp), %ecx
movl -0x88a4(%rbp), %r8d
movl $0x4, %esi
callq 0x6a860
movq %rax, -0x38(%rbp)
jmp 0x5c907
cmpq $0x0, -0x88a0(%rbp)
je 0x5c905
movq -0x88a0(%rbp), %rdi
callq 0x75e0
jmp 0x5c907
movq -0x8890(%rbp), %rdi
callq 0x75e0
movq -0x8898(%rbp), %rdi
callq 0x75e0
movq -0x38(%rbp), %rax
addq $0x88b0, %rsp           # imm = 0x88B0
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__pnm_load(stbi__context*, int*, int*, int*, int, stbi__result_info*)
static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
   stbi_uc *out;
   STBI_NOTUSED(ri);

   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;
   if (comp) *comp = s->img_n;

   if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0))
      return stbi__errpuc("too large", "PNM too large");

   out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0);
   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 %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
callq 0x6f5b0
cmpl $0x0, %eax
jne 0x5d4cf
movq $0x0, -0x8(%rbp)
jmp 0x5d5f4
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)
cmpq $0x0, -0x28(%rbp)
je 0x5d4fc
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
xorl %ecx, %ecx
callq 0x662a0
cmpl $0x0, %eax
jne 0x5d53c
leaq 0x23bd5(%rip), %rdi     # 0x810f8
callq 0x56040
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x5d5f4
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
xorl %ecx, %ecx
callq 0x664e0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x5d57f
leaq 0x23b99(%rip), %rdi     # 0x81102
callq 0x56040
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x5d5f4
movq -0x10(%rbp), %rdi
movq -0x40(%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 0x6b450
cmpl $0x0, -0x2c(%rbp)
je 0x5d5ec
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x5d5ec
movq -0x40(%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 0x6a860
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x5d5ea
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5d5f4
jmp 0x5d5ec
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__setup_jpeg(stbi__jpeg*)
static void stbi__setup_jpeg(stbi__jpeg *j)
{
   j->idct_block_kernel = stbi__idct_block;
   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;

#ifdef STBI_SSE2
   if (stbi__sse2_available()) {
      j->idct_block_kernel = stbi__idct_simd;
      j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
      j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
   }
#endif

#ifdef STBI_NEON
   j->idct_block_kernel = stbi__idct_simd;
   j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;
   j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x229(%rip), %rcx       # 0x5ec20
movq %rcx, 0x4870(%rax)
movq -0x8(%rbp), %rax
leaq 0xb77(%rip), %rcx       # 0x5f580
movq %rcx, 0x4878(%rax)
movq -0x8(%rbp), %rax
leaq 0xce5(%rip), %rcx       # 0x5f700
movq %rcx, 0x4880(%rax)
callq 0x5f830
cmpl $0x0, %eax
je 0x5ea62
movq -0x8(%rbp), %rax
leaq 0xe09(%rip), %rcx       # 0x5f840
movq %rcx, 0x4870(%rax)
movq -0x8(%rbp), %rax
leaq 0x4c07(%rip), %rcx      # 0x63650
movq %rcx, 0x4878(%rax)
movq -0x8(%rbp), %rax
leaq 0x5a95(%rip), %rcx      # 0x644f0
movq %rcx, 0x4880(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__decode_jpeg_header(stbi__jpeg*, int)
static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)
{
   int m;
   z->jfif = 0;
   z->app14_color_transform = -1; // valid values are 0,1,2
   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
movl $0x0, 0x4848(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x484c(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movb $-0x1, 0x4828(%rax)
movq -0x10(%rbp), %rdi
callq 0x64cf0
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0xd8, -0x18(%rbp)
je 0x5ead2
leaq 0x22550(%rip), %rdi     # 0x81015
callq 0x56040
movl %eax, -0x4(%rbp)
jmp 0x5ebce
cmpl $0x1, -0x14(%rbp)
jne 0x5eae4
movl $0x1, -0x4(%rbp)
jmp 0x5ebce
movq -0x10(%rbp), %rdi
callq 0x64cf0
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movb $0x1, %al
cmpl $0xc0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x5eb1c
movb $0x1, %al
cmpl $0xc1, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x5eb1c
cmpl $0xc2, -0x18(%rbp)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5eb27
jmp 0x5eb94
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x64d80
cmpl $0x0, %eax
jne 0x5eb44
movl $0x0, -0x4(%rbp)
jmp 0x5ebce
movq -0x10(%rbp), %rdi
callq 0x64cf0
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0xff, -0x18(%rbp)
jne 0x5eb8f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x653d0
cmpl $0x0, %eax
je 0x5eb7e
leaq 0x224a8(%rip), %rdi     # 0x8101c
callq 0x56040
movl %eax, -0x4(%rbp)
jmp 0x5ebce
movq -0x10(%rbp), %rdi
callq 0x64cf0
movzbl %al, %eax
movl %eax, -0x18(%rbp)
jmp 0x5eb53
jmp 0x5eaf3
cmpl $0xc2, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4830(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x65450
cmpl $0x0, %eax
jne 0x5ebc7
movl $0x0, -0x4(%rbp)
jmp 0x5ebce
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__free_jpeg_components(stbi__jpeg*, int, int)
static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
{
   int i;
   for (i=0; i < ncomp; ++i) {
      if (z->img_comp[i].raw_data) {
         STBI_FREE(z->img_comp[i].raw_data);
         z->img_comp[i].raw_data = NULL;
         z->img_comp[i].data = NULL;
      }
      if (z->img_comp[i].raw_coeff) {
         STBI_FREE(z->img_comp[i].raw_coeff);
         z->img_comp[i].raw_coeff = 0;
         z->img_comp[i].coeff = 0;
      }
      if (z->img_comp[i].linebuf) {
         STBI_FREE(z->img_comp[i].linebuf);
         z->img_comp[i].linebuf = NULL;
      }
   }
   return why;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x664d4
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x38(%rax)
je 0x663f9
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rdi
callq 0x75e0
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x40(%rax)
je 0x6646d
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rdi
callq 0x75e0
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x48(%rax)
je 0x664c4
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0x75e0
movq -0x8(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x14(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x48(%rax)
jmp 0x664c6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x66379
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__grow_buffer_unsafe(stbi__jpeg*)
static void stbi__grow_buffer_unsafe(stbi__jpeg *j)
{
   do {
      unsigned int b = j->nomore ? 0 : stbi__get8(j->s);
      if (b == 0xff) {
         int c = stbi__get8(j->s);
         while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes
         if (c != 0) {
            j->marker = (unsigned char) c;
            j->nomore = 1;
            return;
         }
      }
      j->code_buffer |= b << (24 - j->code_bits);
      j->code_bits += 8;
   } while (j->code_bits <= 24);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x482c(%rax)
je 0x68cd0
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x68ce2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x65d00
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0xff, -0xc(%rbp)
jne 0x68d47
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x65d00
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0xff, -0x10(%rbp)
jne 0x68d20
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x65d00
movzbl %al, %eax
movl %eax, -0x10(%rbp)
jmp 0x68d03
cmpl $0x0, -0x10(%rbp)
je 0x68d45
movl -0x10(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4828(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x482c(%rax)
jmp 0x68d91
jmp 0x68d47
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rdx
movl $0x18, %ecx
subl 0x4824(%rdx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
orl 0x4820(%rax), %ecx
movl %ecx, 0x4820(%rax)
movq -0x8(%rbp), %rax
movl 0x4824(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x4824(%rax)
movq -0x8(%rbp), %rax
cmpl $0x18, 0x4824(%rax)
jle 0x68cbc
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__compute_transparency16(stbi__png*, unsigned short*, int)
static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
{
   stbi__context *s = z->s;
   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
   stbi__uint16 *p = (stbi__uint16*) z->out;

   // compute color-based transparency, assuming we've
   // already got 65535 as the alpha value in the output
   STBI_ASSERT(out_n == 2 || out_n == 4);

   if (out_n == 2) {
      for (i = 0; i < pixel_count; ++i) {
         p[1] = (p[0] == tc[0] ? 0 : 65535);
         p += 2;
      }
   } else {
      for (i = 0; i < pixel_count; ++i) {
         if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])
            p[3] = 0;
         p += 4;
      }
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
imull 0x4(%rcx), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movb $0x1, %al
cmpl $0x2, -0x14(%rbp)
movb %al, -0x31(%rbp)
je 0x6b9a0
cmpl $0x4, -0x14(%rbp)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x6b9a9
jmp 0x6b9ab
jmp 0x6b9ca
leaq 0x15acc(%rip), %rdi     # 0x8147e
leaq 0x155db(%rip), %rsi     # 0x80f94
movl $0x124d, %edx           # imm = 0x124D
leaq 0x15ad2(%rip), %rcx     # 0x81497
callq 0x7310
cmpl $0x2, -0x14(%rbp)
jne 0x6ba1d
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x6ba1b
movq -0x30(%rbp), %rax
movzwl (%rax), %edx
movq -0x10(%rbp), %rax
movzwl (%rax), %esi
movl $0xffff, %eax           # imm = 0xFFFF
xorl %ecx, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6b9d7
jmp 0x6ba89
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x6ba87
movq -0x30(%rbp), %rax
movzwl (%rax), %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x6ba70
movq -0x30(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6ba70
movq -0x30(%rbp), %rax
movzwl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6ba70
movq -0x30(%rbp), %rax
movw $0x0, 0x6(%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6ba24
jmp 0x6ba89
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__high_bit(unsigned int)
static int stbi__high_bit(unsigned int z)
{
   int n=0;
   if (z == 0) return -1;
   if (z >= 0x10000) { n += 16; z >>= 16; }
   if (z >= 0x00100) { n +=  8; z >>=  8; }
   if (z >= 0x00010) { n +=  4; z >>=  4; }
   if (z >= 0x00004) { n +=  2; z >>=  2; }
   if (z >= 0x00002) { n +=  1; z >>=  1; }
   return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x6db10
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6db93
cmpl $0x10000, -0x8(%rbp)    # imm = 0x10000
jb 0x6db2b
movl -0xc(%rbp), %eax
addl $0x10, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jb 0x6db46
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x8(%rbp)
cmpl $0x10, -0x8(%rbp)
jb 0x6db5e
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jb 0x6db76
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
jb 0x6db8d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__shiftsigned(unsigned int, int, int)
static int stbi__shiftsigned(unsigned int v, int shift, int bits)
{
   static unsigned int mul_table[9] = {
      0,
      0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
      0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
   };
   static unsigned int shift_table[9] = {
      0, 0,0,1,0,2,4,6,0,
   };
   if (shift < 0)
      v <<= -shift;
   else
      v >>= shift;
   STBI_ASSERT(v >= 0 && v < 256);
   v >>= (8-bits);
   STBI_ASSERT(bits >= 0 && bits <= 8);
   return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x6dc46
xorl %ecx, %ecx
subl -0x8(%rbp), %ecx
movl -0x4(%rbp), %eax
shll %cl, %eax
movl %eax, -0x4(%rbp)
jmp 0x6dc51
movl -0x8(%rbp), %ecx
movl -0x4(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0xd(%rbp)
jb 0x6dc69
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
setb %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x6dc72
jmp 0x6dc74
jmp 0x6dc93
leaq 0x139e2(%rip), %rdi     # 0x8165d
leaq 0x13312(%rip), %rsi     # 0x80f94
movl $0x13f9, %edx           # imm = 0x13F9
leaq 0x139e1(%rip), %rcx     # 0x8166f
callq 0x7310
movl $0x8, %ecx
subl -0xc(%rbp), %ecx
movl -0x4(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xe(%rbp)
jl 0x6dcb8
cmpl $0x8, -0xc(%rbp)
setle %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
testb $0x1, %al
jne 0x6dcc1
jmp 0x6dcc3
jmp 0x6dce2
leaq 0x139d3(%rip), %rdi     # 0x8169d
leaq 0x132c3(%rip), %rsi     # 0x80f94
movl $0x13fb, %edx           # imm = 0x13FB
leaq 0x13992(%rip), %rcx     # 0x8166f
callq 0x7310
movl -0x4(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x42900(%rip), %rcx     # 0xb05f0
imull (%rcx,%rdx,4), %eax
movslq -0xc(%rbp), %rdx
leaq 0x42921(%rip), %rcx     # 0xb0620
movl (%rcx,%rdx,4), %ecx
sarl %cl, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alan0201tw[P]RayTracer/include/stb_image.h
// Function: stbi__psd_decode_rle(stbi__context*, unsigned char*, int)
static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
{
   int count, nleft, len;

   count = 0;
   while ((nleft = pixelCount - count) > 0) {
      len = stbi__get8(s);
      if (len == 128) {
         // No-op.
      } else if (len < 128) {
         // Copy next len+1 bytes literally.
         len++;
         if (len > nleft) return 0; // corrupt data
         count += len;
         while (len) {
            *p = stbi__get8(s);
            p += 4;
            len--;
         }
      } else if (len > 128) {
         stbi_uc   val;
         // Next -len+1 bytes in the dest are replicated from next source byte.
         // (Interpret len as a negative 8-bit int.)
         len = 257 - len;
         if (len > nleft) return 0; // corrupt data
         val = stbi__get8(s);
         count += len;
         while (len) {
            *p = val;
            p += 4;
            len--;
         }
      }
   }

   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x6ee33
movq -0x10(%rbp), %rdi
callq 0x65d00
movzbl %al, %eax
movl %eax, -0x28(%rbp)
cmpl $0x80, -0x28(%rbp)
jne 0x6ed69
jmp 0x6ee2e
cmpl $0x80, -0x28(%rbp)
jge 0x6edc8
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x6ed8f
movl $0x0, -0x4(%rbp)
jmp 0x6ee3a
movl -0x28(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x6edc6
movq -0x10(%rbp), %rdi
callq 0x65d00
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6ed98
jmp 0x6ee2c
cmpl $0x80, -0x28(%rbp)
jle 0x6ee2a
movl $0x101, %eax            # imm = 0x101
subl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x6eded
movl $0x0, -0x4(%rbp)
jmp 0x6ee3a
movq -0x10(%rbp), %rdi
callq 0x65d00
movb %al, -0x29(%rbp)
movl -0x28(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x6ee28
movb -0x29(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6ee02
jmp 0x6ee2a
jmp 0x6ee2c
jmp 0x6ee2e
jmp 0x6ed3a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)