LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x80, %r15d
xorl %r12d, %r12d
cmpq $0x4, %r12
je 0xe7c6
testl %ebp, %r15d
je 0xe7ae
movq %r14, %rdi
callq 0xae57
testl %eax, %eax
jne 0xe7b6
movq %r14, %rdi
callq 0xae91
movb %al, (%rbx,%r12)
incq %r12
shrl %r15d
jmp 0xe78b
leaq 0x29ad(%rip), %rax      # 0x1116a
movq %rax, 0x6a54(%rip)      # 0x15218
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl $0x80, %eax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0xe7f2
testl %edi, %eax
je 0xe7eb
movb (%rdx,%rcx), %r8b
movb %r8b, (%rsi,%rcx)
incq %rcx
shrl %eax
jmp 0xe7d9
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movups 0xc8(%rdi), %xmm0
movups %xmm0, 0xb8(%rdi)
callq 0xae91
movl %eax, %ebp
movq %rbx, %rdi
callq 0xae91
cmpb $0x50, %bpl
sete %cl
leal -0x37(%rax), %edx
cmpb $-0x2, %dl
setae %dl
testb %dl, %cl
jne 0xe84f
movups 0xc8(%rbx), %xmm0
movups %xmm0, 0xb8(%rbx)
jmp 0xe8e8
testq %r12, %r12
je 0xe866
xorl %ecx, %ecx
cmpb $0x36, %al
sete %cl
leal 0x1(,%rcx,2), %eax
movl %eax, (%r12)
movq %rbx, %rdi
callq 0xae91
leaq 0xf(%rsp), %r12
movb %al, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe8fc
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe974
testq %r15, %r15
je 0xe895
movl %eax, (%r15)
leaq 0xf(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8fc
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe974
testq %r14, %r14
je 0xe8b8
movl %eax, (%r14)
leaq 0xf(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8fc
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe974
cmpl $0x100, %eax            # imm = 0x100
jl 0xe8ec
leaq 0x289d(%rip), %rax      # 0x1117e
movq %rax, 0x6930(%rip)      # 0x15218
xorl %eax, %eax
jmp 0xe8ef
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x100003e00, %r15      # imm = 0x100003E00
movq %r14, %rdi
callq 0xae57
testl %eax, %eax
je 0xe953
movq %r14, %rdi
callq 0xae57
testl %eax, %eax
jne 0xe96e
cmpb $0x23, (%rbx)
jne 0xe96e
movq %r14, %rdi
callq 0xae57
testl %eax, %eax
jne 0xe911
movzbl (%rbx), %eax
cmpl $0xa, %eax
je 0xe911
cmpl $0xd, %eax
je 0xe911
movq %r14, %rdi
callq 0xae91
movb %al, (%rbx)
jmp 0xe92e
movzbl (%rbx), %eax
cmpq $0x20, %rax
ja 0xe91d
btq %rax, %r15
jae 0xe91d
movq %r14, %rdi
callq 0xae91
movb %al, (%rbx)
jmp 0xe911
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0xae57
testl %eax, %eax
jne 0xe9ac
movzbl (%rbx), %eax
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
jb 0xe9ac
imull $0xa, %ebp, %ecx
leal (%rcx,%rax), %ebp
addl $-0x30, %ebp
movq %r14, %rdi
callq 0xae91
movb %al, (%rbx)
jmp 0xe980
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0xae91
movl %eax, %ebp
movq %r14, %rdi
callq 0xae57
cmpb $0xa, %bpl
je 0xea0d
testl %eax, %eax
jne 0xea0d
movb %bpl, (%rbx,%r15)
incq %r15
cmpq $0x3ff, %r15            # imm = 0x3FF
jne 0xe9c3
movl $0x3ff, %r15d           # imm = 0x3FF
movq %r14, %rdi
callq 0xae57
testl %eax, %eax
jne 0xea0d
movq %r14, %rdi
callq 0xae91
cmpb $0xa, %al
jne 0xe9f5
movb $0x0, (%rbx,%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
movzbl 0x3(%rsi), %edi
testl %edi, %edi
je 0xeb04
movq %rsi, %r15
addl $0xffffff78, %edi       # imm = 0xFFFFFF78
movss 0x1537(%rip), %xmm0     # 0x10008
callq 0x2210
movzbl (%r15), %eax
cmpl $0x2, %r14d
jg 0xeb29
movzbl 0x1(%r15), %ecx
addl %eax, %ecx
movzbl 0x2(%r15), %eax
addl %ecx, %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
divss 0x1516(%rip), %xmm0     # 0x10014
movss %xmm0, (%rbx)
jmp 0xeb59
decl %r14d
cmpl $0x3, %r14d
ja 0xeb86
leaq 0x181c(%rip), %rax      # 0x10330
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x3f800000, 0x4(%rbx)  # imm = 0x3F800000
andl $0x0, (%rbx)
jmp 0xeb86
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rbx)
movzbl 0x1(%r15), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x4(%rbx)
movzbl 0x2(%r15), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x8(%rbx)
cmpl $0x4, %r14d
je 0xeb6e
cmpl $0x2, %r14d
jne 0xeb86
movl $0x3f800000, 0x4(%rbx)  # imm = 0x3F800000
jmp 0xeb86
movl $0x3f800000, 0xc(%rbx)  # imm = 0x3F800000
jmp 0xeb86
movl $0x3f800000, 0xc(%rbx)  # imm = 0x3F800000
andl $0x0, 0x8(%rbx)
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdx, %rdx
je 0xeb94
andl $0x0, (%rdx)
cmpl $0x8, %edi
je 0xebe2
pushq $0x3
popq %rax
cmpl $0xf, %edi
je 0xebd3
cmpl $0x20, %edi
je 0xebcd
cmpl $0x18, %edi
je 0xebcd
cmpl $0x10, %edi
jne 0xebdf
testq %rdx, %rdx
sete %dil
xorl %ecx, %ecx
testl %esi, %esi
setne %sil
orb %sil, %dil
je 0xebd8
movb %sil, %cl
xorl $0x3, %ecx
movl %ecx, %eax
retq
shrl $0x3, %edi
movl %edi, %eax
retq
testq %rdx, %rdx
je 0xebe1
movl $0x1, (%rdx)
retq
xorl %eax, %eax
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
callq 0xda97
movl %eax, %ecx
shrl $0xa, %eax
andl $0x1f, %eax
imull $0xff, %eax, %eax
movw $0x1f, %si
xorl %edx, %edx
divw %si
movb %al, (%rbx)
movl %ecx, %eax
shrl $0x5, %eax
andl $0x1f, %eax
imull $0xff, %eax, %eax
xorl %edx, %edx
divw %si
movb %al, 0x1(%rbx)
andl $0x1f, %ecx
imull $0xff, %ecx, %eax
xorl %edx, %edx
divw %si
movb %al, 0x2(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x10(%rdi), %edx
cmpl %esi, %edx
jge 0xec4b
movq %rbx, %rdi
callq 0xee52
movl 0x10(%rbx), %edx
pushq $-0x1
popq %rax
movl %ebp, %ecx
shll %cl, %eax
movl 0x14(%rbx), %esi
notl %eax
andl %esi, %eax
shrl %cl, %esi
movl %esi, 0x14(%rbx)
subl %ebp, %edx
movl %edx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %eax
movl %eax, %edx
shrl %cl, %edx
testl %edx, %edx
jne 0xee8c
movq (%rdi), %rsi
xorl %edx, %edx
cmpq 0x8(%rdi), %rsi
jae 0xee76
leaq 0x1(%rsi), %rdx
movq %rdx, (%rdi)
movzbl (%rsi), %edx
shll %cl, %edx
orl %edx, %eax
movl %eax, 0x14(%rdi)
leal 0x8(%rcx), %edx
movl %edx, 0x10(%rdi)
cmpl $0x11, %ecx
movl %edx, %ecx
jl 0xee59
popq %rax
retq
leaq 0x2483(%rip), %rdi      # 0x11316
leaq 0x1acc(%rip), %rsi      # 0x10966
leaq 0x249a(%rip), %rcx      # 0x1133b
movl $0xf7b, %edx            # imm = 0xF7B
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, 0x18(%rdi)
cmpl $0x0, 0x30(%rdi)
je 0xef02
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
subq %rdi, %r14
movl 0x28(%rbx), %eax
subl %edi, %eax
addl %r14d, %edx
movl %eax, %ecx
leal (%rcx,%rcx), %eax
cmpl %ecx, %edx
jg 0xeecf
movslq %ecx, %r15
movq %r15, %rsi
callq 0x22c0
testq %rax, %rax
je 0xef13
movq %rax, 0x20(%rbx)
movslq %r14d, %rcx
addq %rax, %rcx
movq %rcx, 0x18(%rbx)
addq %rax, %r15
movq %r15, 0x28(%rbx)
pushq $0x1
popq %rax
jmp 0xef23
leaq 0x24b5(%rip), %rax      # 0x113be
movq %rax, 0x6308(%rip)      # 0x15218
xorl %eax, %eax
retq
leaq 0x1bbf(%rip), %rax      # 0x10ad9
movq %rax, 0x62f7(%rip)      # 0x15218
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0xf, 0x10(%rdi)
jg 0xef41
movq %rbx, %rdi
callq 0xee52
movl 0x14(%rbx), %edx
movl %edx, %eax
andl $0x1ff, %eax            # imm = 0x1FF
movzwl (%r14,%rax,2), %eax
testl %eax, %eax
je 0xef6b
movl %eax, %ecx
shrl $0x9, %ecx
shrl %cl, %edx
movl %edx, 0x14(%rbx)
subl %ecx, 0x10(%rbx)
andl $0x1ff, %eax            # imm = 0x1FF
jmp 0xf00f
movl %edx, %eax
rolw $0x8, %ax
movl %eax, %ecx
shrl $0x4, %ecx
movl $0xf0f, %esi            # imm = 0xF0F
andl %esi, %ecx
andl %esi, %eax
shll $0x4, %eax
orl %ecx, %eax
movl $0x3333, %ecx           # imm = 0x3333
movl %eax, %esi
andl %ecx, %esi
shrl $0x2, %eax
andl %ecx, %eax
leal (%rax,%rsi,4), %eax
movl $0x5555, %ecx           # imm = 0x5555
movl %eax, %esi
andl %ecx, %esi
shrl %eax
andl %ecx, %eax
leal (%rax,%rsi,2), %esi
xorl %eax, %eax
movq %rax, %rcx
incq %rax
cmpl %esi, 0x448(%r14,%rcx,4)
jle 0xefa7
cmpq $0x7, %rax
jne 0xefc2
pushq $-0x1
popq %rax
jmp 0xf00f
movb $0x7, %cl
subb %al, %cl
shrl %cl, %esi
movzwl 0x412(%r14,%rax,2), %ecx
subq %rcx, %rsi
movzwl 0x476(%r14,%rax,2), %edi
addq %rsi, %rdi
movzbl 0x484(%r14,%rdi), %ecx
addq $-0x9, %rcx
cmpq %rax, %rcx
jne 0xf017
leaq 0x9(%rax), %rcx
shrl %cl, %edx
movl %edx, 0x14(%rbx)
movl 0x10(%rbx), %ecx
subl %eax, %ecx
addl $-0x9, %ecx
movl %ecx, 0x10(%rbx)
movzwl 0x5a4(%r14,%rdi,2), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x23ce(%rip), %rdi      # 0x113ec
leaq 0x1941(%rip), %rsi      # 0x10966
leaq 0x23d0(%rip), %rcx      # 0x113fc
movl $0xf97, %edx            # imm = 0xF97
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, (%r14)
je 0xf060
movq %rbx, %rdi
callq 0xae91
movzbl %al, %eax
movsbl (%r14), %ecx
incq %r14
cmpl %ecx, %eax
je 0xf040
xorl %eax, %eax
jmp 0xf071
movups 0xc8(%rbx), %xmm0
movups %xmm0, 0xb8(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__png_info_raw(stbi__png*, int*, int*, int*)
static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
{
   if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {
      stbi__rewind( p->s );
      return 0;
   }
   if (x) *x = p->s->img_x;
   if (y) *y = p->s->img_y;
   if (comp) *comp = p->s->img_n;
   return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
pushq $0x2
popq %rsi
xorl %ebp, %ebp
xorl %edx, %edx
callq 0xb8e9
testl %eax, %eax
je 0xf0cb
testq %r12, %r12
je 0xf0ab
movq (%r14), %rax
movl (%rax), %eax
movl %eax, (%r12)
testq %r15, %r15
je 0xf0b9
movq (%r14), %rax
movl 0x4(%rax), %eax
movl %eax, (%r15)
pushq $0x1
popq %rbp
testq %rbx, %rbx
je 0xf0dc
movq (%r14), %rax
movl 0x8(%rax), %eax
movl %eax, (%rbx)
jmp 0xf0dc
movq (%r14), %rax
movups 0xc8(%rax), %xmm0
movups %xmm0, 0xb8(%rax)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/png2tlg.cpp
// Function: TLG6BitStream::PutValue(long, int)
void PutValue(long v, int len)
	{
		// put value "v" as length of "len"
		while(len --)
		{
			Put1Bit(v&1);
			v >>= 1;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
subl $0x1, %ebx
jb 0xf10d
movl %r14d, %esi
andl $0x1, %esi
movq %r15, %rdi
callq 0xf16a
sarq %r14
jmp 0xf0f5
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/png2tlg.cpp
// Function: TLG6BitStream::PutGamma(int)
void PutGamma(int v)
	{
		// Put a gamma code.
		// v must be larger than 0.
		int t = v;
		t >>= 1;
		int cnt = 0;
		while(t)
		{
			Put1Bit(0);
			t >>= 1;
			cnt ++;
		}
		Put1Bit(1);
		while(cnt--)
		{
			Put1Bit(v&1);
			v >>= 1;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
movl %esi, %r15d
cmpl $0x2, %r15d
jb 0xf13c
sarl %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0xf16a
decl %ebp
jmp 0xf125
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xf16a
testl %ebp, %ebp
je 0xf15e
movl %ebx, %esi
andl $0x1, %esi
movq %r14, %rdi
callq 0xf16a
sarl %ebx
incl %ebp
jmp 0xf147
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/png2tlg.cpp
// Function: TLG6BitStream::Put1Bit(bool)
void Put1Bit(bool b)
	{
		if(BufferBytePos == BufferCapacity)
		{
			// need more bytes
			long org_cap = BufferCapacity;
			BufferCapacity += 0x1000;
			if(Buffer)
				Buffer = (unsigned char *)realloc(Buffer, BufferCapacity);
			else
				Buffer = (unsigned char *)malloc(BufferCapacity);
			if(!Buffer) throw std::runtime_error("TVPTlgInsufficientMemory");
			memset(Buffer + org_cap, 0, BufferCapacity - org_cap);
		}

		if(b) Buffer[BufferBytePos] |= 1 << BufferBitPos;
		BufferBitPos ++;
		if(BufferBitPos == 8)
		{
			BufferBitPos = 0;
			BufferBytePos ++;
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
cmpq 0x20(%rdi), %r14
jne 0xf1bd
leaq 0x1000(%r14), %rsi
movq %rsi, 0x20(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xf198
callq 0x22c0
jmp 0xf1a0
movq %rsi, %rdi
callq 0x21f0
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0xf1eb
addq %r14, %rax
movq 0x20(%rbx), %rdx
subq %r14, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x20e0
testb %bpl, %bpl
je 0xf1d4
movb (%rbx), %cl
pushq $0x1
popq %rax
shll %cl, %eax
movq 0x18(%rbx), %rcx
movq 0x8(%rbx), %rdx
orb %al, (%rcx,%rdx)
movl (%rbx), %eax
incl %eax
movl %eax, (%rbx)
cmpl $0x8, %eax
jne 0xf1e6
andl $0x0, (%rbx)
incq 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x225f(%rip), %rsi      # 0x1145c
movq %rax, %rdi
callq 0x2080
movq 0x5de4(%rip), %rsi      # 0x14ff0
movq 0x5db5(%rip), %rdx      # 0x14fc8
movq %rbx, %rdi
callq 0x22d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/png2tlg.cpp
// Function: TryCompressGolomb::Try(char*, int)
int Try(char *buf, int size)
	{
		for(int i = 0; i < size; i++)
		{
			if(buf[i])
			{
				// write zero count
				if(!LastNonZero)
				{
					if(Count)
						TotalBits +=
							TLG6BitStream::GetGammaBitLength(Count);

					// count non-zero values
					Count = 0;
				}

				// write non-zero values
				for(; i < size; i++)
				{
					int e = buf[i];
					if(!e) break;
					Count ++;
					int k = TVPTLG6GolombBitLengthTable[A][N];
					int m = ((e >= 0) ? 2*e : -2*e-1) - 1;
					int unexp_bits = (m>>k);
					if(unexp_bits >= (GOLOMB_GIVE_UP_BYTES*8-8/2))
						unexp_bits = (GOLOMB_GIVE_UP_BYTES*8-8/2)+8;
					TotalBits += unexp_bits + 1 + k;
					A += (m>>1);
					if (--N < 0) {
						A >>= 1; N = TVP_TLG6_GOLOMB_N_COUNT - 1;
					}
				}

				// write non-zero count

				i--;
				LastNonZero = true;
			}
			else
			{
				// zero
				if(LastNonZero)
				{
					if(Count)
					{
						TotalBits += TLG6BitStream::GetGammaBitLength(Count);
						Count = 0;
					}
				}

				Count ++;
				LastNonZero = false;
			}
		}
		return TotalBits;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movslq %edx, %r12
xorl %r13d, %r13d
pushq $0x25
popq %rbp
movl %edx, 0x4(%rsp)
cmpl %edx, %r13d
jge 0xf372
movslq %r13d, %rbx
cmpb $0x0, (%r15,%rbx)
movb 0x10(%r14), %al
movl 0x4(%r14), %edi
je 0xf274
testb %al, %al
je 0xf297
leaq 0x5fbe(%rip), %r13      # 0x15230
jmp 0xf2b5
testb %al, %al
je 0xf35d
xorl %ebx, %ebx
testl %edi, %edi
je 0xf35f
callq 0xf50c
movl 0x4(%rsp), %edx
addl %eax, (%r14)
jmp 0xf35f
testl %edi, %edi
leaq 0x5f90(%rip), %r13      # 0x15230
je 0xf2ae
callq 0xf50c
movl 0x4(%rsp), %edx
addl %eax, (%r14)
andl $0x0, 0x4(%r14)
xorl %edi, %edi
movl (%r14), %eax
movl 0x8(%r14), %ecx
movl 0xc(%r14), %r11d
incl %edi
cmpq %r12, %rbx
jge 0xf34b
movsbl (%r15,%rbx), %r8d
testl %r8d, %r8d
je 0xf350
movl %edi, 0x4(%r14)
movslq %r11d, %r11
movslq %ecx, %rsi
leaq (,%r11,4), %rcx
addq %r13, %rcx
movsbl (%rsi,%rcx), %ecx
movl %r8d, %r9d
addl %r8d, %r9d
sarb $0x7, %r8b
movsbl %r8b, %r8d
xorl %r9d, %r8d
decl %r8d
movl %r8d, %r9d
sarl %cl, %r9d
leal 0x1(%r9), %r10d
cmpl $0x1c, %r9d
cmovgel %ebp, %r10d
addl %ecx, %eax
addl %r10d, %eax
movl %eax, (%r14)
sarl %r8d
addl %r8d, %r11d
movl %r11d, 0xc(%r14)
leal -0x1(%rsi), %ecx
movl %ecx, 0x8(%r14)
testl %esi, %esi
jg 0xf343
sarl %r11d
movl %r11d, 0xc(%r14)
movl $0x3, 0x8(%r14)
pushq $0x3
popq %rcx
incq %rbx
jmp 0xf2c0
movl %edx, %r13d
jmp 0xf353
movl %ebx, %r13d
movb $0x1, 0x10(%r14)
jmp 0xf24c
movl %edi, %ebx
incl %ebx
movl %ebx, 0x4(%r14)
movb $0x0, 0x10(%r14)
incl %r13d
jmp 0xf24c
movl (%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/png2tlg.cpp
// Function: TryCompressGolomb::Flush()
int Flush()
	{
		if(Count)
		{
			TotalBits += TLG6BitStream::GetGammaBitLength(Count);
			Count = 0;
		}
		return TotalBits;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %edi
testl %edi, %edi
je 0xf39e
callq 0xf50c
addl (%rbx), %eax
movl %eax, (%rbx)
andl $0x0, 0x4(%rbx)
jmp 0xf3a0
movl (%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/png2tlg.cpp
// Function: TLG6BitStream::Flush()
void Flush()
	{
		if(Buffer && (BufferBitPos || BufferBytePos))
		{
			if(BufferBitPos) BufferBytePos ++;
			OutStream->write((const char *)Buffer, BufferBytePos);
			BufferBytePos = 0;
			BufferBitPos = 0;
		}
		free(Buffer);
		BufferCapacity = 0;
		Buffer = NULL;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %rsi
testq %rsi, %rsi
je 0xf3ef
movq %rdi, %rbx
movl (%rdi), %eax
testl %eax, %eax
sete %cl
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
sete %dil
testb %dil, %cl
jne 0xf3f1
testl %eax, %eax
je 0xf3d8
incq %rdx
movq %rdx, 0x8(%rbx)
movq 0x10(%rbx), %rdi
callq 0x21e0
andq $0x0, 0x8(%rbx)
andl $0x0, (%rbx)
movq 0x18(%rbx), %rsi
jmp 0xf3f1
xorl %esi, %esi
movq %rsi, %rdi
callq 0x21c0
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zhiyb[P]png2tlg/png2tlg.cpp
// Function: TLG6BitStream::GetGammaBitLength(int)
static int GetGammaBitLength(int v)
	{
		// Get bit length where v is to be encoded as a gamma code.
		if(v<=1) return 1;    //                   1
		if(v<=3) return 3;    //                 x10
		if(v<=7) return 5;    //               xx100
		if(v<=15) return 7;   //             xxx1000
		if(v<=31) return 9;   //          x xxx10000
		if(v<=63) return 11;  //        xxx xx100000
		if(v<=127) return 13; //      xxxxx x1000000
		if(v<=255) return 15; //    xxxxxxx 10000000
		if(v<=511) return 17; //   xxxxxxx1 00000000
		return GetGammaBitLengthGeneric(v);
	}

// Assembly:
cmpl $0x2, %edi
jge 0xf515
pushq $0x1
jmp 0xf568
cmpl $0x4, %edi
jae 0xf51e
pushq $0x3
jmp 0xf568
cmpl $0x8, %edi
jae 0xf527
pushq $0x5
jmp 0xf568
cmpl $0x10, %edi
jae 0xf530
pushq $0x7
jmp 0xf568
cmpl $0x20, %edi
jae 0xf539
pushq $0x9
jmp 0xf568
cmpl $0x40, %edi
jae 0xf542
pushq $0xb
jmp 0xf568
cmpl $0x80, %edi
jae 0xf54e
pushq $0xd
jmp 0xf568
cmpl $0x100, %edi            # imm = 0x100
jae 0xf55a
pushq $0xf
jmp 0xf568
cmpl $0x200, %edi            # imm = 0x200
jae 0xf56a
pushq $0x11
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/test-low/../extras/entropy.c
// Function: entropy_getbytes
bool entropy_getbytes(void* dest, size_t size)
{
    int fd = open("/dev/random", O_RDONLY);
    if (fd >= 0)
        return false;
    uint64_t seeding[2];
    int sz = read(fd, dest, size);
    if (sz < size)
        return false;
    return close(fd) == 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1cc6(%rip), %rdi      # 0x312a
xorl %r14d, %r14d
xorl %esi, %esi
xorl %eax, %eax
callq 0x1080
testl %eax, %eax
jns 0x149c
movl %eax, %ebp
movl %eax, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1060
cltq
cmpq %rbx, %rax
jae 0x148f
xorl %r14d, %r14d
jmp 0x149c
movl %ebp, %edi
callq 0x1050
testl %eax, %eax
sete %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/test-low/../extras/entropy.c
// Function: fallback_entropy_getbytes
void fallback_entropy_getbytes(void* dest, size_t size)
{
    // Most modern OSs use address-space randomization, meaning that we can
    // use the address of stack variables and system library code as
    // initializers.  It's not as good as using /dev/random, but probably
    // better than using the current time alone.

    static PCG_SPINLOCK_DECLARE(mutex);
    PCG_SPINLOCK_LOCK(mutex);

    static int intitialized = 0;
    static pcg32_random_t entropy_rng;
    
    if (!intitialized) {
        int dummyvar;
        pcg32_srandom_r(&entropy_rng,
                        time(NULL) ^ (intptr_t)&fallback_entropy_getbytes, 
                        (intptr_t)&dummyvar);
        intitialized = 1;
    }
    
    char* dest_cp = (char*) dest;
    for (size_t i = 0; i < size; ++i) {
        dest_cp[i] = (char) pcg32_random_r(&entropy_rng);
    }

    PCG_SPINLOCK_UNLOCK(mutex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, %al
xchgb %al, 0x4ba8(%rip)       # 0x6068
testb $0x1, %al
jne 0x14b8
cmpb $0x0, 0x4ba1(%rip)      # 0x606c
jne 0x151c
xorl %edi, %edi
callq 0x1070
leaq -0x31(%rip), %rcx       # 0x14aa
xorq %rax, %rcx
leaq 0x4(%rsp), %rax
leaq 0x1(,%rax,2), %rdx
movq %rdx, 0x4b86(%rip)      # 0x6078
leaq (%rcx,%rax,2), %rcx
incq %rcx
movabsq $0x5851f42d4c957f2d, %rdx # imm = 0x5851F42D4C957F2D
imulq %rcx, %rdx
leaq (%rdx,%rax,2), %rax
incq %rax
movq %rax, 0x4b5b(%rip)      # 0x6070
movb $0x1, 0x4b50(%rip)      # 0x606c
xorl %r12d, %r12d
leaq 0x4b4a(%rip), %r15      # 0x6070
cmpq %r12, %rbx
je 0x153c
movq %r15, %rdi
callq 0x1cdc
movb %al, (%r14,%r12)
incq %r12
jmp 0x1526
xorl %eax, %eax
xchgb %al, 0x4b24(%rip)       # 0x6068
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_32_xsh_rs_16_boundedrand_r
inline uint16_t pcg_oneseq_32_xsh_rs_16_boundedrand_r(struct pcg_state_32* rng,
                                                      uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_oneseq_32_xsh_rs_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x1625
cmpw %bp, %ax
jb 0x1658
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_32_xsh_rs_16_boundedrand_r
inline uint16_t pcg_unique_32_xsh_rs_16_boundedrand_r(struct pcg_state_32* rng,
                                                      uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_unique_32_xsh_rs_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x1671
cmpw %bp, %ax
jb 0x16a6
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_32_xsh_rs_16_boundedrand_r
inline uint16_t
pcg_setseq_32_xsh_rs_16_boundedrand_r(struct pcg_state_setseq_32* rng,
                                      uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_setseq_32_xsh_rs_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x16bf
cmpw %bp, %ax
jb 0x16f0
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_mcg_32_xsh_rs_16_boundedrand_r
inline uint16_t pcg_mcg_32_xsh_rs_16_boundedrand_r(struct pcg_state_32* rng,
                                                   uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_mcg_32_xsh_rs_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x1709
cmpw %bp, %ax
jb 0x1737
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_32_xsh_rr_16_boundedrand_r
inline uint16_t pcg_oneseq_32_xsh_rr_16_boundedrand_r(struct pcg_state_32* rng,
                                                      uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_oneseq_32_xsh_rr_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x1750
cmpw %bp, %ax
jb 0x177b
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_32_xsh_rr_16_boundedrand_r
inline uint16_t pcg_unique_32_xsh_rr_16_boundedrand_r(struct pcg_state_32* rng,
                                                      uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_unique_32_xsh_rr_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x1794
cmpw %bp, %ax
jb 0x17c0
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_32_xsh_rr_16_boundedrand_r
inline uint16_t
pcg_setseq_32_xsh_rr_16_boundedrand_r(struct pcg_state_setseq_32* rng,
                                      uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_setseq_32_xsh_rr_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x17d9
cmpw %bp, %ax
jb 0x1801
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_mcg_32_xsh_rr_16_boundedrand_r
inline uint16_t pcg_mcg_32_xsh_rr_16_boundedrand_r(struct pcg_state_32* rng,
                                                   uint16_t bound)
{
    uint16_t threshold = ((uint16_t)(-bound)) % bound;
    for (;;) {
        uint16_t r = pcg_mcg_32_xsh_rr_16_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divw %bx
movl %edx, %ebp
movq %r14, %rdi
callq 0x181a
cmpw %bp, %ax
jb 0x183f
xorl %edx, %edx
divw %bx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_32_rxs_m_xs_32_boundedrand_r
inline uint32_t
pcg_oneseq_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_32* rng,
                                        uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_oneseq_32_rxs_m_xs_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1858
cmpl %ebp, %eax
jb 0x1897
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_32_rxs_m_xs_32_boundedrand_r
inline uint32_t
pcg_unique_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_32* rng,
                                        uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_unique_32_rxs_m_xs_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x18ae
cmpl %ebp, %eax
jb 0x18f2
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_32_rxs_m_xs_32_boundedrand_r
inline uint32_t
pcg_setseq_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_setseq_32* rng,
                                        uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_setseq_32_rxs_m_xs_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1909
cmpl %ebp, %eax
jb 0x1945
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_64_xsh_rs_32_boundedrand_r
inline uint32_t pcg_oneseq_64_xsh_rs_32_boundedrand_r(struct pcg_state_64* rng,
                                                      uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_oneseq_64_xsh_rs_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1ab4
cmpl %ebp, %eax
jb 0x1afd
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_64_xsh_rs_32_boundedrand_r
inline uint32_t pcg_unique_64_xsh_rs_32_boundedrand_r(struct pcg_state_64* rng,
                                                      uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_unique_64_xsh_rs_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1b14
cmpl %ebp, %eax
jb 0x1b5a
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_64_xsh_rs_32_boundedrand_r
inline uint32_t
pcg_setseq_64_xsh_rs_32_boundedrand_r(struct pcg_state_setseq_64* rng,
                                      uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_setseq_64_xsh_rs_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1b71
cmpl %ebp, %eax
jb 0x1bb1
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_mcg_64_xsh_rs_32_boundedrand_r
inline uint32_t pcg_mcg_64_xsh_rs_32_boundedrand_r(struct pcg_state_64* rng,
                                                   uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_mcg_64_xsh_rs_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1bc8
cmpl %ebp, %eax
jb 0x1c04
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_64_xsh_rr_32_boundedrand_r
inline uint32_t pcg_oneseq_64_xsh_rr_32_boundedrand_r(struct pcg_state_64* rng,
                                                      uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_oneseq_64_xsh_rr_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1c1b
cmpl %ebp, %eax
jb 0x1c66
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_64_xsh_rr_32_boundedrand_r
inline uint32_t pcg_unique_64_xsh_rr_32_boundedrand_r(struct pcg_state_64* rng,
                                                      uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_unique_64_xsh_rr_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1c7d
cmpl %ebp, %eax
jb 0x1cc5
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_64_xsh_rr_32_boundedrand_r
inline uint32_t
pcg_setseq_64_xsh_rr_32_boundedrand_r(struct pcg_state_setseq_64* rng,
                                      uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_setseq_64_xsh_rr_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1cdc
cmpl %ebp, %eax
jb 0x1d1e
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_mcg_64_xsh_rr_32_boundedrand_r
inline uint32_t pcg_mcg_64_xsh_rr_32_boundedrand_r(struct pcg_state_64* rng,
                                                   uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_mcg_64_xsh_rr_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1d35
cmpl %ebp, %eax
jb 0x1d73
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_64_rxs_m_xs_64_boundedrand_r
inline uint64_t
pcg_oneseq_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_64* rng,
                                        uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_oneseq_64_rxs_m_xs_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x1d8a
cmpq %r15, %rax
jb 0x1df0
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_64_rxs_m_xs_64_boundedrand_r
inline uint64_t
pcg_unique_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_64* rng,
                                        uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_unique_64_rxs_m_xs_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x1e0b
cmpq %r15, %rax
jb 0x1e6e
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_64_rxs_m_xs_64_boundedrand_r
inline uint64_t
pcg_setseq_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_setseq_64* rng,
                                        uint64_t bound)
{
    uint64_t threshold = -bound % bound;
    for (;;) {
        uint64_t r = pcg_setseq_64_rxs_m_xs_64_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
negq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
callq 0x1e89
cmpq %r15, %rax
jb 0x1ee6
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_oneseq_64_xsl_rr_32_boundedrand_r
inline uint32_t pcg_oneseq_64_xsl_rr_32_boundedrand_r(struct pcg_state_64* rng,
                                                      uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_oneseq_64_xsl_rr_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1f01
cmpl %ebp, %eax
jb 0x1f45
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_unique_64_xsl_rr_32_boundedrand_r
inline uint32_t pcg_unique_64_xsl_rr_32_boundedrand_r(struct pcg_state_64* rng,
                                                      uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_unique_64_xsl_rr_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1f5c
cmpl %ebp, %eax
jb 0x1f9d
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pyk[P]simple-nn/deps/pcg/src/../include/pcg_variants.h
// Function: pcg_setseq_64_xsl_rr_32_boundedrand_r
inline uint32_t
pcg_setseq_64_xsl_rr_32_boundedrand_r(struct pcg_state_setseq_64* rng,
                                      uint32_t bound)
{
    uint32_t threshold = -bound % bound;
    for (;;) {
        uint32_t r = pcg_setseq_64_xsl_rr_32_random_r(rng);
        if (r >= threshold)
            return r % bound;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
xorl %edx, %edx
divl %esi
movl %edx, %ebp
movq %r14, %rdi
callq 0x1fb4
cmpl %ebp, %eax
jb 0x1fef
xorl %edx, %edx
divl %ebx
movl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq