LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x2100
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x88a8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
callq 0x1af20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x9a00
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x9a4f
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 0x9a4d
cmpl $0x4, -0x24(%rbp)
je 0x9a4d
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x88a8(%rbp), %ecx
movl -0x88a4(%rbp), %r8d
movl $0x4, %esi
callq 0x179c0
movq %rax, -0x38(%rbp)
jmp 0x9a67
cmpq $0x0, -0x88a0(%rbp)
je 0x9a65
movq -0x88a0(%rbp), %rdi
callq 0x22a0
jmp 0x9a67
movq -0x8890(%rbp), %rdi
callq 0x22a0
movq -0x8898(%rbp), %rdi
callq 0x22a0
movq -0x38(%rbp), %rax
addq $0x88b0, %rsp           # imm = 0x88B0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__pnm_test(stbi__context*)
static int      stbi__pnm_test(stbi__context *s)
{
   char p, t;
   p = (char) stbi__get8(s);
   t = (char) stbi__get8(s);
   if (p != 'P' || (t != '5' && t != '6')) {
       stbi__rewind( s );
       return 0;
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movb %al, -0x12(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x50, %eax
jne 0xa5af
movsbl -0x12(%rbp), %eax
cmpl $0x35, %eax
je 0xa5c1
movsbl -0x12(%rbp), %eax
cmpl $0x36, %eax
je 0xa5c1
movq -0x10(%rbp), %rdi
callq 0xbd40
movl $0x0, -0x4(%rbp)
jmp 0xa5c8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
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__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 0x1c710
cmpl $0x0, %eax
jne 0xa62f
movq $0x0, -0x8(%rbp)
jmp 0xa754
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 0xa65c
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 0x13400
cmpl $0x0, %eax
jne 0xa69c
leaq 0x162b1(%rip), %rdi     # 0x20934
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0xa754
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 0x13640
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xa6df
leaq 0x16275(%rip), %rdi     # 0x2093e
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0xa754
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 0x185b0
cmpl $0x0, -0x2c(%rbp)
je 0xa74c
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xa74c
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 0x179c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xa74a
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa754
jmp 0xa74c
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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       # 0xbd80
movq %rcx, 0x4870(%rax)
movq -0x8(%rbp), %rax
leaq 0xb77(%rip), %rcx       # 0xc6e0
movq %rcx, 0x4878(%rax)
movq -0x8(%rbp), %rax
leaq 0xce5(%rip), %rcx       # 0xc860
movq %rcx, 0x4880(%rax)
callq 0xc990
cmpl $0x0, %eax
je 0xbbc2
movq -0x8(%rbp), %rax
leaq 0xe09(%rip), %rcx       # 0xc9a0
movq %rcx, 0x4870(%rax)
movq -0x8(%rbp), %rax
leaq 0x4c07(%rip), %rcx      # 0x107b0
movq %rcx, 0x4878(%rax)
movq -0x8(%rbp), %rax
leaq 0x5a95(%rip), %rcx      # 0x11650
movq %rcx, 0x4880(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x11e50
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0xd8, -0x18(%rbp)
je 0xbc32
leaq 0x14c2c(%rip), %rdi     # 0x20851
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0xbd2e
cmpl $0x1, -0x14(%rbp)
jne 0xbc44
movl $0x1, -0x4(%rbp)
jmp 0xbd2e
movq -0x10(%rbp), %rdi
callq 0x11e50
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movb $0x1, %al
cmpl $0xc0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0xbc7c
movb $0x1, %al
cmpl $0xc1, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0xbc7c
cmpl $0xc2, -0x18(%rbp)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xbc87
jmp 0xbcf4
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x11ee0
cmpl $0x0, %eax
jne 0xbca4
movl $0x0, -0x4(%rbp)
jmp 0xbd2e
movq -0x10(%rbp), %rdi
callq 0x11e50
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0xff, -0x18(%rbp)
jne 0xbcef
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12530
cmpl $0x0, %eax
je 0xbcde
leaq 0x14b84(%rip), %rdi     # 0x20858
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0xbd2e
movq -0x10(%rbp), %rdi
callq 0x11e50
movzbl %al, %eax
movl %eax, -0x18(%rbp)
jmp 0xbcb3
jmp 0xbc53
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 0x125b0
cmpl $0x0, %eax
jne 0xbd27
movl $0x0, -0x4(%rbp)
jmp 0xbd2e
movl $0x1, -0x4(%rbp)
movl -0x4(%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__resample_row_hv_2(unsigned char*, unsigned char*, unsigned char*, int, int)
static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
   // need to generate 2x2 samples for every one in input
   int i,t0,t1;
   if (w == 1) {
      out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
      return out;
   }

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

   STBI_NOTUSED(hs);

   return out;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xff, -0x8(%rbp)
jbe 0x11e3d
cmpl $0x0, -0x8(%rbp)
jge 0x11e2c
movb $0x0, -0x1(%rbp)
jmp 0x11e43
cmpl $0xff, -0x8(%rbp)
jle 0x11e3b
movb $-0x1, -0x1(%rbp)
jmp 0x11e43
jmp 0x11e3d
movl -0x8(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__get_marker(stbi__jpeg*)
static stbi_uc stbi__get_marker(stbi__jpeg *j)
{
   stbi_uc x;
   if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
   x = stbi__get8(j->s);
   if (x != 0xff) return STBI__MARKER_none;
   while (x == 0xff)
      x = stbi__get8(j->s); // consume repeated 0xff fill bytes
   return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4828(%rax), %eax
cmpl $0xff, %eax
je 0x11e8e
movq -0x10(%rbp), %rax
movb 0x4828(%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb $-0x1, 0x4828(%rax)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x11ed2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12e60
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0xff, %eax
je 0x11eae
movb $-0x1, -0x1(%rbp)
jmp 0x11ed2
jmp 0x11eb0
movzbl -0x11(%rbp), %eax
cmpl $0xff, %eax
jne 0x11ecc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x12e60
movb %al, -0x11(%rbp)
jmp 0x11eb0
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__at_eof(stbi__context*)
stbi_inline static int stbi__at_eof(stbi__context *s)
{
   if (s->io.read) {
      if (!(s->io.eof)(s->io_user_data)) return 0;
      // if feof() is true, check if buffer = end
      // special case: we've only got the special 0 character at the end
      if (s->read_from_callbacks == 0) return 1;
   }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1257c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
jne 0x12567
movl $0x0, -0x4(%rbp)
jmp 0x1259d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x1257a
movl $0x1, -0x4(%rbp)
jmp 0x1259d
jmp 0x1257c
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xc0(%rcx), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__get8(stbi__context*)
stbi_inline static stbi_uc stbi__get8(stbi__context *s)
{
   if (s->img_buffer < s->img_buffer_end)
      return *s->img_buffer++;
   if (s->read_from_callbacks) {
      stbi__refill_buffer(s);
      return *s->img_buffer++;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xc0(%rcx), %rax
jae 0x12ea4
movq -0x10(%rbp), %rcx
movq 0xb8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0xb8(%rcx)
movb (%rax), %al
movb %al, -0x1(%rbp)
jmp 0x12edb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x12ed7
movq -0x10(%rbp), %rdi
callq 0x12ef0
movq -0x10(%rbp), %rcx
movq 0xb8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0xb8(%rcx)
movb (%rax), %al
movb %al, -0x1(%rbp)
jmp 0x12edb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
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__refill_buffer(stbi__context*)
static void stbi__refill_buffer(stbi__context *s)
{
   int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
   if (n == 0) {
      // at end of file, treat same as if from memory, but need to handle case
      // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file
      s->read_from_callbacks = 0;
      s->img_buffer = s->buffer_start;
      s->img_buffer_end = s->buffer_start+1;
      *s->img_buffer = 0;
   } else {
      s->img_buffer = s->buffer_start;
      s->img_buffer_end = s->buffer_start + n;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
movq -0x8(%rbp), %rcx
movl 0x34(%rcx), %edx
callq *%rax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x12f6b
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rcx
addq $0x38, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x8(%rbp), %rcx
addq $0x38, %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc0(%rax)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movb $0x0, (%rax)
jmp 0x12f98
movq -0x8(%rbp), %rcx
addq $0x38, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x8(%rbp), %rcx
addq $0x38, %rcx
movslq -0xc(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__build_fast_ac(short*, stbi__huffman*)
static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)
{
   int i;
   for (i=0; i < (1 << FAST_BITS); ++i) {
      stbi_uc fast = h->fast[i];
      fast_ac[i] = 0;
      if (fast < 255) {
         int rs = h->values[fast];
         int run = (rs >> 4) & 15;
         int magbits = rs & 15;
         int len = h->size[fast];

         if (magbits && len + magbits <= FAST_BITS) {
            // magnitude code followed by receive_extend code
            int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
            int m = 1 << (magbits - 1);
            if (k < m) k += (~0U << magbits) + 1;
            // if the result is small enough, we can fit it in fast_ac table
            if (k >= -128 && k <= 127)
               fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));
         }
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x200, -0x14(%rbp)     # imm = 0x200
jge 0x13345
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movw $0x0, (%rax,%rcx,2)
movzbl -0x15(%rbp), %eax
cmpl $0xff, %eax
jge 0x13335
movq -0x10(%rbp), %rax
movzbl -0x15(%rbp), %ecx
movzbl 0x400(%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
sarl $0x4, %eax
andl $0xf, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x15(%rbp), %ecx
movzbl 0x500(%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x13333
movl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
cmpl $0x9, %eax
jg 0x13333
movl -0x14(%rbp), %eax
movl -0x28(%rbp), %ecx
shll %cl, %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl $0x9, %ecx
subl -0x24(%rbp), %ecx
sarl %cl, %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x13300
movl -0x24(%rbp), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
addl $0x1, %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $-0x80, -0x2c(%rbp)
jl 0x13331
cmpl $0x7f, -0x2c(%rbp)
jg 0x13331
movl -0x2c(%rbp), %eax
shll $0x8, %eax
movl -0x20(%rbp), %ecx
shll $0x4, %ecx
addl %ecx, %eax
movl -0x28(%rbp), %ecx
addl -0x24(%rbp), %ecx
addl %ecx, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x13333
jmp 0x13335
jmp 0x13337
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13233
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__skip(stbi__context*, int)
static void stbi__skip(stbi__context *s, int n)
{
   if (n < 0) {
      s->img_buffer = s->img_buffer_end;
      return;
   }
   if (s->io.read) {
      int blen = (int) (s->img_buffer_end - s->img_buffer);
      if (blen < n) {
         s->img_buffer = s->img_buffer_end;
         (s->io.skip)(s->io_user_data, n - blen);
         return;
      }
   }
   s->img_buffer += n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x1337d
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
jmp 0x133f9
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x133de
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb8(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x133dc
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rdi
movl -0xc(%rbp), %esi
subl -0x10(%rbp), %esi
callq *%rax
jmp 0x133f9
jmp 0x133de
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0xb8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x13634
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 0x13559
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 0x22a0
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 0x135cd
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 0x22a0
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 0x13624
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 0x22a0
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 0x13626
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x134d9
movl -0x10(%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__resample_row_v_2(unsigned char*, unsigned char*, unsigned char*, int, int)
static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
   // need to generate two samples vertically for every one in input
   int i;
   STBI_NOTUSED(hs);
   for (i=0; i < w; ++i)
      out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
   return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x147d1
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
imull $0x3, %eax, %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1478e
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int)
static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
   // resample with nearest-neighbor
   int i,j;
   STBI_NOTUSED(in_far);
   for (i=0; i < w; ++i)
      for (j=0; j < hs; ++j)
         out[i*hs+j] = in_near[i];
   return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x149cc
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x149bf
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
imull -0x20(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1498d
jmp 0x149c1
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1497e
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__jpeg_reset(stbi__jpeg*)
static void stbi__jpeg_reset(stbi__jpeg *j)
{
   j->code_bits = 0;
   j->code_buffer = 0;
   j->nomore = 0;
   j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;
   j->marker = STBI__MARKER_none;
   j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;
   j->eob_run = 0;
   // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,
   // since we don't even allow 1<<30 pixels
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4824(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4820(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x482c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x47d8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4778(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4718(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x46b8(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x4828(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4868(%rax)
je 0x15b61
movq -0x8(%rbp), %rax
movl 0x4868(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x15b6b
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, -0xc(%rbp)
jmp 0x15b6b
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x486c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4844(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./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 0x15e30
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x15e42
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0xff, -0xc(%rbp)
jne 0x15ea7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0xff, -0x10(%rbp)
jne 0x15e80
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x10(%rbp)
jmp 0x15e63
cmpl $0x0, -0x10(%rbp)
je 0x15ea5
movl -0x10(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4828(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x482c(%rax)
jmp 0x15ef1
jmp 0x15ea7
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 0x15e1c
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_decode_block_prog_dc(stbi__jpeg*, short*, stbi__huffman*, int)
static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)
{
   int diff,dc;
   int t;
   if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG");

   if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);

   if (j->succ_high == 0) {
      // first scan for DC coefficient, must be first
      memset(data,0,64*sizeof(data[0])); // 0 all the ac values now
      t = stbi__jpeg_huff_decode(j, hdc);
      diff = t ? stbi__extend_receive(j, t) : 0;

      dc = j->img_comp[b].dc_pred + diff;
      j->img_comp[b].dc_pred = dc;
      data[0] = (short) (dc << j->succ_low);
   } else {
      // refinement scan for DC coefficient
      if (stbi__jpeg_get_bit(j))
         data[0] += (short) (1 << j->succ_low);
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4838(%rax)
je 0x15f38
leaq 0xab90(%rip), %rdi      # 0x20abb
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0x1602e
movq -0x10(%rbp), %rax
cmpl $0x10, 0x4824(%rax)
jge 0x15f4e
movq -0x10(%rbp), %rdi
callq 0x15e10
movq -0x10(%rbp), %rax
cmpl $0x0, 0x483c(%rax)
jne 0x15ff7
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x2100
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16540
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x15f96
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x16770
movl %eax, -0x34(%rbp)
jmp 0x15f9d
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x15f9d
movl -0x34(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x24(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
addq $0x46a0, %rax           # imm = 0x46A0
movslq -0x24(%rbp), %rdx
imulq $0x60, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x4840(%rcx), %ecx
shll %cl, %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
jmp 0x16027
movq -0x10(%rbp), %rdi
callq 0x16880
cmpl $0x0, %eax
je 0x16025
movq -0x10(%rbp), %rax
movl 0x4840(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movswl %ax, %edx
movq -0x18(%rbp), %rax
movswl (%rax), %ecx
addl %edx, %ecx
movw %cx, (%rax)
jmp 0x16027
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__extend_receive(stbi__jpeg*, int)
stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
{
   unsigned int k;
   int sgn;
   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);

   sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB
   k = stbi_lrot(j->code_buffer, n);
   STBI_ASSERT(n >= 0 && n < (int) (sizeof(stbi__bmask)/sizeof(*stbi__bmask)));
   j->code_buffer = k & ~stbi__bmask[n];
   k &= stbi__bmask[n];
   j->code_bits -= n;
   return k + (stbi__jbias[n] & ~sgn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4824(%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x16797
movq -0x8(%rbp), %rdi
callq 0x15e10
movq -0x8(%rbp), %rax
movl 0x4820(%rax), %eax
sarl $0x1f, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x4820(%rax), %eax
movl -0xc(%rbp), %ecx
shll %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x4820(%rcx), %edx
movl $0x20, %ecx
subl -0xc(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x15(%rbp)
jl 0x167e6
cmpl $0x11, -0xc(%rbp)
setl %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x167ef
jmp 0x167f1
jmp 0x16810
leaq 0xa258(%rip), %rdi      # 0x20a50
leaq 0x9fd7(%rip), %rsi      # 0x207d6
movl $0x7b5, %edx            # imm = 0x7B5
leaq 0xa284(%rip), %rcx      # 0x20a8f
callq 0x2140
movl -0x10(%rbp), %ecx
movslq -0xc(%rbp), %rdx
leaq 0x9ac2(%rip), %rax      # 0x202e0
movl (%rax,%rdx,4), %eax
xorl $-0x1, %eax
andl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4820(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x9aa5(%rip), %rax      # 0x202e0
movl (%rax,%rcx,4), %eax
andl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x4824(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4824(%rax)
movl -0x10(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0x9ac9(%rip), %rcx      # 0x20330
movl (%rcx,%rdx,4), %ecx
movl -0x14(%rbp), %edx
xorl $-0x1, %edx
andl %edx, %ecx
addl %ecx, %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_get_bit(stbi__jpeg*)
stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)
{
   unsigned int k;
   if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);
   k = j->code_buffer;
   j->code_buffer <<= 1;
   --j->code_bits;
   return k & 0x80000000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4824(%rax)
jge 0x168a2
movq -0x8(%rbp), %rdi
callq 0x15e10
movq -0x8(%rbp), %rax
movl 0x4820(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4820(%rax), %ecx
shll %ecx
movl %ecx, 0x4820(%rax)
movq -0x8(%rbp), %rax
movl 0x4824(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4824(%rax)
movl -0xc(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
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__jpeg_get_bits(stbi__jpeg*, int)
stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)
{
   unsigned int k;
   if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
   k = stbi_lrot(j->code_buffer, n);
   j->code_buffer = k & ~stbi__bmask[n];
   k &= stbi__bmask[n];
   j->code_bits -= n;
   return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4824(%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x16917
movq -0x8(%rbp), %rdi
callq 0x15e10
movq -0x8(%rbp), %rax
movl 0x4820(%rax), %eax
movl -0xc(%rbp), %ecx
shll %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x4820(%rcx), %edx
movl $0x20, %ecx
subl -0xc(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movslq -0xc(%rbp), %rdx
leaq 0x9991(%rip), %rax      # 0x202e0
movl (%rax,%rdx,4), %eax
xorl $-0x1, %eax
andl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4820(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x9974(%rip), %rax      # 0x202e0
movl (%rax,%rcx,4), %eax
andl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x4824(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4824(%rax)
movl -0x10(%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__check_png_header(stbi__context*)
static int stbi__check_png_header(stbi__context *s)
{
   static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
   int i;
   for (i=0; i < 8; ++i)
      if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x16a46
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movslq -0x14(%rbp), %rdx
leaq 0x9950(%rip), %rcx      # 0x20370
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x16a39
leaq 0xa0a2(%rip), %rdi      # 0x20ad1
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0x16a4d
jmp 0x16a3b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16a03
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
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__getn(stbi__context*, unsigned char*, int)
static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
{
   if (s->io.read) {
      int blen = (int) (s->img_buffer_end - s->img_buffer);
      if (blen < n) {
         int res, count;

         memcpy(buffer, s->img_buffer, blen);

         count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
         res = (count == (n-blen));
         s->img_buffer = s->img_buffer_end;
         return res;
      }
   }

   if (s->img_buffer+n <= s->img_buffer_end) {
      memcpy(buffer, s->img_buffer, n);
      s->img_buffer += n;
      return 1;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1866a
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xb8(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x18668
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rsi
movslq -0x20(%rbp), %rdx
callq 0x21b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rcx
addq %rcx, %rsi
movl -0x1c(%rbp), %edx
subl -0x20(%rbp), %edx
callq *%rax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb8(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x186cc
jmp 0x1866a
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0xc0(%rcx), %rax
ja 0x186c5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x21b0
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0xb8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x186cc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
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__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 0x18b00
cmpl $0x4, -0x14(%rbp)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x18b09
jmp 0x18b0b
jmp 0x18b2a
leaq 0x81a8(%rip), %rdi      # 0x20cba
leaq 0x7cbd(%rip), %rsi      # 0x207d6
movl $0x124d, %edx           # imm = 0x124D
leaq 0x81ae(%rip), %rcx      # 0x20cd3
callq 0x2140
cmpl $0x2, -0x14(%rbp)
jne 0x18b7d
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x18b7b
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 0x18b37
jmp 0x18be9
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x18be7
movq -0x30(%rbp), %rax
movzwl (%rax), %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x18bd0
movq -0x30(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x18bd0
movq -0x30(%rbp), %rax
movzwl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jne 0x18bd0
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 0x18b84
jmp 0x18be9
movl $0x1, %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__compute_transparency(stbi__png*, unsigned char*, int)
static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
{
   stbi__context *s = z->s;
   stbi__uint32 i, pixel_count = s->img_x * s->img_y;
   stbi_uc *p = z->out;

   // compute color-based transparency, assuming we've
   // already got 255 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 : 255);
         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 0x18c50
cmpl $0x4, -0x14(%rbp)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x18c59
jmp 0x18c5b
jmp 0x18c7a
leaq 0x8058(%rip), %rdi      # 0x20cba
leaq 0x7b6d(%rip), %rsi      # 0x207d6
movl $0x1234, %edx           # imm = 0x1234
leaq 0x80a1(%rip), %rcx      # 0x20d16
callq 0x2140
cmpl $0x2, -0x14(%rbp)
jne 0x18ccb
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x18cc9
movq -0x30(%rbp), %rax
movzbl (%rax), %edx
movq -0x10(%rbp), %rax
movzbl (%rax), %esi
movl $0xff, %eax
xorl %ecx, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x18c87
jmp 0x18d35
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x18d33
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x18d1c
movq -0x30(%rbp), %rax
movzbl 0x1(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x18d1c
movq -0x30(%rbp), %rax
movzbl 0x2(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x18d1c
movq -0x30(%rbp), %rax
movb $0x0, 0x3(%rax)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x18cd2
jmp 0x18d35
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__paeth(int, int, int)
static int stbi__paeth(int a, int b, int c)
{
   int p = a + b - c;
   int pa = abs(p-a);
   int pb = abs(p-b);
   int pc = abs(p-c);
   if (pa <= pb && pa <= pc) return a;
   if (pb <= pc) return b;
   return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x1a671
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x1a671
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a687
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x1a681
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a687
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)