LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/dxwc[P]sfeed/sfeed.c
// Function: xmlattrstart
static void
xmlattrstart(XMLParser *p, const char *t, size_t tl, const char *n, size_t nl)
{
	if (!ISINCONTENT(ctx) || ctx.contenttype != ContentTypeHTML)
		return;

	/* handles transforming inline XML to data */
	if (!ctx.attrcount)
		xmldata(p, " ", 1);
	ctx.attrcount++;
	xmldata(p, n, nl);
	xmldata(p, "=\"", 2);
}

// Assembly:
cmpl $0x0, 0x75fd(%rip)      # 0x9c84
je 0x26f9
cmpl $0x0, 0x75f8(%rip)      # 0x9c88
jne 0x26f9
cmpl $0x2, 0x75f3(%rip)      # 0x9c8c
jne 0x26f9
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movl 0x75e5(%rip), %eax      # 0x9c94
testl %eax, %eax
jne 0x26cd
leaq 0x2a7a(%rip), %rsi      # 0x5134
movl $0x1, %edx
movq %rbx, %rdi
callq 0x270b
movl 0x75c7(%rip), %eax      # 0x9c94
incl %eax
movl %eax, 0x75bf(%rip)      # 0x9c94
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x270b
leaq 0x2a4c(%rip), %rsi      # 0x5136
movl $0x2, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x270b
retq
// File: /workspace/github_c_makefile_star2_O3/dxwc[P]sfeed/sfeed.c
// Function: xmldata
static void
xmldata(XMLParser *p, const char *s, size_t len)
{
	if (!ctx.field)
		return;

	/* add only data from <name> inside <author> tag
	 * or any other non-<author> tag */
	if (ctx.tagid != AtomTagAuthor || istag(p->tag, p->taglen, STRP("name")))
		string_append(ctx.field, s, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x7481(%rip), %r15      # 0x9b98
testq %r15, %r15
je 0x274c
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x16, 0x7557(%rip)     # 0x9c80
jne 0x2752
cmpq $0x4, 0x488(%rdi)
jne 0x274c
addq $0x88, %rdi
leaq 0x29f6(%rip), %rsi      # 0x5139
callq 0x2040
testl %eax, %eax
je 0x2752
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2bd6
// File: /workspace/github_c_makefile_star2_O3/dxwc[P]sfeed/sfeed.c
// Function: xmldataentity
static void
xmldataentity(XMLParser *p, const char *data, size_t datalen)
{
	char buf[16];
	ssize_t len;

	if (!ctx.field)
		return;

	/* try to translate entity, else just pass as data to
	 * xml_data_handler. */
	if ((len = xml_entitytostr(data, buf, sizeof(buf))) > 0)
		xmldata(p, buf, (size_t)len);
	else
		xmldata(p, data, datalen);
}

// Assembly:
cmpq $0x0, 0x742b(%rip)      # 0x9b98
je 0x27b6
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rsi
movl $0x10, %edx
movq %r15, %rdi
callq 0x3e54
testl %eax, %eax
jle 0x279f
movl %eax, %edx
movq %rsp, %rsi
movq %rbx, %rdi
jmp 0x27a8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x270b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/dxwc[P]sfeed/sfeed.c
// Function: string_append
static void
string_append(String *s, const char *data, size_t len)
{
	if (!len)
		return;
	/* check if allocation is necesary, don't shrink buffer,
	 * should be more than bufsiz ofcourse. */
	if (s->len + len >= s->bufsiz)
		string_buffer_realloc(s, s->len + len + 1);
	memcpy(s->data + s->len, data, len);
	s->len += len;
	s->data[s->len] = '\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x2c4a
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq (%rdi,%rdx), %rax
cmpq 0x10(%r14), %rax
jae 0x2bff
movq (%r14), %rax
jmp 0x2c2d
incq %rax
movl $0x40, %ecx
movq %rcx, %r12
addq %rcx, %rcx
cmpq %rax, %r12
jbe 0x2c07
movq (%r14), %rdi
movq %r12, %rsi
callq 0x2190
movq %rax, (%r14)
testq %rax, %rax
je 0x2c56
movq %r12, 0x10(%r14)
movq 0x8(%r14), %rdi
addq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2150
addq 0x8(%r14), %rbx
movq %rbx, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x24cf(%rip), %rsi      # 0x512c
movl $0x1, %edi
xorl %eax, %eax
callq 0x2170
// File: /workspace/github_c_makefile_star2_O3/dxwc[P]sfeed/sfeed.c
// Function: gettag
static enum TagId
gettag(enum FeedType feedtype, const char *name, size_t namelen)
{
	FeedTag f, *r = NULL;

	f.name = (char *)name;

	switch (feedtype) {
	case FeedTypeRSS:
		r = bsearch(&f, rsstags, sizeof(rsstags) / sizeof(rsstags[0]),
		        sizeof(rsstags[0]), tagcmp);
		break;
	case FeedTypeAtom:
		r = bsearch(&f, atomtags, sizeof(atomtags) / sizeof(atomtags[0]),
		        sizeof(atomtags[0]), tagcmp);
		break;
	default:
		break;
	}

	return r ? r->id : TagUnknown;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, 0x8(%rsp)
xorl %ebx, %ebx
cmpl $0x2, %edi
je 0x2c99
cmpl $0x1, %edi
jne 0x2cc3
leaq 0x448a(%rip), %rsi      # 0x7110
leaq -0x9b1(%rip), %r8       # 0x22dc
leaq 0x8(%rsp), %rdi
movl $0xb, %edx
jmp 0x2cb1
leaq 0x4580(%rip), %rsi      # 0x7220
leaq -0x9cb(%rip), %r8       # 0x22dc
leaq 0x8(%rsp), %rdi
movl $0x9, %edx
movl $0x18, %ecx
callq 0x21c0
testq %rax, %rax
je 0x2cc3
movl 0x10(%rax), %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/dxwc[P]sfeed/sfeed.c
// Function: string_print_trimmed
static void
string_print_trimmed(String *s)
{
	char *p, *e;

	if (!s->data || !s->len)
		return;

	p = ltrim(s->data);
	e = rtrim(p);

	for (; *p && p != e; p++) {
		if (isspace((unsigned char)*p))
			putchar(' '); /* any whitespace to space */
		else if (!iscntrl((unsigned char)*p))
			/* ignore other control chars */
			putchar(*p);
	}
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x3563
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x35d5
movq %rax, %rbx
movq %rax, %rdi
callq 0x360c
movq %rax, %r14
movb (%rbx), %bpl
testb %bpl, %bpl
setne %al
cmpq %r14, %rbx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x3559
callq 0x21d0
movq %rax, %r15
incq %rbx
movq (%r15), %rax
movzbl %bpl, %ecx
movzwl (%rax,%rcx,2), %eax
movl $0x20, %edi
btl $0xd, %eax
jb 0x3540
testb $0x2, %al
jne 0x3545
movsbl %bpl, %edi
callq 0x2030
movb (%rbx), %bpl
testb %bpl, %bpl
je 0x3559
leaq 0x1(%rbx), %rax
cmpq %r14, %rbx
movq %rax, %rbx
jne 0x3522
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dxwc[P]sfeed/sfeed.c
// Function: string_print_uri
void
string_print_uri(String *s)
{
	char link[4096], *p, *e;
	int c;

	if (!s->data || !s->len)
		return;

	p = ltrim(s->data);
	e = rtrim(p);
	c = *e;
	*e = '\0';
	if (absuri(link, sizeof(link), p, baseurl) != -1)
		fputs(link, stdout);
	*e = c; /* restore */
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x35d4
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
callq 0x35d5
movq %rax, %r14
movq %rax, %rdi
callq 0x360c
movq %rax, %rbx
movb (%rax), %bpl
movb $0x0, (%rax)
movq 0x3b61(%rip), %rcx      # 0x7100
movq %rsp, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdx
callq 0x38c2
cmpl $-0x1, %eax
je 0x35c6
movq 0x3a25(%rip), %rax      # 0x6fe0
movq (%rax), %rsi
movq %rsp, %rdi
callq 0x20c0
movb %bpl, (%rbx)
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dxwc[P]sfeed/xml.c
// Function: xml_entitytostr
int
xml_entitytostr(const char *e, char *buf, size_t bufsiz)
{
	/* doesn't start with & */
	if (e[0] != '&')
		return 0;
	/* numeric entity */
	if (e[1] == '#')
		return numericentitytostr(e + 2, buf, bufsiz);
	else /* named entity */
		return namedentitytostr(e + 1, buf, bufsiz);
}

// Assembly:
cmpb $0x26, (%rdi)
jne 0x3ea6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x23, 0x1(%rdi)
jne 0x3ead
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x5, %rdx
jb 0x3fdb
leaq 0x2(%r14), %r12
callq 0x2050
movq %rax, %r15
movl $0x0, (%rax)
cmpb $0x78, (%r12)
jne 0x3f05
addq $0x3, %r14
movq %rsp, %rsi
movq %r14, %rdi
movl $0x10, %edx
jmp 0x3f10
xorl %ecx, %ecx
jmp 0x3fe6
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x2, %rdx
jb 0x3fdb
incq %r14
movl $0x8, %r15d
leaq 0x2e84(%rip), %r12      # 0x6d50
movq -0x8(%r15,%r12), %rsi
movq %r14, %rdi
callq 0x2100
testl %eax, %eax
je 0x3ef1
addq $0x10, %r15
cmpq $0xa8, %r15
jne 0x3ecc
xorl %ecx, %ecx
jmp 0x3fdb
movb (%r15,%r12), %al
movb %al, (%rbx)
movb $0x0, 0x1(%rbx)
movl $0x1, %ecx
jmp 0x3fdb
movq %rsp, %rsi
movq %r12, %rdi
movl $0xa, %edx
callq 0x21a0
xorl %ecx, %ecx
cmpl $0x0, (%r15)
jne 0x3fdb
movq (%rsp), %rdx
cmpb $0x3b, (%rdx)
setne %dl
cmpq $0x110000, %rax         # imm = 0x110000
setge %sil
orb %dl, %sil
jne 0x3fdb
testq %rax, %rax
je 0x3f55
cmpq $0x7f, %rax
jg 0x3f59
movb %al, (%rbx)
movl $0x1, %ecx
jmp 0x3fd5
xorl %ecx, %ecx
jmp 0x3fd5
movl %eax, %ecx
cmpq $0x7ff, %rax            # imm = 0x7FF
ja 0x3f79
shrl $0x6, %ecx
orb $-0x40, %cl
movb %cl, (%rbx)
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rbx)
movl $0x2, %ecx
jmp 0x3fd5
cmpq $0xffff, %rax           # imm = 0xFFFF
ja 0x3fa5
shrl $0xc, %ecx
orb $-0x20, %cl
movb %cl, (%rbx)
movl %eax, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rbx)
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rbx)
movl $0x3, %ecx
jmp 0x3fd5
shrl $0x12, %ecx
orb $-0x10, %cl
movb %cl, (%rbx)
movl %eax, %ecx
shrl $0xc, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rbx)
movl %eax, %ecx
shrl $0x6, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x2(%rbx)
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x3(%rbx)
movl $0x4, %ecx
movl %ecx, %eax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_load
STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   FILE *f = stbi__fopen(filename, "rb");
   unsigned char *result;
   if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
   result = stbi_load_from_file(f,x,y,comp,req_comp);
   fclose(f);
   return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x16554(%rip), %rsi     # 0x189d0
callq 0x21c0
testq %rax, %rax
je 0x24ad
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x24c7
movq %rax, %rbx
movq %r13, %rdi
callq 0x2170
movq %rbx, %rax
jmp 0x24bd
leaq 0x1651f(%rip), %rax     # 0x189d3
movq %rax, 0x1ad3d(%rip)     # 0x1d1f8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_load_from_file
STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *result;
   stbi__context s;
   stbi__start_file(&s,f);
   result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
   if (result) {
      // need to 'unget' all the characters in the IO buffer
      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
   }
   return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2544
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x25c3
movq %rax, %r14
testq %rax, %rax
je 0x252f
movl 0xb8(%rsp), %eax
subl 0xc0(%rsp), %eax
movslq %eax, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x21a0
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__load_and_postprocess_8bit(stbi__context*, int*, int*, int*, int)
static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   stbi__result_info ri;
   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);

   if (result == NULL)
      return NULL;

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

   // @TODO: move stbi__convert_format to here

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

   return (unsigned char *) result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movl $0x8, (%rsp)
leaq 0x1c(%rsp), %r9
callq 0x68f0
testq %rax, %rax
je 0x265a
movq %rax, %rbp
movl 0x1c(%rsp), %eax
cmpl $0x8, %eax
movq %r13, 0x10(%rsp)
je 0x265f
cmpl $0x10, %eax
jne 0x26a8
movl (%r15), %eax
movl (%r14), %r12d
movl %ebx, %ecx
testl %ebx, %ebx
jne 0x261d
movl (%r13), %ecx
imull %eax, %r12d
imull %ecx, %r12d
movslq %r12d, %rdi
callq 0x2200
movq %rax, %r13
testq %rax, %rax
je 0x2664
testl %r12d, %r12d
jle 0x2650
movl %r12d, %eax
xorl %ecx, %ecx
movb 0x1(%rbp,%rcx,2), %dl
movb %dl, (%r13,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x263f
movq %rbp, %rdi
callq 0x21d0
jmp 0x2672
xorl %r13d, %r13d
jmp 0x2696
movq %rbp, %r13
jmp 0x2672
leaq 0x1653e(%rip), %rax     # 0x18ba9
movq %rax, 0x1ab86(%rip)     # 0x1d1f8
cmpl $0x0, 0x1ab87(%rip)     # 0x1d200
je 0x2696
testl %ebx, %ebx
jne 0x2686
movq 0x10(%rsp), %rax
movl (%rax), %ebx
movl (%r15), %esi
movl (%r14), %edx
movq %r13, %rdi
movl %ebx, %ecx
callq 0xa46d
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1636d(%rip), %rdi     # 0x18a1c
leaq 0x16380(%rip), %rsi     # 0x18a36
leaq 0x16387(%rip), %rcx     # 0x18a44
movl $0x468, %edx            # imm = 0x468
callq 0x20f0
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_load_from_file_16
STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
{
   stbi__uint16 *result;
   stbi__context s;
   stbi__start_file(&s,f);
   result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
   if (result) {
      // need to 'unget' all the characters in the IO buffer
      fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);
   }
   return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2544
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x2744
movq %rax, %r14
testq %rax, %rax
je 0x272f
movl 0xb8(%rsp), %eax
subl 0xc0(%rsp), %eax
movslq %eax, %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x21a0
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__load_and_postprocess_16bit(stbi__context*, int*, int*, int*, int)
static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   stbi__result_info ri;
   void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);

   if (result == NULL)
      return NULL;

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

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

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

   return (stbi__uint16 *) result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r12
movl $0x10, (%rsp)
leaq 0x1c(%rsp), %r9
callq 0x68f0
testq %rax, %rax
je 0x27a8
movq %rax, %r15
movl 0x1c(%rsp), %eax
cmpl $0x8, %eax
je 0x27b0
cmpl $0x10, %eax
je 0x2828
leaq 0x16bc4(%rip), %rdi     # 0x19354
leaq 0x1629f(%rip), %rsi     # 0x18a36
leaq 0x16bcf(%rip), %rcx     # 0x1936d
movl $0x480, %edx            # imm = 0x480
callq 0x20f0
xorl %r15d, %r15d
jmp 0x284b
movl (%r12), %eax
movl (%r14), %r13d
movl %ebx, %ecx
testl %ebx, %ebx
jne 0x27c0
movl (%rbp), %ecx
movq %rbp, 0x10(%rsp)
imull %eax, %r13d
imull %ecx, %r13d
leal (,%r13,2), %eax
movslq %eax, %rdi
callq 0x2200
movq %rax, %rbp
testq %rax, %rax
je 0x2812
testl %r13d, %r13d
jle 0x2808
movl %r13d, %eax
xorl %ecx, %ecx
movzbl (%r15,%rcx), %edx
movl %edx, %esi
shll $0x8, %esi
orl %edx, %esi
movw %si, (%rbp,%rcx,2)
incq %rcx
cmpq %rcx, %rax
jne 0x27ef
movq %r15, %rdi
callq 0x21d0
jmp 0x2820
leaq 0x16390(%rip), %rax     # 0x18ba9
movq %rax, 0x1a9d8(%rip)     # 0x1d1f8
movq %rbp, %r15
movq 0x10(%rsp), %rbp
cmpl $0x0, 0x1a9d1(%rip)     # 0x1d200
je 0x284b
testl %ebx, %ebx
jne 0x2838
movl (%rbp), %ebx
movl (%r12), %esi
movl (%r14), %edx
addl %ebx, %ebx
movq %r15, %rdi
movl %ebx, %ecx
callq 0xa46d
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_load_16
STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   FILE *f = stbi__fopen(filename, "rb");
   stbi__uint16 *result;
   if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file");
   result = stbi_load_from_file_16(f,x,y,comp,req_comp);
   fclose(f);
   return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x16157(%rip), %rsi     # 0x189d0
callq 0x21c0
testq %rax, %rax
je 0x28aa
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x26c7
movq %rax, %rbx
movq %r13, %rdi
callq 0x2170
movq %rbx, %rax
jmp 0x28ba
leaq 0x16122(%rip), %rax     # 0x189d3
movq %rax, 0x1a940(%rip)     # 0x1d1f8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__loadf_main(stbi__context*, int*, int*, int*, int)
static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
   unsigned char *data;
   #ifndef STBI_NO_HDR
   if (stbi__hdr_test(s)) {
      stbi__result_info ri;
      float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
      if (hdr_data)
         stbi__float_postprocess(hdr_data,x,y,comp,req_comp);
      return hdr_data;
   }
   #endif
   data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
   if (data)
      return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);
   return stbi__errpf("unknown image type", "Image not of any known type, or corrupt");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
callq 0x319b
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movl %ebx, %r8d
testl %eax, %eax
je 0x2e75
callq 0xc85c
testq %rax, %rax
je 0x2fb5
movq %rax, %r15
cmpl $0x0, 0x1a3b2(%rip)     # 0x1d200
je 0x2fb8
testl %ebx, %ebx
jne 0x2e5c
movl (%r12), %ebx
movl (%rbp), %esi
movl (%r13), %edx
shll $0x2, %ebx
movq %r15, %rdi
movl %ebx, %ecx
callq 0xa46d
jmp 0x2fb8
callq 0x25c3
testq %rax, %rax
je 0x2f96
movq %rax, %r14
movl (%rbp), %eax
movl (%r13), %ebp
testl %ebx, %ebx
jne 0x2e95
movl (%r12), %ebx
movl %eax, %r12d
movl %eax, %edi
movl %ebp, %esi
movl %ebx, %edx
callq 0x15815
testq %rax, %rax
je 0x2f9f
movq %rax, %r15
movl %ebx, %eax
andl $0x1, %eax
cmpl $0x1, %eax
movl %ebx, %eax
sbbl $0x0, %eax
imull %r12d, %ebp
testl %ebp, %ebp
jle 0x2f8c
movl %ebx, (%rsp)
movslq %ebx, %rdx
movl %ebp, %r13d
movl %eax, %ebp
leaq (,%rdx,4), %rcx
movq %rcx, 0x18(%rsp)
movq %r14, %rbx
xorl %r14d, %r14d
movss 0x15116(%rip), %xmm1    # 0x18004
movq %rbx, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %rdx, 0x20(%rsp)
movl %eax, 0x4(%rsp)
testl %eax, %eax
jle 0x2f43
xorl %r12d, %r12d
movzbl (%rbx,%r12), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss %xmm1, %xmm0
movss 0x1a280(%rip), %xmm1    # 0x1d1a0
callq 0x2280
movss 0x150d7(%rip), %xmm1    # 0x18004
mulss 0x1a26f(%rip), %xmm0    # 0x1d1a4
movss %xmm0, (%r15,%r12,4)
incq %r12
cmpq %r12, %rbp
jne 0x2f08
incq %r14
addq 0x18(%rsp), %r15
movq 0x20(%rsp), %rdx
addq %rdx, %rbx
cmpq %r13, %r14
movl 0x4(%rsp), %eax
jne 0x2f01
testb $0x1, (%rsp)
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %r14
jne 0x2f8c
cltq
movzbl (%r14,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%r15,%rax,4)
addq %rdx, %rax
decq %r13
jne 0x2f6e
movq %r14, %rdi
callq 0x21d0
jmp 0x2fb8
leaq 0x15b01(%rip), %rax     # 0x18a9e
jmp 0x2fae
movq %r14, %rdi
callq 0x21d0
leaq 0x15bfb(%rip), %rax     # 0x18ba9
movq %rax, 0x1a243(%rip)     # 0x1d1f8
xorl %r15d, %r15d
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_loadf
STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
{
   float *result;
   FILE *f = stbi__fopen(filename, "rb");
   if (!f) return stbi__errpf("can't fopen", "Unable to open file");
   result = stbi_loadf_from_file(f,x,y,comp,req_comp);
   fclose(f);
   return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
leaq 0x15932(%rip), %rsi     # 0x189d0
callq 0x21c0
testq %rax, %rax
je 0x30da
movq %rax, %r12
movq %rsp, %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x2544
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x2e01
movq %rax, %rbx
movq %r12, %rdi
callq 0x2170
jmp 0x30ea
leaq 0x158f2(%rip), %rax     # 0x189d3
movq %rax, 0x1a110(%rip)     # 0x1d1f8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_is_hdr_from_memory
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
{
   #ifndef STBI_NO_HDR
   stbi__context s;
   stbi__start_mem(&s,buffer,len);
   return stbi__hdr_test(&s);
   #else
   STBI_NOTUSED(buffer);
   STBI_NOTUSED(len);
   return 0;
   #endif
}

// Assembly:
subq $0xd8, %rsp
movq %rsp, %rax
movq $0x0, 0x10(%rax)
movl $0x0, 0x30(%rax)
movq %rdi, 0xc8(%rax)
movq %rdi, 0xb8(%rax)
movslq %esi, %rcx
addq %rdi, %rcx
movq %rcx, 0xd0(%rax)
movq %rcx, 0xc0(%rax)
movq %rax, %rdi
callq 0x319b
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__hdr_test(stbi__context*)
static int stbi__hdr_test(stbi__context* s)
{
   int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
   stbi__rewind(s);
   if(!r) {
       r = stbi__hdr_test_core(s, "#?RGBE\n");
       stbi__rewind(s);
   }
   return r;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x16372(%rip), %rsi     # 0x19518
callq 0x15f42
movups 0xc8(%rbx), %xmm0
movups %xmm0, 0xb8(%rbx)
testl %eax, %eax
je 0x31c4
movl $0x1, %eax
popq %rbx
retq
leaq 0x16359(%rip), %rsi     # 0x19524
movq %rbx, %rdi
callq 0x15f42
movups 0xc8(%rbx), %xmm0
movups %xmm0, 0xb8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_is_hdr
STBIDEF int      stbi_is_hdr          (char const *filename)
{
   FILE *f = stbi__fopen(filename, "rb");
   int result=0;
   if (f) {
      result = stbi_is_hdr_from_file(f);
      fclose(f);
   }
   return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x157e3(%rip), %rsi     # 0x189d0
callq 0x21c0
testq %rax, %rax
je 0x3210
movq %rax, %rbx
movq %rax, %rdi
callq 0x3219
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2170
movl %ebp, %eax
jmp 0x3212
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_is_hdr_from_file
STBIDEF int stbi_is_hdr_from_file(FILE *f)
{
   #ifndef STBI_NO_HDR
   long pos = ftell(f);
   int res;
   stbi__context s;
   stbi__start_file(&s,f);
   res = stbi__hdr_test(&s);
   fseek(f, pos, SEEK_SET);
   return res;
   #else
   STBI_NOTUSED(f);
   return 0;
   #endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
callq 0x2030
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2544
movq %r15, %rdi
callq 0x319b
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21a0
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_is_hdr_from_callbacks
static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)
{
   s->io = *c;
   s->io_user_data = user;
   s->buflen = sizeof(s->buffer_start);
   s->read_from_callbacks = 1;
   s->img_buffer_original = s->buffer_start;
   stbi__refill_buffer(s);
   s->img_buffer_original_end = s->img_buffer_end;
}

// Assembly:
pushq %rbx
subq $0xe0, %rsp
movq 0x10(%rdi), %rax
leaq 0x40(%rsp), %rbx
movq %rax, -0x18(%rbx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rbx)
movq %rsi, -0x10(%rbx)
movabsq $0x8000000001, %rax     # imm = 0x8000000001
movq %rax, -0x8(%rbx)
movq %rbx, 0x90(%rbx)
movq %rsi, %rdi
movq %rbx, %rsi
movl $0x80, %edx
callq *-0x28(%rbx)
testl %eax, %eax
je 0x32b4
cltq
addq %rbx, %rax
jmp 0x32c4
leaq 0x41(%rsp), %rax
movl $0x0, -0x9(%rax)
movb $0x0, -0x1(%rax)
leaq 0x8(%rsp), %rdi
movq %rbx, 0xb8(%rdi)
movq %rax, 0xc0(%rdi)
movq %rax, 0xd0(%rdi)
callq 0x319b
addq $0xe0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_zlib_decode_malloc_guesssize
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(initial_size);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer + len;
   if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %rdi
callq 0x2200
testq %rax, %rax
je 0x3396
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movslq %r15d, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl %ebp, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x33ad
testl %eax, %eax
je 0x338c
testq %rbx, %rbx
je 0x33a6
movl 0x20(%rsp), %ecx
movq 0x28(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x3398
movq 0x28(%rsp), %rdi
callq 0x21d0
xorl %eax, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rax
jmp 0x3398
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_zlib_decode_malloc_guesssize_headerflag
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(initial_size);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer + len;
   if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %r8d, %ebp
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
movslq %edx, %rdi
callq 0x2200
testq %rax, %rax
je 0x3dde
movq %rsp, %rdi
movq %r15, (%rdi)
movslq %r12d, %rcx
addq %r15, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl %r14d, %edx
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x33ad
testl %eax, %eax
je 0x3dd4
testq %rbx, %rbx
je 0x3df0
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x3de0
movq 0x20(%rsp), %rdi
callq 0x21d0
xorl %eax, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rax
jmp 0x3de0
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_zlib_decode_noheader_malloc
STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
{
   stbi__zbuf a;
   char *p = (char *) stbi__malloc(16384);
   if (p == NULL) return NULL;
   a.zbuffer = (stbi_uc *) buffer;
   a.zbuffer_end = (stbi_uc *) buffer+len;
   if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
      if (outlen) *outlen = (int) (a.zout - a.zout_start);
      return a.zout_start;
   } else {
      STBI_FREE(a.zout_start);
      return NULL;
   }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x4000, %edi           # imm = 0x4000
callq 0x2200
testq %rax, %rax
je 0x3ead
movq %rsp, %rdi
movq %r14, (%rdi)
movslq %ebp, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl $0x4000, %edx           # imm = 0x4000
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x33ad
testl %eax, %eax
je 0x3ea3
testq %rbx, %rbx
je 0x3ebb
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
subl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x3eaf
movq 0x20(%rsp), %rdi
callq 0x21d0
xorl %eax, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%rsp), %rax
jmp 0x3eaf
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_info
STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
{
    FILE *f = stbi__fopen(filename, "rb");
    int result;
    if (!f) return stbi__err("can't fopen", "Unable to open file");
    result = stbi_info_from_file(f, x, y, comp);
    fclose(f);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x14a9e(%rip), %rsi     # 0x189d0
callq 0x21c0
testq %rax, %rax
je 0x3f5e
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3f7a
movl %eax, %ebx
movq %r12, %rdi
callq 0x2170
movl %ebx, %eax
jmp 0x3f6e
leaq 0x14a6e(%rip), %rax     # 0x189d3
movq %rax, 0x1928c(%rip)     # 0x1d1f8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_info_from_file
STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)
{
   int r;
   stbi__context s;
   long pos = ftell(f);
   stbi__start_file(&s, f);
   r = stbi__info_main(&s,x,y,comp);
   fseek(f,pos,SEEK_SET);
   return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x2030
movq %rax, %r13
movq %rsp, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2544
movq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3fe1
movl %eax, %ebx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x21a0
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_is_16_bit
STBIDEF int stbi_is_16_bit(char const *filename)
{
    FILE *f = stbi__fopen(filename, "rb");
    int result;
    if (!f) return stbi__err("can't fopen", "Unable to open file");
    result = stbi_is_16_bit_from_file(f);
    fclose(f);
    return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x147c6(%rip), %rsi     # 0x189d0
callq 0x21c0
testq %rax, %rax
je 0x422d
movq %rax, %rbx
movq %rax, %rdi
callq 0x4244
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2170
movl %ebp, %eax
jmp 0x423d
leaq 0x1479f(%rip), %rax     # 0x189d3
movq %rax, 0x18fbd(%rip)     # 0x1d1f8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi_is_16_bit_from_file
STBIDEF int stbi_is_16_bit_from_file(FILE *f)
{
   int r;
   stbi__context s;
   long pos = ftell(f);
   stbi__start_file(&s, f);
   r = stbi__is_16_main(&s);
   fseek(f,pos,SEEK_SET);
   return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
callq 0x2030
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2544
movq %r15, %rdi
callq 0x4291
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21a0
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__is_16_main(stbi__context*)
static int stbi__is_16_main(stbi__context *s)
{
   #ifndef STBI_NO_PNG
   if (stbi__png_is16(s))  return 1;
   #endif

   #ifndef STBI_NO_PSD
   if (stbi__psd_is16(s))  return 1;
   #endif

   return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
movq %rbx, (%rdi)
movl $0x2, %esi
xorl %edx, %edx
callq 0x10f8c
testl %eax, %eax
je 0x42c1
cmpl $0x10, 0x20(%rsp)
jne 0x42c1
movl $0x1, %eax
jmp 0x439e
movq (%rsp), %rax
movups 0xc8(%rax), %xmm0
movups %xmm0, 0xb8(%rax)
movq %rbx, %rdi
callq 0xfc21
movl %eax, %ebp
shll $0x10, %ebp
movq %rbx, %rdi
callq 0xfc21
orl %ebp, %eax
cmpl $0x38425053, %eax       # imm = 0x38425053
jne 0x438e
movq %rbx, %rdi
callq 0xfc21
cmpl $0x1, %eax
jne 0x438e
cmpq $0x0, 0x10(%rbx)
je 0x433b
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rdx
movl %edx, %ecx
subl %eax, %ecx
cmpl $0x5, %ecx
jg 0x4342
movq %rdx, 0xb8(%rbx)
movq 0x28(%rbx), %rdi
movl $0x6, %esi
subl %ecx, %esi
callq *0x18(%rbx)
jmp 0x434d
movq 0xb8(%rbx), %rax
addq $0x6, %rax
movq %rax, 0xb8(%rbx)
movq %rbx, %rdi
callq 0xfc21
cmpl $0x10, %eax
ja 0x438e
movq %rbx, %rdi
callq 0xfc21
movq %rbx, %rdi
callq 0xfc21
movq %rbx, %rdi
callq 0xfc21
movq %rbx, %rdi
callq 0xfc21
movq %rbx, %rdi
callq 0xfc21
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x10, %ecx
je 0x439e
movups 0xc8(%rbx), %xmm0
movups %xmm0, 0xb8(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/png2tlg.cpp
// Function: SlideCompressor::SlideCompressor()
SlideCompressor::SlideCompressor()
{
	S = 0;
	for(int i = 0; i < SLIDE_N + SLIDE_M - 1; i++) Text[i] = 0;
	for(int i = 0; i < 256*256; i++)
		Map[i] = -1;
	for(int i = 0; i < SLIDE_N; i++)
		Chains[i].Prev = Chains[i].Next = -1;
	for(int i = SLIDE_N - 1; i >= 0; i--)
		AddMap(i);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x187ee(%rip), %rax     # 0x1cd70
movq %rax, (%rdi)
movl $0x0, 0x92228(%rdi)
addq $0x8, %rdi
xorl %r14d, %r14d
movl $0x1110, %edx           # imm = 0x1110
xorl %esi, %esi
callq 0x20e0
leaq 0x1118(%rbx), %rdi
movl $0x48000, %edx          # imm = 0x48000
movl $0xff, %esi
callq 0x20e0
movzbl 0x1007(%rbx,%r14), %eax
leal 0x1000(%r14), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movzbl 0x8(%rbx,%rcx), %ecx
shll $0xa, %ecx
leal (%rcx,%rax,4), %edx
movslq 0x1118(%rbx,%rdx), %rax
leaq 0xfff(%r14), %rcx
movl %ecx, 0x1118(%rbx,%rdx)
cmpq $-0x1, %rax
je 0x4610
movl %ecx, 0x41118(%rbx,%rax,8)
movl %eax, 0x49114(%rbx,%r14,8)
movl $0xffffffff, 0x49110(%rbx,%r14,8) # imm = 0xFFFFFFFF
decq %r14
cmpq $-0x1000, %r14          # imm = 0xF000
jne 0x45b8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/png2tlg.cpp
// Function: SlideCompressor::GetMatch(unsigned char const*, int, int&, int)
int SlideCompressor::GetMatch(const unsigned char*cur, int curlen, int &pos, int s)
{
	// get match length
	if(curlen < 3) return 0;

	int place = cur[0] + ((int)cur[1] << 8);

	int maxlen = 0;
	if((place = Map[place]) != -1)
	{
		int place_org;
		curlen -= 1;
		do
		{
			place_org = place;
			if(s == place || s == ((place + 1) & (SLIDE_N -1))) continue;
			place += 2;
			int lim = (SLIDE_M < curlen ? SLIDE_M : curlen) + place_org;
			const unsigned char *c = cur + 2;
			if(lim >= SLIDE_N)
			{
				if(place_org <= s && s < SLIDE_N)
					lim = s;
				else if(s < (lim&(SLIDE_N-1)))
					lim = s + SLIDE_N;
			}
			else
			{
				if(place_org <= s && s < lim)
					lim = s;
			}
			while(Text[place] == *(c++) && place < lim) place++;
			int matchlen = place - place_org;
			if(matchlen > maxlen) pos = place_org, maxlen = matchlen;
			if(matchlen == SLIDE_M) return maxlen;

		} while((place = Chains[place_org].Next) != -1);
	}
	return maxlen;
}

// Assembly:
xorl %eax, %eax
cmpl $0x3, %edx
jl 0x4795
movzwl (%rsi), %r9d
movl 0x1118(%rdi,%r9,4), %r9d
cmpl $-0x1, %r9d
je 0x4795
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x112, %r10d           # imm = 0x112
cmpl %r10d, %edx
cmovbl %edx, %r10d
decl %r10d
leal 0x1000(%r8), %eax
movl %eax, -0x4(%rsp)
leaq 0x9(%rdi), %r11
xorl %eax, %eax
cmpl %r8d, %r9d
je 0x4776
leal 0x1(%r9), %ebx
andl $0xfff, %ebx            # imm = 0xFFF
cmpl %r8d, %ebx
je 0x4776
leal (%r10,%r9), %ebx
cmpl $0x1000, %ebx           # imm = 0x1000
jl 0x4715
cmpl $0xfff, %r8d            # imm = 0xFFF
jg 0x4701
movl %r8d, %ebp
cmpl %r8d, %r9d
jle 0x4724
movl %ebx, %ebp
andl $0xfff, %ebp            # imm = 0xFFF
cmpl %r8d, %ebp
cmovgl -0x4(%rsp), %ebx
movl %ebx, %ebp
jmp 0x4724
cmpl %r8d, %ebx
movl %r8d, %ebp
cmovll %ebx, %ebp
cmpl %r8d, %r9d
cmovgl %ebx, %ebp
leal 0x2(%r9), %ebx
movslq %ebx, %r14
movb 0x8(%rdi,%r14), %r15b
cmpb 0x2(%rsi), %r15b
jne 0x4762
cmpl %ebp, %ebx
jge 0x4762
movslq %ebp, %r15
leaq (%r11,%r14), %r12
incq %r14
xorl %ebp, %ebp
movb (%r12,%rbp), %dl
leaq 0x1(%rbp), %r13
cmpb 0x3(%rsi,%rbp), %dl
jne 0x475f
addq %r14, %rbp
cmpq %r15, %rbp
movq %r13, %rbp
jl 0x4746
addl %r13d, %ebx
subl %r9d, %ebx
cmpl %eax, %ebx
jle 0x476e
movl %r9d, (%rcx)
movl %ebx, %eax
cmpl $0x111, %ebx            # imm = 0x111
je 0x478b
movslq %r9d, %rdx
movl 0x4111c(%rdi,%rdx,8), %r9d
cmpl $-0x1, %r9d
jne 0x46c8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/png2tlg.cpp
// Function: SlideCompressor::DeleteMap(int)
void SlideCompressor::DeleteMap(int p)
{
	int n;
	if((n = Chains[p].Next) != -1)
		Chains[n].Prev = Chains[p].Prev;

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

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

// Assembly:
movslq %esi, %rax
movslq 0x4111c(%rdi,%rax,8), %rcx
movl 0x41118(%rdi,%rax,8), %edx
cmpq $-0x1, %rcx
je 0x47dc
movl %edx, 0x41118(%rdi,%rcx,8)
cmpl $-0x1, %edx
jne 0x47e1
movzbl 0x8(%rdi,%rax), %edx
leal 0x1(%rax), %esi
andl $0xfff, %esi            # imm = 0xFFF
movzbl 0x8(%rdi,%rsi), %esi
shll $0xa, %esi
leal (%rsi,%rdx,4), %edx
movl %ecx, 0x1118(%rdi,%rdx)
jmp 0x47eb
cmpl $-0x1, %edx
je 0x47f8
movslq %edx, %rdx
movl %ecx, 0x4111c(%rdi,%rdx,8)
movq $-0x1, 0x41118(%rdi,%rax,8)
retq
movzbl 0x8(%rdi,%rax), %ecx
leal 0x1(%rax), %edx
andl $0xfff, %edx            # imm = 0xFFF
movzbl 0x8(%rdi,%rdx), %edx
shll $0xa, %edx
leal (%rdx,%rcx,4), %ecx
movl $0xffffffff, 0x1118(%rdi,%rcx) # imm = 0xFFFFFFFF
jmp 0x47eb
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/png2tlg.cpp
// Function: SlideCompressor::Store()
void SlideCompressor::Store()
{
	S2 = S;
	int i;
	for(i = 0; i < SLIDE_N + SLIDE_M - 1; i++)
		Text2[i] = Text[i];

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

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

// Assembly:
movl 0x92228(%rdi), %eax
movl %eax, 0x9222c(%rdi)
movq $-0x1110, %rax          # imm = 0xEEF0
movups 0x1118(%rdi,%rax), %xmm0
movups %xmm0, 0x4a228(%rdi,%rax)
addq $0x10, %rax
jne 0x4b9d
movq $-0x10000, %rax         # imm = 0xFFFF0000
movups 0x41118(%rdi,%rax,4), %xmm0
movups %xmm0, 0x8a228(%rdi,%rax,4)
addq $0x4, %rax
jne 0x4bba
xorl %eax, %eax
movups 0x41118(%rdi,%rax,8), %xmm0
movups %xmm0, 0x8a228(%rdi,%rax,8)
addq $0x2, %rax
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x4bd2
retq
nop
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/png2tlg.cpp
// Function: SlideCompressor::Restore()
void SlideCompressor::Restore()
{
	S = S2;
	int i;
	for(i = 0; i < SLIDE_N + SLIDE_M - 1; i++)
		Text[i] = Text2[i];

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x9222c(%rdi), %eax
movl %eax, 0x92228(%rdi)
leaq 0x49118(%rdi), %rsi
addq $0x8, %rdi
movl $0x1110, %edx           # imm = 0x1110
callq 0x2140
leaq 0x4a228(%rbx), %rsi
leaq 0x1118(%rbx), %rdi
movl $0x40000, %edx          # imm = 0x40000
callq 0x2140
leaq 0x8a228(%rbx), %rsi
addq $0x41118, %rbx          # imm = 0x41118
movl $0x8000, %edx           # imm = 0x8000
movq %rbx, %rdi
popq %rbx
jmp 0x2140
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/png2tlg.cpp
// Function: TVPTLG6InitGolombTable()
void TVPTLG6InitGolombTable()
{
	if(TVPTLG6GolombTableInit) return;
	for(int n = 0; n < TVP_TLG6_GOLOMB_N_COUNT; n++)
	{
		int a = 0;
		for(int i = 0; i < 9; i++)
		{
			for(int j = 0; j < TVPTLG6GolombCompressed[n][i]; j++)
				TVPTLG6GolombBitLengthTable[a++][n] = (char)i;
		}
		if(a != TVP_TLG6_GOLOMB_N_COUNT*2*128)
			*(char*)0 = 0;   // THIS MUST NOT BE EXECUETED!
				// (this is for compressed table data check)
	}
	TVPTLG6GolombTableInit = true;
}

// Assembly:
cmpb $0x0, 0x195c0(%rip)     # 0x1e210
jne 0x4cb1
leaq 0x185b7(%rip), %rax     # 0x1d210
xorl %ecx, %ecx
leaq 0x137ae(%rip), %rdx     # 0x18410
leaq (%rcx,%rcx,8), %rsi
leaq (%rdx,%rsi,2), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movswl (%rsi,%rdi,2), %r10d
testl %r10d, %r10d
jle 0x4c95
movslq %r8d, %r9
leaq (%rax,%r9,4), %r9
movl %r10d, %r10d
xorl %r11d, %r11d
movb %dil, (%r9,%r11,4)
incq %r11
cmpl %r11d, %r10d
jne 0x4c86
addl %r11d, %r8d
incq %rdi
cmpq $0x9, %rdi
jne 0x4c6f
incq %rcx
incq %rax
cmpq $0x4, %rcx
jne 0x4c62
movb $0x1, 0x1955f(%rip)     # 0x1e210
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/png2tlg.cpp
// Function: main
int main(int argc, char *argv[])
{
	if (argc != 3) {
		std::cerr << "usage: " << argv[0] << " input output" << std::endl;
		return 1;
	}
	tTVPBaseBitmap bmp(argv[1]);
	std::fstream fs(argv[2], std::fstream::out | std::fstream::binary);
	SaveTLG6( &fs, &bmp, false );
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
cmpl $0x3, %edi
jne 0x67dc
movq 0x8(%r14), %rsi
movq %rsp, %rdi
leaq 0x38(%rsp), %rdx
callq 0x16e94
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x16ed2
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x679d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
movq 0x10(%r14), %rsi
leaq 0x38(%rsp), %rdi
movl $0x14, %edx
callq 0x2210
leaq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x5ba8
leaq 0x38(%rsp), %rdi
callq 0x2070
movq 0x30(%rsp), %rdi
callq 0x21d0
jmp 0x6872
movq 0x16805(%rip), %rbx     # 0x1cfe8
leaq 0x1221c(%rip), %rsi     # 0x18a06
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21b0
movq (%r14), %r14
testq %r14, %r14
je 0x681b
movq %r14, %rdi
callq 0x20c0
movq 0x167da(%rip), %rdi     # 0x1cfe8
movq %r14, %rsi
movq %rax, %rdx
callq 0x21b0
jmp 0x6832
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x22e0
leaq 0x121d5(%rip), %rsi     # 0x18a0e
movl $0xd, %edx
movq %rbx, %rdi
callq 0x21b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x2100
movl $0x1, %ebx
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2070
jmp 0x6891
movq %rax, %rbx
movq 0x30(%rsp), %rdi
callq 0x21d0
jmp 0x68c0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68c0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x68c0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__vertical_flip(void*, int, int, int)
static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)
{
   int row;
   size_t bytes_per_row = (size_t)w * bytes_per_pixel;
   stbi_uc temp[2048];
   stbi_uc *bytes = (stbi_uc *)image;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x838, %rsp            # imm = 0x838
movq %rdi, 0x20(%rsp)
movl %edx, 0x14(%rsp)
movl %edx, %eax
sarl %eax
testl %eax, %eax
jle 0xa548
movslq %esi, %rdx
movslq %ecx, %rcx
imulq %rdx, %rcx
movq %rcx, 0x18(%rsp)
movl %eax, %eax
movq %rax, 0x28(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x800, %ebx            # imm = 0x800
leaq 0x30(%rsp), %r15
cmpq $0x0, 0x18(%rsp)
je 0xa530
movq 0x8(%rsp), %rcx
movl %ecx, %eax
notl %eax
addl 0x14(%rsp), %eax
movslq %eax, %r12
movq 0x18(%rsp), %r14
imulq %r14, %r12
movq 0x20(%rsp), %rax
addq %rax, %r12
movq %r14, %r13
imulq %rcx, %r13
addq %rax, %r13
cmpq %rbx, %r14
movl $0x800, %ebp            # imm = 0x800
cmovbq %r14, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x2140
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x2140
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x2140
addq %rbp, %r13
addq %rbp, %r12
subq %rbp, %r14
jne 0xa4ef
movq 0x8(%rsp), %rcx
incq %rcx
movq %rcx, 0x8(%rsp)
cmpq 0x28(%rsp), %rcx
jne 0xa4bc
addq $0x838, %rsp            # imm = 0x838
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zhiyb[P]png2tlg/./stb_image.h
// Function: stbi__pnm_test(stbi__context*)
static int      stbi__pnm_test(stbi__context *s)
{
   char p, t;
   p = (char) stbi__get8(s);
   t = (char) stbi__get8(s);
   if (p != 'P' || (t != '5' && t != '6')) {
       stbi__rewind( s );
       return 0;
   }
   return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb8(%rdi), %rcx
movq 0xc0(%rdi), %rax
cmpq %rax, %rcx
jae 0xc69d
leaq 0x1(%rcx), %rdx
movq %rdx, 0xb8(%rbx)
movb (%rcx), %bpl
movq %rdx, %rcx
jmp 0xc6e9
cmpl $0x0, 0x30(%rbx)
je 0xc6c2
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %r14
movl 0x34(%rbx), %edx
movq %r14, %rsi
callq *0x10(%rbx)
testl %eax, %eax
je 0xc6c6
cltq
addq %r14, %rax
movb (%r14), %bpl
jmp 0xc6d7
xorl %ebp, %ebp
jmp 0xc6e9
movl $0x0, 0x30(%rbx)
leaq 0x39(%rbx), %rax
movb $0x0, 0x38(%rbx)
xorl %ebp, %ebp
movq %rax, 0xc0(%rbx)
leaq 0x39(%rbx), %rcx
movq %rcx, 0xb8(%rbx)
cmpq %rax, %rcx
jae 0xc6fd
leaq 0x1(%rcx), %rax
movq %rax, 0xb8(%rbx)
movb (%rcx), %cl
jmp 0xc745
cmpl $0x0, 0x30(%rbx)
je 0xc758
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %r14
movl 0x34(%rbx), %edx
movq %r14, %rsi
callq *0x10(%rbx)
testl %eax, %eax
je 0xc722
cltq
addq %r14, %rax
movb (%r14), %cl
jmp 0xc733
movl $0x0, 0x30(%rbx)
leaq 0x39(%rbx), %rax
movb $0x0, 0x38(%rbx)
xorl %ecx, %ecx
movq %rax, 0xc0(%rbx)
leaq 0x39(%rbx), %rax
movq %rax, 0xb8(%rbx)
cmpb $0x50, %bpl
jne 0xc758
addb $-0x37, %cl
movl $0x1, %eax
cmpb $-0x3, %cl
ja 0xc768
movups 0xc8(%rbx), %xmm0
movups %xmm0, 0xb8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq