LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x1dcf9(%rip), %rsi     # 0x20770
callq 0x2650
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2aa4
leaq 0x1dce5(%rip), %rdi     # 0x20773
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x2ad2
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x2890
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2200
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x12ef0
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: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x2b40
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 0x2e00
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x23573(%rip)     # 0x26340
je 0x2df1
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 0x3080
movq -0x38(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x30ec
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x87e0
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 0x30b6
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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)) {
      stbi__result_info ri;
      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
      if (hdr_data)
         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
      return hdr_data;
   }
   #endif
   data = stbi__load_and_postprocess_8bit(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 $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
callq 0x3400
cmpl $0x0, %eax
je 0x31d8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq -0x44(%rbp), %r9
callq 0xa760
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x31cb
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x1cfd0
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3260
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x2760
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3245
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x3224
movl -0x2c(%rbp), %eax
movl %eax, -0x64(%rbp)
jmp 0x322d
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movl -0x54(%rbp), %edx
movl -0x58(%rbp), %esi
movq -0x60(%rbp), %rdi
movl -0x64(%rbp), %ecx
callq 0x1d040
movq %rax, -0x8(%rbp)
jmp 0x3260
leaq 0x1d5f2(%rip), %rdi     # 0x2083e
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x1d479(%rip), %rsi     # 0x20770
callq 0x2650
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3324
leaq 0x1d465(%rip), %rdi     # 0x20773
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x3352
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x3360
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2200
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x1defb(%rip), %rsi     # 0x21312
callq 0x1e340
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbd40
cmpl $0x0, -0xc(%rbp)
jne 0x344a
movq -0x8(%rbp), %rdi
leaq 0x1dee5(%rip), %rsi     # 0x2131e
callq 0x1e340
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbd40
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x1d2f9(%rip), %rsi     # 0x20770
callq 0x2650
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34a3
movq -0x10(%rbp), %rdi
callq 0x34b0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2200
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x2030
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
callq 0x2730
leaq -0xf0(%rbp), %rdi
callq 0x3400
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2280
movl -0x14(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x36a0
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
jne 0x3610
movq $0x0, -0x8(%rbp)
jmp 0x3692
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 0x36c0
cmpl $0x0, %eax
je 0x367e
cmpq $0x0, -0x20(%rbp)
je 0x3671
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 0x3692
movq -0x1000(%rbp), %rdi
callq 0x22a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x1d1e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x36a0
movq %rax, -0x1030(%rbp)
cmpq $0x0, -0x1030(%rbp)
jne 0x37a4
movq $0x0, -0x8(%rbp)
jmp 0x3826
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 0x36c0
cmpl $0x0, %eax
je 0x3812
cmpq $0x0, -0x20(%rbp)
je 0x3805
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 0x3826
movq -0x1008(%rbp), %rdi
callq 0x22a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x36c0
cmpl $0x0, %eax
je 0x38ac
movq -0x1010(%rbp), %rax
movq -0x1008(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x38b3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x36a0
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
jne 0x38fe
movq $0x0, -0x8(%rbp)
jmp 0x3981
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 0x36c0
cmpl $0x0, %eax
je 0x396d
cmpq $0x0, -0x20(%rbp)
je 0x3960
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 0x3981
movq -0x1000(%rbp), %rdi
callq 0x22a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x36c0
cmpl $0x0, %eax
je 0x39fa
movq -0x1010(%rbp), %rax
movq -0x1008(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x3a01
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x1ccfd(%rip), %rsi     # 0x20770
callq 0x2650
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3a94
leaq 0x1cce9(%rip), %rdi     # 0x20773
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0x3abb
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x3ad0
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2200
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x2030
movq %rax, -0x108(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x2730
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x100(%rbp), %rdi
callq 0x3b50
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x108(%rbp), %rsi
xorl %edx, %edx
callq 0x2280
movl -0x24(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// 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 0x1e3b0
cmpl $0x0, %eax
je 0x3b8e
movl $0x1, -0x4(%rbp)
jmp 0x3cc1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1e410
cmpl $0x0, %eax
je 0x3bb4
movl $0x1, -0x4(%rbp)
jmp 0x3cc1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1e450
cmpl $0x0, %eax
je 0x3bda
movl $0x1, -0x4(%rbp)
jmp 0x3cc1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1e490
cmpl $0x0, %eax
je 0x3c00
movl $0x1, -0x4(%rbp)
jmp 0x3cc1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1e530
cmpl $0x0, %eax
je 0x3c26
movl $0x1, -0x4(%rbp)
jmp 0x3cc1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1e680
cmpl $0x0, %eax
je 0x3c49
movl $0x1, -0x4(%rbp)
jmp 0x3cc1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1c710
cmpl $0x0, %eax
je 0x3c6c
movl $0x1, -0x4(%rbp)
jmp 0x3cc1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1e890
cmpl $0x0, %eax
je 0x3c8f
movl $0x1, -0x4(%rbp)
jmp 0x3cc1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1eaa0
cmpl $0x0, %eax
je 0x3cb2
movl $0x1, -0x4(%rbp)
jmp 0x3cc1
leaq 0x1cb85(%rip), %rdi     # 0x2083e
callq 0x2680
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x1ca89(%rip), %rsi     # 0x20770
callq 0x2650
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3d08
leaq 0x1ca75(%rip), %rdi     # 0x20773
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0x3d23
movq -0x18(%rbp), %rdi
callq 0x3d30
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2200
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x2030
movq %rax, -0xf0(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x2730
leaq -0xe8(%rbp), %rdi
callq 0x3d90
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
xorl %edx, %edx
callq 0x2280
movl -0xc(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/png2tlg.cpp
// Function: SlideCompressor::SlideCompressor()
SlideCompressor::SlideCompressor()
{
	S = 0;
	for(int i = 0; i < SLIDE_N + SLIDE_M - 1; i++) Text[i] = 0;
	for(int i = 0; i < 256*256; i++)
		Map[i] = -1;
	for(int i = 0; i < SLIDE_N; i++)
		Chains[i].Prev = Chains[i].Next = -1;
	for(int i = SLIDE_N - 1; i >= 0; i--)
		AddMap(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x21e35(%rip), %rcx     # 0x25d70
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x92228(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x1110, -0xc(%rbp)     # imm = 0x1110
jge 0x3f74
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, 0x8(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3f53
movl $0x0, -0x10(%rbp)
cmpl $0x10000, -0x10(%rbp)   # imm = 0x10000
jge 0x3fa2
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl $0xffffffff, 0x1118(%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3f7b
movl $0x0, -0x14(%rbp)
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
jge 0x3fdf
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0xffffffff, 0x4111c(%rax,%rcx,8) # imm = 0xFFFFFFFF
movslq -0x14(%rbp), %rcx
movl $0xffffffff, 0x41118(%rax,%rcx,8) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3fa9
movl $0xfff, -0x18(%rbp)     # imm = 0xFFF
cmpl $0x0, -0x18(%rbp)
jl 0x4003
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x4010
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3fe6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/png2tlg.cpp
// Function: SlideCompressor::AddMap(int)
void SlideCompressor::AddMap(int p)
{
	int place = Text[p] + ((int)Text[(p + 1) & (SLIDE_N - 1)] << 8);

	if(Map[place] == -1)
	{
		// first insertion
		Map[place] = p;
	}
	else
	{
		// not first insertion
		int old = Map[place];
		Map[place] = p;
		Chains[old].Prev = p;
		Chains[p].Next = old;
		Chains[p].Prev = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0xc(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %ecx
movl -0xc(%rbp), %edx
addl $0x1, %edx
andl $0xfff, %edx            # imm = 0xFFF
movslq %edx, %rdx
movzbl 0x8(%rax,%rdx), %edx
shll $0x8, %edx
addl %edx, %ecx
movl %ecx, -0x10(%rbp)
movslq -0x10(%rbp), %rcx
cmpl $-0x1, 0x1118(%rax,%rcx,4)
jne 0x406a
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edx
movslq -0x10(%rbp), %rcx
movl %edx, 0x1118(%rax,%rcx,4)
jmp 0x40b5
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x1118(%rax,%rcx,4), %ecx
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %edx
movslq -0x10(%rbp), %rcx
movl %edx, 0x1118(%rax,%rcx,4)
movl -0xc(%rbp), %edx
movslq -0x14(%rbp), %rcx
movl %edx, 0x41118(%rax,%rcx,8)
movl -0x14(%rbp), %edx
movslq -0xc(%rbp), %rcx
movl %edx, 0x4111c(%rax,%rcx,8)
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x41118(%rax,%rcx,8) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/png2tlg.cpp
// Function: SlideCompressor::DeleteMap(int)
void SlideCompressor::DeleteMap(int p)
{
	int n;
	if((n = Chains[p].Next) != -1)
		Chains[n].Prev = Chains[p].Prev;

	if((n = Chains[p].Prev) != -1)
	{
		Chains[n].Next = Chains[p].Next;
	}
	else if(Chains[p].Next != -1)
	{
		int place = Text[p] + ((int)Text[(p + 1) & (SLIDE_N - 1)] << 8);
		Map[place] = Chains[p].Next;
	}
	else
	{
		int place = Text[p] + ((int)Text[(p + 1) & (SLIDE_N - 1)] << 8);
		Map[place] = -1;
	}

	Chains[p].Prev = -1;
	Chains[p].Next = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0xc(%rbp), %rcx
movl 0x4111c(%rax,%rcx,8), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, %eax
je 0x4310
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x41118(%rax,%rcx,8), %edx
movslq -0x10(%rbp), %rcx
movl %edx, 0x41118(%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x41118(%rax,%rcx,8), %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, %eax
je 0x4346
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x4111c(%rax,%rcx,8), %edx
movslq -0x10(%rbp), %rcx
movl %edx, 0x4111c(%rax,%rcx,8)
jmp 0x43d3
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $-0x1, 0x4111c(%rax,%rcx,8)
je 0x4399
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %ecx
movl -0xc(%rbp), %edx
addl $0x1, %edx
andl $0xfff, %edx            # imm = 0xFFF
movslq %edx, %rdx
movzbl 0x8(%rax,%rdx), %edx
shll $0x8, %edx
addl %edx, %ecx
movl %ecx, -0x14(%rbp)
movslq -0xc(%rbp), %rcx
movl 0x4111c(%rax,%rcx,8), %edx
movslq -0x14(%rbp), %rcx
movl %edx, 0x1118(%rax,%rcx,4)
jmp 0x43d1
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %ecx
movl -0xc(%rbp), %edx
addl $0x1, %edx
andl $0xfff, %edx            # imm = 0xFFF
movslq %edx, %rdx
movzbl 0x8(%rax,%rdx), %edx
shll $0x8, %edx
addl %edx, %ecx
movl %ecx, -0x18(%rbp)
movslq -0x18(%rbp), %rcx
movl $0xffffffff, 0x1118(%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x43d3
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x41118(%rax,%rcx,8) # imm = 0xFFFFFFFF
movslq -0xc(%rbp), %rcx
movl $0xffffffff, 0x4111c(%rax,%rcx,8) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/png2tlg.cpp
// Function: SlideCompressor::Store()
void SlideCompressor::Store()
{
	S2 = S;
	int i;
	for(i = 0; i < SLIDE_N + SLIDE_M - 1; i++)
		Text2[i] = Text[i];

	for(i = 0; i < 256*256; i++)
		Map2[i] = Map[i];

	for(i = 0; i < SLIDE_N; i++)
		Chains2[i] = Chains[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x92228(%rax), %ecx
movl %ecx, 0x9222c(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x1110, -0xc(%rbp)     # imm = 0x1110
jge 0x47ce
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb 0x8(%rax,%rcx), %dl
movslq -0xc(%rbp), %rcx
movb %dl, 0x49118(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x47a3
movl $0x0, -0xc(%rbp)
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jge 0x4803
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x1118(%rax,%rcx,4), %edx
movslq -0xc(%rbp), %rcx
movl %edx, 0x4a228(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x47d5
movl $0x0, -0xc(%rbp)
cmpl $0x1000, -0xc(%rbp)     # imm = 0x1000
jge 0x483a
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rdx
movslq -0xc(%rbp), %rcx
movq 0x41118(%rax,%rdx,8), %rdx
movq %rdx, 0x8a228(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x480a
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/png2tlg.cpp
// Function: SlideCompressor::Restore()
void SlideCompressor::Restore()
{
	S = S2;
	int i;
	for(i = 0; i < SLIDE_N + SLIDE_M - 1; i++)
		Text[i] = Text2[i];

	for(i = 0; i < 256*256; i++)
		Map[i] = Map2[i];

	for(i = 0; i < SLIDE_N; i++)
		Chains[i] = Chains2[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x9222c(%rax), %ecx
movl %ecx, 0x92228(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x1110, -0xc(%rbp)     # imm = 0x1110
jge 0x488e
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb 0x49118(%rax,%rcx), %dl
movslq -0xc(%rbp), %rcx
movb %dl, 0x8(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4863
movl $0x0, -0xc(%rbp)
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jge 0x48c3
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x4a228(%rax,%rcx,4), %edx
movslq -0xc(%rbp), %rcx
movl %edx, 0x1118(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4895
movl $0x0, -0xc(%rbp)
cmpl $0x1000, -0xc(%rbp)     # imm = 0x1000
jge 0x48fa
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rdx
movslq -0xc(%rbp), %rcx
movq 0x8a228(%rax,%rdx,8), %rdx
movq %rdx, 0x41118(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x48ca
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/png2tlg.cpp
// Function: TVPTLG6InitGolombTable()
void TVPTLG6InitGolombTable()
{
	if(TVPTLG6GolombTableInit) return;
	for(int n = 0; n < TVP_TLG6_GOLOMB_N_COUNT; n++)
	{
		int a = 0;
		for(int i = 0; i < 9; i++)
		{
			for(int j = 0; j < TVPTLG6GolombCompressed[n][i]; j++)
				TVPTLG6GolombBitLengthTable[a++][n] = (char)i;
		}
		if(a != TVP_TLG6_GOLOMB_N_COUNT*2*128)
			*(char*)0 = 0;   // THIS MUST NOT BE EXECUETED!
				// (this is for compressed table data check)
	}
	TVPTLG6GolombTableInit = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x1, 0x22a45(%rip)     # 0x27350
je 0x4912
jmp 0x49c4
movl $0x0, -0x4(%rbp)
cmpl $0x4, -0x4(%rbp)
jge 0x49bd
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0x499f
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movslq -0x4(%rbp), %rdx
leaq 0x218f4(%rip), %rcx     # 0x26240
imulq $0x12, %rdx, %rdx
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
movswl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jge 0x4992
movl -0xc(%rbp), %eax
movb %al, %dl
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x8(%rbp)
movslq %eax, %rcx
leaq 0x219d7(%rip), %rax     # 0x26350
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x493e
jmp 0x4994
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4931
cmpl $0x400, -0x8(%rbp)      # imm = 0x400
je 0x49ad
xorl %eax, %eax
movb $0x0, (%rax)
jmp 0x49af
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4919
movb $0x1, 0x2298c(%rip)     # 0x27350
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/png2tlg.cpp
// Function: WriteInt32(long, std::ostream*)
static void WriteInt32(long num, std::ostream *out)
{
	char buf[4];
	buf[0] = num & 0xff;
	buf[1] = (num >> 8) & 0xff;
	buf[2] = (num >> 16) & 0xff;
	buf[3] = (num >> 24) & 0xff;
	out->write(buf, 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
andq $0xff, %rax
movb %al, -0x14(%rbp)
movq -0x8(%rbp), %rax
sarq $0x8, %rax
andq $0xff, %rax
movb %al, -0x13(%rbp)
movq -0x8(%rbp), %rax
sarq $0x10, %rax
andq $0xff, %rax
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
sarq $0x18, %rax
andq $0xff, %rax
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
callq 0x22d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/png2tlg.cpp
// Function: TLG6InitializeColorFilterCompressor(SlideCompressor&)
static void TLG6InitializeColorFilterCompressor(SlideCompressor &c)
{
	unsigned char code[4096];
	unsigned char dum[4096];
	unsigned char *p = code;
	for(int i = 0; i < 32; i++)
	{
		for(int j = 0; j < 16; j++)
		{
			p[0] = p[1] = p[2] = p[3] = i;
			p += 4;
			p[0] = p[1] = p[2] = p[3] = j;
			p += 4;
		}
	}

	long dumlen;
	c.Encode(code, 4096, dum, dumlen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, -0x8(%rbp)
leaq -0x1010(%rbp), %rax
movq %rax, -0x2018(%rbp)
movl $0x0, -0x201c(%rbp)
cmpl $0x20, -0x201c(%rbp)
jge 0x81f7
movl $0x0, -0x2020(%rbp)
cmpl $0x10, -0x2020(%rbp)
jge 0x81e1
movl -0x201c(%rbp), %eax
movb %al, %cl
movq -0x2018(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x2018(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x2018(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x2018(%rbp), %rax
movb %cl, (%rax)
movq -0x2018(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x2018(%rbp)
movl -0x2020(%rbp), %eax
movb %al, %cl
movq -0x2018(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x2018(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x2018(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x2018(%rbp), %rax
movb %cl, (%rax)
movq -0x2018(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x2018(%rbp)
movl -0x2020(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2020(%rbp)
jmp 0x813e
jmp 0x81e3
movl -0x201c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x201c(%rbp)
jmp 0x8127
movq -0x8(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
leaq -0x2010(%rbp), %rcx
movl $0x1000, %edx           # imm = 0x1000
leaq -0x2028(%rbp), %r8
callq 0x4400
addq $0x2030, %rsp           # imm = 0x2030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/png2tlg.cpp
// Function: main
int main(int argc, char *argv[])
{
	if (argc != 3) {
		std::cerr << "usage: " << argv[0] << " input output" << std::endl;
		return 1;
	}
	tTVPBaseBitmap bmp(argv[1]);
	std::fstream fs(argv[2], std::fstream::out | std::fstream::binary);
	SaveTLG6( &fs, &bmp, false );
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x829b
movq 0x1dd92(%rip), %rdi     # 0x25fe8
leaq 0x18549(%rip), %rsi     # 0x207a6
callq 0x21f0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x21f0
movq %rax, %rdi
leaq 0x18533(%rip), %rsi     # 0x207ae
callq 0x21f0
movq %rax, %rdi
movq 0x1dd2e(%rip), %rsi     # 0x25fb8
callq 0x2230
movl $0x1, -0x4(%rbp)
jmp 0x83ee
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x280(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x278(%rbp)
callq 0x23f0
movq -0x280(%rbp), %rsi
movq -0x278(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x1f6d0
jmp 0x82d3
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1f780
jmp 0x82e2
leaq -0x48(%rbp), %rdi
callq 0x2130
leaq -0x49(%rbp), %rdi
callq 0x2250
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x290(%rbp)
movl $0x10, %edi
movl $0x4, %esi
callq 0x1f8a0
movl %eax, -0x284(%rbp)
jmp 0x831a
movl -0x284(%rbp), %edx
movq -0x290(%rbp), %rsi
leaq -0x270(%rbp), %rdi
callq 0x22f0
jmp 0x8335
xorl %eax, %eax
leaq -0x270(%rbp), %rcx
cmpq $0x0, %rcx
movq %rax, -0x298(%rbp)
je 0x835d
leaq -0x270(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x298(%rbp)
movq -0x298(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x6ce0
jmp 0x8371
movl $0x0, -0x4(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x2070
leaq -0x28(%rbp), %rdi
callq 0x1f8c0
jmp 0x83ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x83b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2130
leaq -0x49(%rbp), %rdi
callq 0x2250
jmp 0x83fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x83e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x2070
leaq -0x28(%rbp), %rdi
callq 0x1f8c0
jmp 0x83fa
movl -0x4(%rbp), %eax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x36a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x8784
leaq 0x181d0(%rip), %rdi     # 0x2093e
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x87d0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x87bf
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 0x878b
movq -0x10(%rbp), %rdi
callq 0x22a0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x895d
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 0x894d
cmpq $0x800, -0x840(%rbp) # imm = 0x800
jae 0x889c
movq -0x840(%rbp), %rax
movq %rax, -0x850(%rbp)
jmp 0x88aa
movl $0x800, %eax            # imm = 0x800
movq %rax, -0x850(%rbp)
jmp 0x88aa
movq -0x850(%rbp), %rax
movq %rax, -0x848(%rbp)
leaq -0x820(%rbp), %rdi
movq -0x830(%rbp), %rsi
movq -0x848(%rbp), %rdx
callq 0x21b0
movq -0x830(%rbp), %rdi
movq -0x838(%rbp), %rsi
movq -0x848(%rbp), %rdx
callq 0x21b0
movq -0x838(%rbp), %rdi
leaq -0x820(%rbp), %rsi
movq -0x848(%rbp), %rdx
callq 0x21b0
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 0x8871
jmp 0x894f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x881a
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x36a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0xbb40
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xbbd0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbd40
movq -0x18(%rbp), %rdi
callq 0x22a0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x36a0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rdi
callq 0xbb40
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x13790
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
callq 0x22a0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)