LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__bmp_test_raw(stbi__context*)
static int stbi__bmp_test_raw(stbi__context *s)
{
   int r;
   int sz;
   if (stbi__get8(s) != 'B') return 0;
   if (stbi__get8(s) != 'M') return 0;
   stbi__get32le(s); // discard filesize
   stbi__get16le(s); // discard reserved
   stbi__get16le(s); // discard reserved
   stbi__get32le(s); // discard data offset
   sz = stbi__get32le(s);
   r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
cmpl $0x42, %eax
je 0x1a6e9
movl $0x0, -0x4(%rbp)
jmp 0x1a77a
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
cmpl $0x4d, %eax
je 0x1a703
movl $0x0, -0x4(%rbp)
jmp 0x1a77a
movq -0x10(%rbp), %rdi
callq 0x1a790
movq -0x10(%rbp), %rdi
callq 0x1a7d0
movq -0x10(%rbp), %rdi
callq 0x1a7d0
movq -0x10(%rbp), %rdi
callq 0x1a790
movq -0x10(%rbp), %rdi
callq 0x1a790
movl %eax, -0x18(%rbp)
movb $0x1, %al
cmpl $0xc, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x1a769
movb $0x1, %al
cmpl $0x28, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x1a769
movb $0x1, %al
cmpl $0x38, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x1a769
movb $0x1, %al
cmpl $0x6c, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x1a769
cmpl $0x7c, -0x18(%rbp)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -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__high_bit(unsigned int)
static int stbi__high_bit(unsigned int z)
{
   int n=0;
   if (z == 0) return -1;
   if (z >= 0x10000) { n += 16; z >>= 16; }
   if (z >= 0x00100) { n +=  8; z >>=  8; }
   if (z >= 0x00010) { n +=  4; z >>=  4; }
   if (z >= 0x00004) { n +=  2; z >>=  2; }
   if (z >= 0x00002) { n +=  1; z >>=  1; }
   return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1ac70
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1acf3
cmpl $0x10000, -0x8(%rbp)    # imm = 0x10000
jb 0x1ac8b
movl -0xc(%rbp), %eax
addl $0x10, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jb 0x1aca6
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x8(%rbp)
cmpl $0x10, -0x8(%rbp)
jb 0x1acbe
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jb 0x1acd6
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
jb 0x1aced
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__bitcount(unsigned int)
static int stbi__bitcount(unsigned int a)
{
   a = (a & 0x55555555) + ((a >>  1) & 0x55555555); // max 2
   a = (a & 0x33333333) + ((a >>  2) & 0x33333333); // max 4
   a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
   a = (a + (a >> 8)); // max 16 per 8 bits
   a = (a + (a >> 16)); // max 32 per 8 bits
   return a & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl -0x4(%rbp), %ecx
shrl %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x33333333, %eax       # imm = 0x33333333
movl -0x4(%rbp), %ecx
shrl $0x2, %ecx
andl $0x33333333, %ecx       # imm = 0x33333333
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
shrl $0x4, %ecx
addl %ecx, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
shrl $0x8, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__shiftsigned(unsigned int, int, int)
static int stbi__shiftsigned(unsigned int v, int shift, int bits)
{
   static unsigned int mul_table[9] = {
      0,
      0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
      0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
   };
   static unsigned int shift_table[9] = {
      0, 0,0,1,0,2,4,6,0,
   };
   if (shift < 0)
      v <<= -shift;
   else
      v >>= shift;
   STBI_ASSERT(v >= 0 && v < 256);
   v >>= (8-bits);
   STBI_ASSERT(bits >= 0 && bits <= 8);
   return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x1ada6
xorl %ecx, %ecx
subl -0x8(%rbp), %ecx
movl -0x4(%rbp), %eax
shll %cl, %eax
movl %eax, -0x4(%rbp)
jmp 0x1adb1
movl -0x8(%rbp), %ecx
movl -0x4(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0xd(%rbp)
jb 0x1adc9
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
setb %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x1add2
jmp 0x1add4
jmp 0x1adf3
leaq 0x60be(%rip), %rdi      # 0x20e99
leaq 0x59f4(%rip), %rsi      # 0x207d6
movl $0x13f9, %edx           # imm = 0x13F9
leaq 0x60bd(%rip), %rcx      # 0x20eab
callq 0x2140
movl $0x8, %ecx
subl -0xc(%rbp), %ecx
movl -0x4(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xe(%rbp)
jl 0x1ae18
cmpl $0x8, -0xc(%rbp)
setle %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
testb $0x1, %al
jne 0x1ae21
jmp 0x1ae23
jmp 0x1ae42
leaq 0x60af(%rip), %rdi      # 0x20ed9
leaq 0x59a5(%rip), %rsi      # 0x207d6
movl $0x13fb, %edx           # imm = 0x13FB
leaq 0x606e(%rip), %rcx      # 0x20eab
callq 0x2140
movl -0x4(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0xb470(%rip), %rcx      # 0x262c0
imull (%rcx,%rdx,4), %eax
movslq -0xc(%rbp), %rdx
leaq 0xb491(%rip), %rcx      # 0x262f0
movl (%rcx,%rdx,4), %ecx
sarl %cl, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__gif_test_raw(stbi__context*)
static int stbi__gif_test_raw(stbi__context *s)
{
   int sz;
   if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;
   sz = stbi__get8(s);
   if (sz != '9' && sz != '7') return 0;
   if (stbi__get8(s) != 'a') return 0;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
cmpl $0x47, %eax
jne 0x1aec0
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
cmpl $0x49, %eax
jne 0x1aec0
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
cmpl $0x46, %eax
jne 0x1aec0
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
cmpl $0x38, %eax
je 0x1aec9
movl $0x0, -0x4(%rbp)
jmp 0x1af0e
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x39, -0x14(%rbp)
je 0x1aeed
cmpl $0x37, -0x14(%rbp)
je 0x1aeed
movl $0x0, -0x4(%rbp)
jmp 0x1af0e
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
cmpl $0x61, %eax
je 0x1af07
movl $0x0, -0x4(%rbp)
jmp 0x1af0e
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__gif_parse_colortable(stbi__context*, unsigned char (*) [4], int, int)
static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
{
   int i;
   for (i=0; i < num_entries; ++i) {
      pal[i][2] = stbi__get8(s);
      pal[i][1] = stbi__get8(s);
      pal[i][0] = stbi__get8(s);
      pal[i][3] = transp == i ? 0 : 255;
   }
}

// 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 $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1b8e4
movq -0x8(%rbp), %rdi
callq 0x12e60
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, 0x2(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x12e60
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, 0x1(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x12e60
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %esi
movl $0xff, %eax
xorl %ecx, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, 0x3(%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b86d
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__psd_decode_rle(stbi__context*, unsigned char*, int)
static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)
{
   int count, nleft, len;

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

   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x1bf93
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movl %eax, -0x28(%rbp)
cmpl $0x80, -0x28(%rbp)
jne 0x1bec9
jmp 0x1bf8e
cmpl $0x80, -0x28(%rbp)
jge 0x1bf28
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x1beef
movl $0x0, -0x4(%rbp)
jmp 0x1bf9a
movl -0x28(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x1bf26
movq -0x10(%rbp), %rdi
callq 0x12e60
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1bef8
jmp 0x1bf8c
cmpl $0x80, -0x28(%rbp)
jle 0x1bf8a
movl $0x101, %eax            # imm = 0x101
subl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x1bf4d
movl $0x0, -0x4(%rbp)
jmp 0x1bf9a
movq -0x10(%rbp), %rdi
callq 0x12e60
movb %al, -0x29(%rbp)
movl -0x28(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x1bf88
movb -0x29(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1bf62
jmp 0x1bf8a
jmp 0x1bf8c
jmp 0x1bf8e
jmp 0x1be9a
movl $0x1, -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__pic_test_core(stbi__context*)
static int stbi__pic_test_core(stbi__context *s)
{
   int i;

   if (!stbi__pic_is4(s,"\x53\x80\xF6\x34"))
      return 0;

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

   if (!stbi__pic_is4(s,"PICT"))
      return 0;

   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4ffe(%rip), %rsi      # 0x20fc5
callq 0x1c030
cmpl $0x0, %eax
jne 0x1bfda
movl $0x0, -0x4(%rbp)
jmp 0x1c020
movl $0x0, -0x14(%rbp)
cmpl $0x54, -0x14(%rbp)
jge 0x1bffb
movq -0x10(%rbp), %rdi
callq 0x12e60
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1bfe1
movq -0x10(%rbp), %rdi
leaq 0x4fc4(%rip), %rsi      # 0x20fca
callq 0x1c030
cmpl $0x0, %eax
jne 0x1c019
movl $0x0, -0x4(%rbp)
jmp 0x1c020
movl $0x1, -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__pic_is4(stbi__context*, char const*)
static int stbi__pic_is4(stbi__context *s,const char *str)
{
   int i;
   for (i=0; i<4; ++i)
      if (stbi__get8(s) != (stbi_uc)str[i])
         return 0;

   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x1c07f
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1c072
movl $0x0, -0x4(%rbp)
jmp 0x1c086
jmp 0x1c074
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1c047
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__readval(stbi__context*, int, unsigned char*)
static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
{
   int mask=0x80, i;

   for (i=0; i<4; ++i, mask>>=1) {
      if (channel & mask) {
         if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
         dest[i]=stbi__get8(s);
      }
   }

   return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x80, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x1c698
movl -0x14(%rbp), %eax
andl -0x24(%rbp), %eax
cmpl $0x0, %eax
je 0x1c683
movq -0x10(%rbp), %rdi
callq 0x12530
cmpl $0x0, %eax
je 0x1c66d
leaq 0x4978(%rip), %rdi      # 0x20fcf
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x1c6a0
movq -0x10(%rbp), %rdi
callq 0x12e60
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1c685
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
sarl %eax
movl %eax, -0x24(%rbp)
jmp 0x1c631
movq -0x20(%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__copyval(int, unsigned char*, unsigned char const*)
static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)
{
   int mask=0x80,i;

   for (i=0;i<4; ++i, mask>>=1)
      if (channel&mask)
         dest[i]=src[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x80, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x1c709
movl -0x4(%rbp), %eax
andl -0x1c(%rbp), %eax
cmpl $0x0, %eax
je 0x1c6f4
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1c6f6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
sarl %eax
movl %eax, -0x1c(%rbp)
jmp 0x1c6cd
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__pnm_info(stbi__context*, int*, int*, int*)
static int      stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
{
   int maxv, dummy;
   char c, p, t;

   if (!x) x = &dummy;
   if (!y) y = &dummy;
   if (!comp) comp = &dummy;

   stbi__rewind(s);

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1c737
leaq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1c746
leaq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1c755
leaq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd40
movq -0x10(%rbp), %rdi
callq 0x12e60
movb %al, -0x32(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12e60
movb %al, -0x33(%rbp)
movsbl -0x32(%rbp), %eax
cmpl $0x50, %eax
jne 0x1c791
movsbl -0x33(%rbp), %eax
cmpl $0x35, %eax
je 0x1c7a6
movsbl -0x33(%rbp), %eax
cmpl $0x36, %eax
je 0x1c7a6
movq -0x10(%rbp), %rdi
callq 0xbd40
movl $0x0, -0x4(%rbp)
jmp 0x1c84e
movsbl -0x33(%rbp), %edx
movl $0x1, %ecx
movl $0x3, %eax
cmpl $0x36, %edx
cmovel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x12e60
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x1c860
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x1c940
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x1c860
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x1c940
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x1c860
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x1c940
movl %eax, -0x2c(%rbp)
cmpl $0xff, -0x2c(%rbp)
jle 0x1c847
leaq 0x47a6(%rip), %rdi      # 0x20fe3
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0x1c84e
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__pnm_skip_whitespace(stbi__context*, char*)
static void     stbi__pnm_skip_whitespace(stbi__context *s, char *c)
{
   for (;;) {
      while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))
         *c = (char) stbi__get8(s);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x1c872
movq -0x8(%rbp), %rdi
callq 0x12530
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x1c89c
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x1c9c0
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1c8a5
jmp 0x1c8b8
movq -0x8(%rbp), %rdi
callq 0x12e60
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x1c872
movq -0x8(%rbp), %rdi
callq 0x12530
cmpl $0x0, %eax
jne 0x1c8d2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x1c8d4
jmp 0x1c92d
jmp 0x1c8d6
movq -0x8(%rbp), %rdi
callq 0x12530
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
jne 0x1c90c
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x12(%rbp)
je 0x1c90c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x1c915
jmp 0x1c928
movq -0x8(%rbp), %rdi
callq 0x12e60
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x1c8d6
jmp 0x1c870
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_getinteger(stbi__context*, char*)
static int      stbi__pnm_getinteger(stbi__context *s, char *c)
{
   int value = 0;

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

   return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12530
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x1c981
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x1ca30
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1c98a
jmp 0x1c9b0
imull $0xa, -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12e60
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x1c957
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__hdr_gettoken(stbi__context*, char*)
static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
{
   int len=0;
   char c = '\0';

   c = (char) stbi__get8(z);

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

   buffer[len] = 0;
   return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12e60
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12530
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x16(%rbp)
jne 0x1caa9
movsbl -0x15(%rbp), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x1cab2
jmp 0x1cb1d
movb -0x15(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
cmpl $0x3ff, -0x14(%rbp)     # imm = 0x3FF
jne 0x1cb0c
jmp 0x1cad5
movq -0x8(%rbp), %rdi
callq 0x12530
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x17(%rbp)
jne 0x1caff
movq -0x8(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
testb $0x1, %al
jne 0x1cb08
jmp 0x1cb0a
jmp 0x1cad5
jmp 0x1cb1d
movq -0x8(%rbp), %rdi
callq 0x12e60
movb %al, -0x15(%rbp)
jmp 0x1ca87
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__hdr_convert(float*, unsigned char*, int)
static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
{
   if ( input[3] != 0 ) {
      float f1;
      // Exponent
      f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
      if (req_comp <= 2)
         output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
      else {
         output[0] = input[0] * f1;
         output[1] = input[1] * f1;
         output[2] = input[2] * f1;
      }
      if (req_comp == 2) output[1] = 1;
      if (req_comp == 4) output[3] = 1;
   } else {
      switch (req_comp) {
         case 4: output[3] = 1; /* fallthrough */
         case 3: output[0] = output[1] = output[2] = 0;
                 break;
         case 2: output[1] = 1; /* fallthrough */
         case 1: output[0] = 0;
                 break;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
je 0x1cd50
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %edi
subl $0x88, %edi
movss 0x337a(%rip), %xmm0     # 0x20004
callq 0x1f8e0
movss %xmm0, -0x18(%rbp)
cmpl $0x2, -0x14(%rbp)
jg 0x1ccd4
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
cvtsi2ss %eax, %xmm0
mulss -0x18(%rbp), %xmm0
movss 0x334e(%rip), %xmm1     # 0x20014
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x1cd20
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cvtsi2ss %eax, %xmm0
mulss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cvtsi2ss %eax, %xmm0
mulss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cvtsi2ss %eax, %xmm0
mulss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
cmpl $0x2, -0x14(%rbp)
jne 0x1cd37
movq -0x8(%rbp), %rax
movss 0x32d2(%rip), %xmm0     # 0x20004
movss %xmm0, 0x4(%rax)
cmpl $0x4, -0x14(%rbp)
jne 0x1cd4e
movq -0x8(%rbp), %rax
movss 0x32bb(%rip), %xmm0     # 0x20004
movss %xmm0, 0xc(%rax)
jmp 0x1cdc8
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x1cdc6
movq -0x20(%rbp), %rax
leaq 0x3479(%rip), %rcx      # 0x201e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movss 0x3284(%rip), %xmm0     # 0x20004
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
jmp 0x1cdc6
movq -0x8(%rbp), %rax
movss 0x324e(%rip), %xmm0     # 0x20004
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
jmp 0x1cdc8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__tga_get_comp(int, int, int*)
static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
{
   // only RGB or RGBA (incl. 16bit) or grey allowed
   if (is_rgb16) *is_rgb16 = 0;
   switch(bits_per_pixel) {
      case 8:  return STBI_grey;
      case 16: if(is_grey) return STBI_grey_alpha;
               // fallthrough
      case 15: if(is_rgb16) *is_rgb16 = 1;
               return STBI_rgb;
      case 24: // fallthrough
      case 32: return bits_per_pixel/8;
      default: return 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1cdef
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl -0x8(%rbp), %eax
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x18, %eax
ja 0x1ce58
movq -0x20(%rbp), %rax
leaq 0x33e9(%rip), %rcx      # 0x201f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x1ce5f
cmpl $0x0, -0xc(%rbp)
je 0x1ce2c
movl $0x2, -0x4(%rbp)
jmp 0x1ce5f
jmp 0x1ce2e
cmpq $0x0, -0x18(%rbp)
je 0x1ce3f
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x1ce5f
movl -0x8(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
jmp 0x1ce5f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__tga_read_rgb16(stbi__context*, unsigned char*)
static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)
{
   stbi__uint16 px = (stbi__uint16)stbi__get16le(s);
   stbi__uint16 fiveBitMask = 31;
   // we have 3 channels with 5bits each
   int r = (px >> 10) & fiveBitMask;
   int g = (px >> 5) & fiveBitMask;
   int b = px & fiveBitMask;
   // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later
   out[0] = (stbi_uc)((r * 255)/31);
   out[1] = (stbi_uc)((g * 255)/31);
   out[2] = (stbi_uc)((b * 255)/31);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a7d0
movw %ax, -0x12(%rbp)
movw $0x1f, -0x14(%rbp)
movzwl -0x12(%rbp), %eax
sarl $0xa, %eax
movzwl -0x14(%rbp), %ecx
andl %ecx, %eax
movl %eax, -0x18(%rbp)
movzwl -0x12(%rbp), %eax
sarl $0x5, %eax
movzwl -0x14(%rbp), %ecx
andl %ecx, %eax
movl %eax, -0x1c(%rbp)
movzwl -0x12(%rbp), %eax
movzwl -0x14(%rbp), %ecx
andl %ecx, %eax
movl %eax, -0x20(%rbp)
imull $0xff, -0x18(%rbp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
imull $0xff, -0x1c(%rbp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
imull $0xff, -0x20(%rbp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__convert_8_to_16(unsigned char*, int, int, int)
static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
{
   int i;
   int img_len = w * h * channels;
   stbi__uint16 *enlarged;

   enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
   if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");

   for (i = 0; i < img_len; ++i)
      enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff

   STBI_FREE(orig);
   return enlarged;
}

// 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)
movl -0x24(%rbp), %eax
shll %eax
movslq %eax, %rdi
callq 0x36a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1cf68
leaq 0x39ec(%rip), %rdi      # 0x2093e
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x1cfbf
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1cfae
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movw %ax, %dx
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1cf6f
movq -0x10(%rbp), %rdi
callq 0x22a0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__ldr_to_hdr(unsigned char*, int, int, int)
static float   *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)
{
   int i,k,n;
   float *output;
   if (!data) return NULL;
   output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);
   if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); }
   // compute number of non-alpha components
   if (comp & 1) n = comp; else n = comp-1;
   for (i=0; i < x*y; ++i) {
      for (k=0; k < n; ++k) {
         output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);
      }
   }
   if (n < comp) {
      for (i=0; i < x*y; ++i) {
         output[i*comp + n] = data[i*comp + n]/255.0f;
      }
   }
   STBI_FREE(data);
   return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1d069
movq $0x0, -0x8(%rbp)
jmp 0x1d1d4
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movl $0x4, %ecx
xorl %r8d, %r8d
callq 0x1cbe0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1d0b3
movq -0x10(%rbp), %rdi
callq 0x22a0
leaq 0x38a4(%rip), %rdi      # 0x2093e
callq 0x2680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x1d1d4
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1d0c6
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x1d0cf
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1d15e
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1d14e
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x2ef4(%rip), %xmm1     # 0x20008
divss %xmm1, %xmm0
movss 0x9110(%rip), %xmm1     # 0x26230
callq 0x1f910
mulss 0x9107(%rip), %xmm0     # 0x26234
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1d0eb
jmp 0x1d150
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1d0d6
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1d1c3
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1d1c1
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movss 0x2e6c(%rip), %xmm1     # 0x20008
divss %xmm1, %xmm0
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1d16d
jmp 0x1d1c3
movq -0x10(%rbp), %rdi
callq 0x22a0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__parse_zlib(stbi__zbuf*, int)
static int stbi__parse_zlib(stbi__zbuf *a, int parse_header)
{
   int final, type;
   if (parse_header)
      if (!stbi__parse_zlib_header(a)) return 0;
   a->num_bits = 0;
   a->code_buffer = 0;
   do {
      final = stbi__zreceive(a,1);
      type = stbi__zreceive(a,2);
      if (type == 0) {
         if (!stbi__parse_uncompressed_block(a)) return 0;
      } else if (type == 3) {
         return 0;
      } else {
         if (type == 1) {
            // use fixed code lengths
            if (!stbi__zbuild_huffman(&a->z_length  , stbi__zdefault_length  , 288)) return 0;
            if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance,  32)) return 0;
         } else {
            if (!stbi__compute_huffman_codes(a)) return 0;
         }
         if (!stbi__parse_huffman_block(a)) return 0;
      }
   } while (!final);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1d211
movq -0x10(%rbp), %rdi
callq 0x1d330
cmpl $0x0, %eax
jne 0x1d20f
movl $0x0, -0x4(%rbp)
jmp 0x1d327
jmp 0x1d211
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1d3d0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x1d3d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x1d26e
movq -0x10(%rbp), %rdi
callq 0x1d440
cmpl $0x0, %eax
jne 0x1d269
movl $0x0, -0x4(%rbp)
jmp 0x1d327
jmp 0x1d30d
cmpl $0x3, -0x1c(%rbp)
jne 0x1d280
movl $0x0, -0x4(%rbp)
jmp 0x1d327
cmpl $0x1, -0x1c(%rbp)
jne 0x1d2d9
movq -0x10(%rbp), %rdi
addq $0x34, %rdi
leaq 0x317b(%rip), %rsi      # 0x20410
movl $0x120, %edx            # imm = 0x120
callq 0x1d610
cmpl $0x0, %eax
jne 0x1d2ad
movl $0x0, -0x4(%rbp)
jmp 0x1d327
movq -0x10(%rbp), %rdi
addq $0x818, %rdi            # imm = 0x818
leaq 0x3271(%rip), %rsi      # 0x20530
movl $0x20, %edx
callq 0x1d610
cmpl $0x0, %eax
jne 0x1d2d7
movl $0x0, -0x4(%rbp)
jmp 0x1d327
jmp 0x1d2f2
movq -0x10(%rbp), %rdi
callq 0x1d920
cmpl $0x0, %eax
jne 0x1d2f0
movl $0x0, -0x4(%rbp)
jmp 0x1d327
jmp 0x1d2f2
movq -0x10(%rbp), %rdi
callq 0x1dc70
cmpl $0x0, %eax
jne 0x1d309
movl $0x0, -0x4(%rbp)
jmp 0x1d327
jmp 0x1d30b
jmp 0x1d30d
jmp 0x1d30f
cmpl $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1d227
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__parse_zlib_header(stbi__zbuf*)
static int stbi__parse_zlib_header(stbi__zbuf *a)
{
   int cmf   = stbi__zget8(a);
   int cm    = cmf & 15;
   /* int cinfo = cmf >> 4; */
   int flg   = stbi__zget8(a);
   if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec
   if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png
   if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png
   // window = 1 << (8 + cinfo)... but who cares, we fully buffer output
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1df00
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1df00
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
shll $0x8, %eax
addl -0x1c(%rbp), %eax
movl $0x1f, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x1d38a
leaq 0x3de0(%rip), %rdi      # 0x21160
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0x1d3c4
movl -0x1c(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x1d3a6
leaq 0x3dd4(%rip), %rdi      # 0x21170
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0x1d3c4
cmpl $0x8, -0x18(%rbp)
je 0x1d3bd
leaq 0x3c02(%rip), %rdi      # 0x20fb5
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0x1d3c4
movl $0x1, -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__zreceive(stbi__zbuf*, int)
stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)
{
   unsigned int k;
   if (z->num_bits < n) stbi__fill_bits(z);
   k = z->code_buffer & ((1 << n) - 1);
   z->code_buffer >>= n;
   z->num_bits -= n;
   return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x1d3f4
movq -0x8(%rbp), %rdi
callq 0x1df40
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x14(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__fill_bits(stbi__zbuf*)
static void stbi__fill_bits(stbi__zbuf *z)
{
   do {
      STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
      z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
      z->num_bits += 8;
   } while (z->num_bits <= 24);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jae 0x1df69
jmp 0x1df88
leaq 0x320f(%rip), %rdi      # 0x2117f
leaq 0x285f(%rip), %rsi      # 0x207d6
movl $0xf7b, %edx            # imm = 0xF7B
leaq 0x3221(%rip), %rcx      # 0x211a4
callq 0x2140
movq -0x8(%rbp), %rdi
callq 0x1df00
movzbl %al, %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
orl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x18, 0x10(%rax)
jle 0x1df4c
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__zexpand(stbi__zbuf*, char*, int)
static int stbi__zexpand(stbi__zbuf *z, char *zout, int n)  // need to make room for n bytes
{
   char *q;
   int cur, limit, old_limit;
   z->zout = zout;
   if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG");
   cur   = (int) (z->zout     - z->zout_start);
   limit = old_limit = (int) (z->zout_end - z->zout_start);
   while (cur + n > limit)
      limit *= 2;
   q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);
   STBI_NOTUSED(old_limit);
   if (q == NULL) return stbi__err("outofmem", "Out of memory");
   z->zout_start = q;
   z->zout       = q + cur;
   z->zout_end   = q + limit;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x1e00d
leaq 0x3227(%rip), %rdi      # 0x21227
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0x1e0b7
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addl -0x1c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jle 0x1e051
movl -0x30(%rbp), %eax
shll %eax
movl %eax, -0x30(%rbp)
jmp 0x1e03c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movslq -0x30(%rbp), %rsi
callq 0x23b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1e07e
leaq 0x28ca(%rip), %rdi      # 0x2093e
callq 0x2680
movl %eax, -0x4(%rbp)
jmp 0x1e0b7
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movslq -0x30(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__bitreverse16(int)
stbi_inline static int stbi__bitreverse16(int n)
{
  n = ((n & 0xAAAA) >>  1) | ((n & 0x5555) << 1);
  n = ((n & 0xCCCC) >>  2) | ((n & 0x3333) << 2);
  n = ((n & 0xF0F0) >>  4) | ((n & 0x0F0F) << 4);
  n = ((n & 0xFF00) >>  8) | ((n & 0x00FF) << 8);
  return n;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x10, 0x10(%rax)
jge 0x1e1b3
movq -0x10(%rbp), %rdi
callq 0x1df40
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movl %ecx, %ecx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1e209
movl -0x1c(%rbp), %eax
sarl $0x9, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x14(%rax)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
movl -0x1c(%rbp), %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, -0x4(%rbp)
jmp 0x1e219
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e230
movl %eax, -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__zhuffman_decode_slowpath(stbi__zbuf*, stbi__zhuffman*)
static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)
{
   int b,s,k;
   // not resolved by fast table, so compute it the slow way
   // use jpeg approach, which requires MSbits at top
   k = stbi__bit_reverse(a->code_buffer, 16);
   for (s=STBI__ZFAST_BITS+1; ; ++s)
      if (k < z->maxcode[s])
         break;
   if (s == 16) return -1; // invalid code!
   // code size is s, so:
   b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];
   STBI_ASSERT(z->size[b] == s);
   a->code_buffer >>= s;
   a->num_bits -= s;
   return z->value[b];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edi
movl $0x10, %esi
callq 0x1e0c0
movl %eax, -0x24(%rbp)
movl $0xa, -0x20(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
cmpl 0x420(%rcx,%rdx,4), %eax
jge 0x1e271
jmp 0x1e27e
jmp 0x1e273
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1e25b
cmpl $0x10, -0x20(%rbp)
jne 0x1e290
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e32d
movl -0x24(%rbp), %eax
movl $0x10, %ecx
subl -0x20(%rbp), %ecx
sarl %cl, %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzwl 0x400(%rcx,%rdx,2), %ecx
subl %ecx, %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzwl 0x464(%rcx,%rdx,2), %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl 0x484(%rax,%rcx), %eax
cmpl -0x20(%rbp), %eax
jne 0x1e2db
jmp 0x1e2fa
leaq 0x2fd4(%rip), %rdi      # 0x212b6
leaq 0x24ed(%rip), %rsi      # 0x207d6
movl $0xf97, %edx            # imm = 0xF97
leaq 0x2fd1(%rip), %rcx      # 0x212c6
callq 0x2140
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x14(%rax)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzwl 0x5a4(%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__hdr_test_core(stbi__context*, char const*)
static int stbi__hdr_test_core(stbi__context *s, const char *signature)
{
   int i;
   for (i=0; signature[i]; ++i)
      if (stbi__get8(s) != signature[i])
          return 0;
   stbi__rewind(s);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1e397
movq -0x10(%rbp), %rdi
callq 0x12e60
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1e38a
movl $0x0, -0x4(%rbp)
jmp 0x1e3a7
jmp 0x1e38c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1e357
movq -0x10(%rbp), %rdi
callq 0xbd40
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq