LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/o.c
// Function: dumpo
V dumpo(O o,I n){
    L i;I m=n*2;while(m-->0)putchar(' ');
    switch(o->t){
    case TD:printf("%f\n",o->d);BK;
    case TS:putchar('"');for(i=0;i<o->s.z;i++){C c=o->s.s[i];if(c>=ECOFF&&c<(ECOFF+sizeof(ecm)))printf("\\%c",ecm[c-ECOFF]);else putchar(c);}puts("\"");BK;
    case TA:puts("[]");for(i=0;i<len(o->a);++i)dumpo(o->a->st[i],n+1);BK;
    case TCB:printf("{%s}\n",o->s.s);BK;
    case TR:puts(":");dumpo(o->e.k,n+1);dumpo(o->e.v,n+1);BK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal 0x1(,%r14,2), %r12d
leaq 0x2725(%rip), %r15      # 0x93ea
testl %r14d, %r14d
jle 0x6ce0
movl %r12d, %r13d
movl $0x20, %edi
callq 0x2040
decl %r13d
cmpl $0x1, %r13d
jg 0x6ccd
movl (%rbx), %eax
cmpl $0x4, %eax
jne 0x6d08
movq %r15, %rdi
callq 0x2080
movq 0x8(%rbx), %rdi
incl %r14d
movl %r14d, %esi
callq 0x6ca2
movq 0x10(%rbx), %rbx
addl $0x2, %r12d
jmp 0x6cc5
jae 0x6d76
movl %eax, %eax
leaq 0x25a1(%rip), %rcx      # 0x92b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x8(%rbx), %xmm0
leaq 0x26af(%rip), %rdi      # 0x93d7
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
leaq 0x269d(%rip), %rdi      # 0x93e1
callq 0x2080
movq 0x8(%rbx), %rax
cmpq $0x0, 0x8(%rax)
je 0x6d76
incl %r14d
xorl %r15d, %r15d
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
movl %r14d, %esi
callq 0x6ca2
incq %r15
movq 0x8(%rbx), %rax
cmpq 0x8(%rax), %r15
jb 0x6d5a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rsi
leaq 0x2654(%rip), %rdi      # 0x93e4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
movl $0x22, %edi
callq 0x2040
cmpq $0x0, 0x10(%rbx)
je 0x6df9
leaq 0x6547(%rip), %r15      # 0xd304
leaq 0x2617(%rip), %r14      # 0x93db
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movsbl (%rax,%r12), %edi
leal -0x7(%rdi), %eax
cmpb $0x6, %al
ja 0x6deb
addl $-0x7, %edi
movsbl (%rdi,%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2100
jmp 0x6df0
callq 0x2040
incq %r12
cmpq 0x10(%rbx), %r12
jb 0x6dc7
leaq 0x25df(%rip), %rdi      # 0x93df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/o.c
// Function: repl
V repl(){ //repl
    C b[BZ];isrepl=1;printf("O REPL");for(;;){
        printf("\n>>> ");if(!fgets(b,BZ,stdin))BK; //get line
        if(!setjmp(jb))excs(b,0); //run line
    }excs("",1); //cleanup
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movl $0x1, 0x6393(%rip)      # 0xd320
leaq 0x24b3(%rip), %rdi      # 0x9447
xorl %eax, %eax
movl %eax, %ebx
callq 0x2100
leaq 0x24aa(%rip), %rdi      # 0x944e
movl %ebx, %eax
callq 0x2100
movq 0x5fde(%rip), %rax      # 0xcf90
movq (%rax), %rdx
leaq -0x830(%rbp), %rdi
movl $0x800, %esi            # imm = 0x800
callq 0x2150
testq %rax, %rax
je 0x7026
leaq 0x675e(%rip), %rbx      # 0xd730
leaq -0x830(%rbp), %r14
xorl %eax, %eax
leaq 0x246c(%rip), %r12      # 0x944e
movl %eax, %r13d
movl $0x800, %r15d           # imm = 0x800
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
jne 0x7001
movq %r14, %rdi
xorl %esi, %esi
callq 0x6e5d
movq %r12, %rdi
movl %r13d, %eax
callq 0x2100
movq 0x5f7d(%rip), %rax      # 0xcf90
movq (%rax), %rdx
movq %r14, %rdi
movl %r15d, %esi
callq 0x2150
testq %rax, %rax
jne 0x6feb
leaq 0x23ad(%rip), %rdi      # 0x93da
movl $0x1, %esi
callq 0x6e5d
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regaux.c
// Function: renewmatch
extern void
_renewmatch(Resub *mp, int ms, Resublist *sp)
{
	int i;

	if(mp==0 || ms<=0)
		return;
	if(mp[0].s.sp==0 || sp->m[0].s.sp<mp[0].s.sp ||
	   (sp->m[0].s.sp==mp[0].s.sp && sp->m[0].e.ep>mp[0].e.ep)){
		for(i=0; i<ms && i<NSUBEXP; i++)
			mp[i] = sp->m[i];
		for(; i<ms; i++)
			mp[i].s.sp = mp[i].e.ep = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
jne 0x72bf
movq (%rdi), %rax
testq %rax, %rax
je 0x7254
cmpq %rax, (%rdx)
jae 0x728b
testl %esi, %esi
jle 0x7299
leal -0x1(%rsi), %ecx
cmpq $0x1f, %rcx
movl $0x1f, %eax
cmovbq %rcx, %rax
movl %eax, %ecx
shll $0x4, %ecx
addq $0x10, %rcx
incl %eax
xorl %r8d, %r8d
movups (%rdx,%r8), %xmm0
movups %xmm0, (%rdi,%r8)
addq $0x10, %r8
cmpq %r8, %rcx
jne 0x7276
jmp 0x729b
jne 0x72bf
movq 0x8(%rdx), %rax
cmpq 0x8(%rdi), %rax
ja 0x7254
jmp 0x72bf
xorl %eax, %eax
cmpl %esi, %eax
jge 0x72bf
movl %eax, %ecx
shlq $0x4, %rcx
addq %rcx, %rdi
notl %eax
addl %esi, %eax
shlq $0x4, %rax
addq $0x10, %rax
xorl %esi, %esi
movq %rax, %rdx
popq %rbp
jmp 0x2120
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regaux.c
// Function: renewthread
extern Relist*
_renewthread(Relist *lp,	/* _relist to add to */
	Reinst *ip,		/* instruction to add */
	int ms,
	Resublist *sep)		/* pointers to subexpressions */
{
	Relist *p;

	for(p=lp; p->inst; p++){
		if(p->inst == ip){
			if(sep->m[0].s.sp < p->se.m[0].s.sp){
				if(ms > 1)
					p->se = *sep;
				else
					p->se.m[0] = sep->m[0];
			}
			return 0;
		}
	}
	p->inst = ip;
	if(ms > 1)
		p->se = *sep;
	else
		p->se.m[0] = sep->m[0];
	(++p)->inst = 0;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x72e7
cmpq %rsi, %rax
je 0x731c
movq 0x208(%rbx), %rax
addq $0x208, %rbx            # imm = 0x208
jmp 0x72cd
movq %rsi, (%rbx)
leaq 0x8(%rbx), %rdi
cmpl $0x2, %edx
jl 0x7302
movl $0x200, %edx            # imm = 0x200
movq %rcx, %rsi
callq 0x21b0
jmp 0x7308
movups (%rcx), %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x208(%rbx)
addq $0x208, %rbx            # imm = 0x208
jmp 0x7348
movq (%rcx), %rax
cmpq 0x8(%rbx), %rax
jae 0x7346
addq $0x8, %rbx
cmpl $0x2, %edx
jl 0x7340
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x21b0
jmp 0x7346
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regaux.c
// Function: renewemptythread
extern Relist*
_renewemptythread(Relist *lp,	/* _relist to add to */
	Reinst *ip,		/* instruction to add */
	int ms,
	char *sp)		/* pointers to subexpressions */
{
	Relist *p;

	for(p=lp; p->inst; p++){
		if(p->inst == ip){
			if(sp < p->se.m[0].s.sp) {
				if(ms > 1)
					memset(&p->se, 0, sizeof(p->se));
				p->se.m[0].s.sp = sp;
			}
			return 0;
		}
	}
	p->inst = ip;
	if(ms > 1)
		memset(&p->se, 0, sizeof(p->se));
	p->se.m[0].s.sp = sp;
	(++p)->inst = 0;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x737c
cmpq %rsi, %rax
je 0x73ac
movq 0x208(%rbx), %rax
addq $0x208, %rbx            # imm = 0x208
jmp 0x7362
movq %rsi, (%rbx)
cmpl $0x2, %edx
jl 0x7394
leaq 0x8(%rbx), %rdi
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x2120
movq %r14, 0x8(%rbx)
movq $0x0, 0x208(%rbx)
addq $0x208, %rbx            # imm = 0x208
jmp 0x73cf
cmpq %r14, 0x8(%rbx)
jbe 0x73cd
addq $0x8, %rbx
cmpl $0x2, %edx
jl 0x73ca
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2120
movq %r14, (%rbx)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regaux.c
// Function: rrenewemptythread
extern Relist*
_rrenewemptythread(Relist *lp,	/* _relist to add to */
	Reinst *ip,		/* instruction to add */
	int ms,
	Rune *rsp)		/* pointers to subexpressions */
{
	Relist *p;

	for(p=lp; p->inst; p++){
		if(p->inst == ip){
			if(rsp < p->se.m[0].s.rsp) {
				if(ms > 1)
					memset(&p->se, 0, sizeof(p->se));
				p->se.m[0].s.rsp = rsp;
			}
			return 0;
		}
	}
	p->inst = ip;
	if(ms > 1)
		memset(&p->se, 0, sizeof(p->se));
	p->se.m[0].s.rsp = rsp;
	(++p)->inst = 0;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x7401
cmpq %rsi, %rax
je 0x7431
movq 0x208(%rbx), %rax
addq $0x208, %rbx            # imm = 0x208
jmp 0x73e7
movq %rsi, (%rbx)
cmpl $0x2, %edx
jl 0x7419
leaq 0x8(%rbx), %rdi
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x2120
movq %r14, 0x8(%rbx)
movq $0x0, 0x208(%rbx)
addq $0x208, %rbx            # imm = 0x208
jmp 0x7454
cmpq %r14, 0x8(%rbx)
jbe 0x7452
addq $0x8, %rbx
cmpl $0x2, %edx
jl 0x744f
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2120
movq %r14, (%rbx)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regcomp.c
// Function: pushator
static	void
pushator(int t)
{
	if(atorp >= &atorstack[NSTACK])
		cant("operator stack overflow");
	*atorp++ = t;
	*subidp++ = cursubid;
}

// Assembly:
leaq 0x66ce(%rip), %rax      # 0xe1f0
cmpq %rax, 0x66c7(%rip)      # 0xe1f0
jae 0x7b5a
movq 0x66be(%rip), %rax      # 0xe1f0
leaq 0x4(%rax), %rcx
movq %rcx, 0x66b3(%rip)      # 0xe1f0
movl %edi, (%rax)
movl 0x6867(%rip), %eax      # 0xe3ac
movq 0x6854(%rip), %rcx      # 0xe3a0
leaq 0x4(%rcx), %rdx
movq %rdx, 0x6849(%rip)      # 0xe3a0
movl %eax, (%rcx)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x19ee(%rip), %rdi      # 0x9553
callq 0x7f30
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regcomp.c
// Function: operand
static	void
operand(int t)
{
	Reinst *i;

	if(lastwasand)
		operator(CAT);	/* catenate is implicit */
	i = newinst(t);

	if(t == CCLASS || t == NCCLASS)
		i->r.cp = yyclassp;
	if(t == RUNE)
		i->r.r = yyrune;

	pushand(i, i);
	lastwasand = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpb $0x1, 0x682f(%rip)      # 0xe3a8
jne 0x7b96
movl $0x84, %edi
callq 0x7c16
movl $0x84, %edi
callq 0x7b1b
movb $0x0, 0x6812(%rip)      # 0xe3a8
movq 0x6503(%rip), %rax      # 0xe0a0
movl %ebx, (%rax)
leaq 0x8(%rax), %rcx
leaq 0x18(%rax), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rdx, 0x64eb(%rip)      # 0xe0a0
leal -0xc5(%rbx), %edx
cmpl $0x1, %edx
ja 0x7bca
movq 0x67f1(%rip), %rdx      # 0xe3b8
movq %rdx, (%rcx)
cmpl $0x7f, %ebx
jne 0x7bd7
movl 0x67db(%rip), %edx      # 0xe3b0
movl %edx, (%rcx)
movq 0x6762(%rip), %rcx      # 0xe340
leaq 0x675b(%rip), %rdx      # 0xe340
cmpq %rdx, %rcx
jae 0x7c0a
movq %rax, (%rcx)
movq %rax, 0x8(%rcx)
addq $0x10, %rcx
movq %rcx, 0x6744(%rip)      # 0xe340
movb $0x1, 0x67a5(%rip)      # 0xe3a8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1a00(%rip), %rdi      # 0x9611
callq 0x7f30
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regcomp.c
// Function: cant
static	void
cant(char *s)
{
	char buf[100];
	strncpy(buf, "can't happen: ", sizeof(buf));
	strncat(buf, s, sizeof(buf)-1);
	rcerror(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x1567(%rip), %rsi      # 0x94ac
leaq -0x80(%rbp), %r14
movl $0x64, %edx
movq %r14, %rdi
callq 0x21b0
movl $0x63, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2130
incl 0x6144(%rip)            # 0xe0b0
movq %r14, %rdi
callq 0x8064
leaq 0x6145(%rip), %rdi      # 0xe0c0
movl $0x1, %esi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regcomp.c
// Function: nextc
static	int
nextc(Rune *rp)
{
	if(lexdone){
		*rp = 0;
		return 1;
	}
	exprp += chartorune(rp, exprp);
	if(*rp == '\\'){
		exprp += chartorune(rp, exprp);
		return 1;
	}
	if(*rp == 0)
		lexdone = 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x61f3(%rip)      # 0xe188
jne 0x7f9f
movl $0x0, (%rbx)
jmp 0x7fdd
movq 0x61ea(%rip), %rsi      # 0xe190
movq %rbx, %rdi
callq 0x8b5c
movslq %eax, %rsi
addq 0x61d8(%rip), %rsi      # 0xe190
movq %rsi, 0x61d1(%rip)      # 0xe190
movl (%rbx), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x7fe9
cmpl $0x5c, %ecx
jne 0x7fe2
movq %rbx, %rdi
callq 0x8b5c
cltq
addq %rax, 0x61b3(%rip)      # 0xe190
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movb $0x1, 0x6198(%rip)      # 0xe188
jmp 0x7fe2
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regcomp.c
// Function: popand
static	Node*
popand(int op)
{
	Reinst *inst;

	if(andp <= &andstack[0]){
		regerr2("missing operand for ", op);
		inst = newinst(NOP);
		pushand(inst,inst);
	}
	return --andp;
}

// Assembly:
movq 0x6347(%rip), %rax      # 0xe340
leaq 0x6200(%rip), %rcx      # 0xe200
cmpq %rcx, %rax
jbe 0x8011
addq $-0x10, %rax
movq %rax, 0x6330(%rip)      # 0xe340
retq
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb $0x6d, %al
xorl %edx, %edx
leaq 0x163b(%rip), %rcx      # 0x965f
movb %al, -0x70(%rbp,%rdx)
movb 0x1(%rdx,%rcx), %al
leaq 0x1(%rdx), %rsi
movq %rsi, %rdx
cmpq $0x14, %rsi
jne 0x8024
leaq -0x70(%rbp), %rax
movb %dil, 0x14(%rax)
movb $0x0, 0x15(%rax)
incl 0x6065(%rip)            # 0xe0b0
movq %rax, %rdi
callq 0x8064
leaq 0x6066(%rip), %rdi      # 0xe0c0
movl $0x1, %esi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regerror.c
// Function: regerror9
void
regerror(char *s)
{
	char buf[132];

	strncpy(buf, "regerror: ", sizeof(buf));
	strncat(buf, s, sizeof(buf)-1);
	strncat(buf, "\n", sizeof(buf)-1);
	write(2, buf, strlen(buf));
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
leaq 0x15f8(%rip), %rsi      # 0x9674
leaq -0xa0(%rbp), %rbx
movl $0x84, %edx
movq %rbx, %rdi
callq 0x2060
movl $0x83, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x20e0
movw $0xa, -0xa0(%rbp,%rax)
movq %rbx, %rdi
callq 0x20e0
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x20b0
movl $0x1, %edi
callq 0x2240
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regexec.c
// Function: regexec9
extern int
regexec(Reprog *progp,	/* program to run */
	char *bol,	/* string to run machine on */
	Resub *mp,	/* subexpression elements */
	int ms)		/* number of elements at mp */
{
	Reljunk j;
	Relist relist0[LISTSIZE], relist1[LISTSIZE];
	int rv;

	/*
 	 *  use user-specified starting/ending location if specified
	 */
	j.starts = bol;
	j.eol = 0;
	if(mp && ms>0){
		if(mp->s.sp)
			j.starts = mp->s.sp;
		if(mp->e.ep)
			j.eol = mp->e.ep;
	}
	j.starttype = 0;
	j.startchar = 0;
	if(progp->startinst->type == RUNE && progp->startinst->r.r < Runeself) {
		j.starttype = RUNE;
		j.startchar = progp->startinst->r.r;
	}
	if(progp->startinst->type == BOL)
		j.starttype = BOL;

	/* mark space */
	j.relist[0] = relist0;
	j.relist[1] = relist1;
	j.reliste[0] = relist0 + nelem(relist0) - 2;
	j.reliste[1] = relist1 + nelem(relist1) - 2;

	rv = regexec1(progp, bol, mp, ms, &j);
	if(rv >= 0)
		return rv;
	rv = regexec2(progp, bol, mp, ms, &j);
	if(rv >= 0)
		return rv;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28f8, %rsp           # imm = 0x28F8
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
testq %rdx, %rdx
sete %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
jne 0x8127
movq (%r14), %rax
testq %rax, %rax
je 0x811a
movq %rax, -0x58(%rbp)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x8127
movq %rax, -0x50(%rbp)
movq $0x0, -0x60(%rbp)
movq (%r12), %rcx
movl (%rcx), %eax
cmpl $0xc3, %eax
je 0x815a
cmpl $0x7f, %eax
jne 0x8161
movl 0x8(%rcx), %ecx
cmpl $0x7f, %ecx
ja 0x8153
movl $0x7f, -0x60(%rbp)
movl %ecx, -0x5c(%rbp)
cmpl $0xc3, %eax
jne 0x8161
movl $0xc3, -0x60(%rbp)
leaq -0x2920(%rbp), %rax
leaq -0x80(%rbp), %r8
movq %rax, (%r8)
leaq -0x14d0(%rbp), %rcx
movq %rcx, 0x8(%r8)
movl $0x1040, %edx           # imm = 0x1040
addq %rdx, %rax
movq %rax, 0x10(%r8)
addq %rdx, %rcx
movq %rcx, 0x18(%r8)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x8244
movl %eax, %r13d
testl %eax, %eax
jns 0x822f
movl $0x1fbd0, %edi          # imm = 0x1FBD0
callq 0x21c0
testq %rax, %rax
je 0x8218
movq %rax, -0x30(%rbp)
movl $0x1fbd0, %edi          # imm = 0x1FBD0
callq 0x21c0
testq %rax, %rax
je 0x8220
leaq -0x80(%rbp), %r8
movq -0x30(%rbp), %rcx
movq %rcx, (%r8)
movq %rax, 0x8(%r8)
movq %rax, %rdx
movq %rax, -0x38(%rbp)
movl $0x1f7c0, %eax          # imm = 0x1F7C0
addq %rax, %rcx
movq %rcx, 0x10(%r8)
movq %rdx, %rcx
addq %rax, %rcx
movq %rcx, 0x18(%r8)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x8244
movl %eax, %r13d
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x38(%rbp), %rdi
jmp 0x822a
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x822f
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq -0x30(%rbp), %rdi
callq 0x2030
movl %r13d, %eax
addq $0x28f8, %rsp           # imm = 0x28F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/regsub.c
// Function: regsub9
extern	void
regsub(char *sp,	/* source string */
	char *dp,	/* destination string */
	int dlen,
	Resub *mp,	/* subexpression elements */
	int ms)		/* number of elements pointed to by mp */
{
	char *ssp, *ep;
	int i;

	ep = dp+dlen-1;
	while(*sp != '\0'){
		if(*sp == '\\'){
			switch(*++sp){
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				i = *sp-'0';
				if(mp!=0 && mp[i].s.sp != 0 && ms>i)
					for(ssp = mp[i].s.sp;
					     ssp < mp[i].e.ep;
					     ssp++)
						if(dp < ep)
							*dp++ = *ssp;
				break;
			case '\\':
				if(dp < ep)
					*dp++ = '\\';
				break;
			case '\0':
				sp--;
				break;
			default:
				if(dp < ep)
					*dp++ = *sp;
				break;
			}
		}else if(*sp == '&'){
			if(mp!=0 && mp[0].s.sp != 0 && ms>0)
				for(ssp = mp[0].s.sp;
				     ssp < mp[0].e.ep; ssp++)
					if(dp < ep)
						*dp++ = *ssp;
		}else{
			if(dp < ep)
				*dp++ = *sp;
		}
		sp++;
	}
	*dp = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rax
addq %rsi, %rax
decq %rax
movzbl (%rdi), %r9d
cmpl $0x26, %r9d
je 0x85fa
cmpl $0x5c, %r9d
je 0x8599
testl %r9d, %r9d
je 0x8650
movq %rdi, %rdx
cmpq %rax, %rsi
jae 0x8648
movb %r9b, (%rsi)
incq %rsi
jmp 0x8645
leaq 0x1(%rdi), %rdx
movb 0x1(%rdi), %r9b
movzbl %r9b, %r10d
leal -0x30(%r10), %r11d
cmpl $0xa, %r11d
jae 0x862e
testq %rcx, %rcx
je 0x8645
movsbq %r9b, %r10
addq $-0x30, %r10
movq %r10, %rdi
shlq $0x4, %rdi
movq (%rcx,%rdi), %r9
testq %r9, %r9
sete %r11b
cmpl %r8d, %r10d
setge %r10b
orb %r11b, %r10b
jne 0x8645
addq %rcx, %rdi
cmpq 0x8(%rdi), %r9
jae 0x8645
cmpq %rax, %rsi
jae 0x85f5
movb (%r9), %r10b
movb %r10b, (%rsi)
incq %rsi
incq %r9
jmp 0x85e1
testq %rcx, %rcx
je 0x8648
testl %r8d, %r8d
setle %r9b
movq (%rcx), %rdx
testq %rdx, %rdx
sete %r10b
orb %r9b, %r10b
jne 0x8648
cmpq 0x8(%rcx), %rdx
jae 0x8648
cmpq %rax, %rsi
jae 0x8629
movb (%rdx), %r9b
movb %r9b, (%rsi)
incq %rsi
incq %rdx
jmp 0x8615
testl %r10d, %r10d
je 0x8648
cmpl $0x5c, %r10d
jne 0x863c
movb $0x5c, %r9b
cmpq %rax, %rsi
jb 0x858e
movq %rdx, %rdi
incq %rdi
jmp 0x8565
movb $0x0, (%rsi)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/rregexec.c
// Function: rregexec9
extern int
rregexec(Reprog *progp,	/* program to run */
	Rune *bol,	/* string to run machine on */
	Resub *mp,	/* subexpression elements */
	int ms)		/* number of elements at mp */
{
	Reljunk j;
	Relist relist0[LISTSIZE], relist1[LISTSIZE];
	int rv;

	/*
 	 *  use user-specified starting/ending location if specified
	 */
	j.rstarts = bol;
	j.reol = 0;
	if(mp && ms>0){
		if(mp->s.sp)
			j.rstarts = mp->s.rsp;
		if(mp->e.ep)
			j.reol = mp->e.rep;
	}
	j.starttype = 0;
	j.startchar = 0;
	if(progp->startinst->type == RUNE && progp->startinst->r.r < Runeself) {
		j.starttype = RUNE;
		j.startchar = progp->startinst->r.r;
	}
	if(progp->startinst->type == BOL)
		j.starttype = BOL;

	/* mark space */
	j.relist[0] = relist0;
	j.relist[1] = relist1;
	j.reliste[0] = relist0 + nelem(relist0) - 2;
	j.reliste[1] = relist1 + nelem(relist1) - 2;

	rv = rregexec1(progp, bol, mp, ms, &j);
	if(rv >= 0)
		return rv;
	rv = rregexec2(progp, bol, mp, ms, &j);
	if(rv >= 0)
		return rv;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf410, %rsp           # imm = 0xF410
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
testq %rdx, %rdx
sete %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
jne 0x86a9
movq (%r14), %rax
testq %rax, %rax
je 0x869c
movq %rax, -0x30(%rbp)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x86a9
movq %rax, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
movq (%r12), %rcx
movl (%rcx), %eax
cmpl $0xc3, %eax
je 0x86dc
cmpl $0x7f, %eax
jne 0x86e3
movl 0x8(%rcx), %ecx
cmpl $0x7f, %ecx
ja 0x86d5
movl $0x7f, -0x48(%rbp)
movl %ecx, -0x44(%rbp)
cmpl $0xc3, %eax
jne 0x86e3
movl $0xc3, -0x48(%rbp)
leaq -0x2910(%rbp), %rax
leaq -0x68(%rbp), %r8
movq %rax, (%r8)
leaq -0x14c0(%rbp), %rcx
movq %rcx, 0x8(%r8)
movl $0x1040, %edx           # imm = 0x1040
addq %rdx, %rax
movq %rax, 0x10(%r8)
addq %rdx, %rcx
movq %rcx, 0x18(%r8)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x876f
testl %eax, %eax
jns 0x875f
leaq -0xf430(%rbp), %rax
leaq -0x68(%rbp), %r8
movq %rax, (%r8)
leaq -0x8ea0(%rbp), %rcx
movq %rcx, 0x8(%r8)
movl $0x6180, %edx           # imm = 0x6180
addq %rdx, %rax
movq %rax, 0x10(%r8)
addq %rdx, %rcx
movq %rcx, 0x18(%r8)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x876f
addq $0xf410, %rsp           # imm = 0xF410
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/rregsub.c
// Function: rregsub9
extern	void
rregsub(Rune *sp,	/* source string */
	Rune *dp,	/* destination string */
	int dlen,
	Resub *mp,	/* subexpression elements */
	int ms)		/* number of elements pointed to by mp */
{
	Rune *ssp, *ep;
	int i;

	ep = dp+(dlen/sizeof(Rune))-1;
	while(*sp != '\0'){
		if(*sp == '\\'){
			switch(*++sp){
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				i = *sp-'0';
				if(mp!=0 && mp[i].s.rsp != 0 && ms>i)
					for(ssp = mp[i].s.rsp;
					     ssp < mp[i].e.rep;
					     ssp++)
						if(dp < ep)
							*dp++ = *ssp;
				break;
			case '\\':
				if(dp < ep)
					*dp++ = '\\';
				break;
			case '\0':
				sp--;
				break;
			default:
				if(dp < ep)
					*dp++ = *sp;
				break;
			}
		}else if(*sp == '&'){
			if(mp!=0 && mp[0].s.rsp != 0 && ms>0)
				for(ssp = mp[0].s.rsp;
				     ssp < mp[0].e.rep; ssp++)
					if(dp < ep)
						*dp++ = *ssp;
		}else{
			if(dp < ep)
				*dp++ = *sp;
		}
		sp++;
	}
	*dp = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rax
andq $-0x4, %rax
addq %rsi, %rax
addq $-0x4, %rax
movl (%rdi), %r9d
cmpl $0x26, %r9d
je 0x8af5
cmpl $0x5c, %r9d
je 0x8a9e
testl %r9d, %r9d
je 0x8b51
movq %rdi, %rdx
cmpq %rax, %rsi
jae 0x8b48
movl %r9d, (%rsi)
addq $0x4, %rsi
jmp 0x8b45
leaq 0x4(%rdi), %rdx
movl 0x4(%rdi), %r9d
leal -0x30(%r9), %r10d
cmpl $0xa, %r10d
jae 0x8b2b
testq %rcx, %rcx
je 0x8b45
movslq %r10d, %rdi
shlq $0x4, %rdi
movq (%rcx,%rdi), %r9
testq %r9, %r9
sete %r11b
cmpl %r8d, %r10d
setge %r10b
orb %r11b, %r10b
jne 0x8b45
addq %rcx, %rdi
cmpq 0x8(%rdi), %r9
jae 0x8b45
cmpq %rax, %rsi
jae 0x8aef
movl (%r9), %r10d
movl %r10d, (%rsi)
addq $0x4, %rsi
addq $0x4, %r9
jmp 0x8ada
testq %rcx, %rcx
je 0x8b48
testl %r8d, %r8d
setle %r9b
movq (%rcx), %rdx
testq %rdx, %rdx
sete %r10b
orb %r9b, %r10b
jne 0x8b48
cmpq 0x8(%rcx), %rdx
jae 0x8b48
cmpq %rax, %rsi
jae 0x8b25
movl (%rdx), %r9d
movl %r9d, (%rsi)
addq $0x4, %rsi
addq $0x4, %rdx
jmp 0x8b10
testl %r9d, %r9d
je 0x8b48
cmpl $0x5c, %r9d
jne 0x8b3c
movl $0x5c, %r9d
cmpq %rax, %rsi
jb 0x8a92
movq %rdx, %rdi
addq $0x4, %rdi
jmp 0x8a6e
movl $0x0, (%rsi)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/utf.c
// Function: runestrchr
Rune*
runestrchr(Rune *s, Rune c)
{
	Rune c0 = c;
	Rune c1;

	if(c == 0) {
		while(*s++)
			;
		return s-1;
	}

	while((c1 = *s++))
		if(c1 == c0)
			return s-1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
addq $-0x4, %rax
testl %esi, %esi
je 0x8c3e
movl 0x4(%rax), %ecx
testl %ecx, %ecx
je 0x8c50
addq $0x4, %rax
cmpl %esi, %ecx
jne 0x8c2d
jmp 0x8c52
movq %rax, %rcx
leaq 0x4(%rcx), %rax
cmpl $0x0, 0x4(%rcx)
movq %rax, %rcx
jne 0x8c41
jmp 0x8c52
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phase[P]o/libregexp/utf.c
// Function: utfrune
char*
utfrune(char *s, Rune c)
{
	Rune c1;
	Rune r;
	int n;

	if(c < Runesync)		/* not part of utf sequence */
		return strchr(s, c);

	for(;;) {
		c1 = *(unsigned char*)s;
		if(c1 < Runeself) {	/* one byte rune */
			if(c1 == 0)
				return 0;
			if(c1 == c)
				return s;
			s++;
			continue;
		}
		n = chartorune(&r, s);
		if(r == c)
			return s;
		s += n;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x80, %esi
jae 0x8c81
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
leaq -0x1c(%rbp), %r15
movzbl (%rbx), %ecx
testb %cl, %cl
js 0x8c9c
testl %ecx, %ecx
je 0x8cb4
movl $0x1, %eax
cmpl %r14d, %ecx
jne 0x8caf
jmp 0x8cb6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8b5c
cmpl %r14d, -0x1c(%rbp)
je 0x8cb6
movl %eax, %eax
addq %rax, %rbx
jmp 0x8c85
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/tests/kvlds-blocking/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct wire_requestqueue * Q;
	struct kivaloo_cookie * K;

	WARNP_INIT;

	/* Check number of arguments. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_kvlds %s\n", "<socketname>");
		exit(1);
	}

	/* Open a connection to KVLDS. */
	if ((K = kivaloo_open(argv[1], &Q)) == NULL) {
		warnp("Could not connect o KVLDS daemon.");
		exit(1);
	}

	/* Test the blocking API. */
	if (set_get_blocking(Q))
		exit(1);

	/* Free the request queue and network connection. */
	kivaloo_close(K);

	/* Success! */
	exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x254a
callq 0x2660
cmpl $0x2, %ebp
jne 0x2580
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2a64
testq %rax, %rax
jne 0x25a9
callq 0x2090
cmpl $0x0, (%rax)
jne 0x2643
leaq 0x8ab0(%rip), %rdi      # 0xb027
xorl %eax, %eax
callq 0x27ff
jmp 0x259f
movq 0xea71(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x8a73(%rip), %rsi      # 0xb004
leaq 0x8a82(%rip), %rdx      # 0xb01a
xorl %eax, %eax
callq 0x21b0
movl $0x1, %edi
callq 0x2290
movq %rax, %rbx
movq 0x8(%rsp), %r12
leaq 0x9720(%rip), %rdi      # 0xbcd8
movl $0x3, %esi
callq 0x2924
movq %rax, %r14
leaq 0x8a7d(%rip), %rdi      # 0xb049
movl $0x3, %esi
callq 0x2924
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2e4e
testl %eax, %eax
jne 0x259f
movq %rsp, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2eef
testl %eax, %eax
jne 0x259f
movzbl (%r15), %edx
movq (%rsp), %rdi
cmpb (%rdi), %dl
jne 0x259f
incq %rdi
movq %r15, %rsi
incq %rsi
callq 0x2220
testl %eax, %eax
jne 0x259f
movq %r14, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x2040
movq (%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2bad
xorl %edi, %edi
callq 0x2290
movq %rax, %rbx
leaq 0x89da(%rip), %rdi      # 0xb027
xorl %eax, %eax
callq 0x26e0
movl $0x0, (%rbx)
jmp 0x259f
nop
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_08/argv0.c
// Function: main
int main(int argc, char *argv[])
{
	char *name;

	/* Get the file name removing the prepending path name */
	name = basename(argv[0]);

	/* Do different actions according to the invoking name */
	if (strcmp(name, "hello") == 0) {
		printf("hello ");
		if (argc >= 2)
			printf("%s!", argv[1]);
		else
			printf("world");
		printf("\n");
	} else if (strcmp(name, "sum") == 0) {
		if (argc >= 3)
			printf("%d\n", atoi(argv[1]) + atoi(argv[2]));
		else
			printf("too few arguments!\n");
	} else {
		printf("change my name!\n");
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
callq 0x1070
movq %rax, %r14
leaq 0xe5d(%rip), %rsi       # 0x2004
movq %rax, %rdi
callq 0x1060
testl %eax, %eax
je 0x11cf
leaq 0xe61(%rip), %rsi       # 0x201b
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
je 0x11f6
leaq 0xe56(%rip), %rdi       # 0x2023
jmp 0x1244
leaq 0xe34(%rip), %rdi       # 0x200a
xorl %eax, %eax
callq 0x1050
cmpl $0x2, %ebp
jl 0x1223
movq 0x8(%rbx), %rsi
leaq 0xe24(%rip), %rdi       # 0x2011
xorl %eax, %eax
callq 0x1050
jmp 0x1231
cmpl $0x3, %ebp
jl 0x123d
movq 0x8(%rbx), %rdi
callq 0x1080
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x1080
addl %eax, %ebp
leaq 0xe07(%rip), %rdi       # 0x201f
movl %ebp, %esi
xorl %eax, %eax
callq 0x1050
jmp 0x1249
leaq 0xdeb(%rip), %rdi       # 0x2015
xorl %eax, %eax
callq 0x1050
movl $0xa, %edi
callq 0x1030
jmp 0x1249
leaq 0xdef(%rip), %rdi       # 0x2033
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/testrender.c
// Function: main
int main(int argc, char* argv[])
{
	struct aatrace_text txt;
	struct aatrace_font font;
	struct aatrace_pic out;

	if (argc < 4)
		return 1;

	if (util_load_text(&txt, argv[1]) < 0)
		return 2;

	if (util_load_font(&font, argv[2]) < 0)
		return 3;

	aatrace_render_pic(&out, &txt, &font);

	if (util_store_pic(argv[3], &out) < 0)
		return 4;

	return 0;
}

// Assembly:
movl $0x1, %eax
cmpl $0x4, %edi
jl 0x13ce
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
movq %rsp, %rdi
callq 0x17cd
testl %eax, %eax
js 0x13bb
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0x1a97
testl %eax, %eax
js 0x13c2
leaq 0x40(%rsp), %r14
movq %rsp, %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x1b0c
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1a09
shrl $0x1d, %eax
andl $-0x4, %eax
jmp 0x13c7
movl $0x2, %eax
jmp 0x13c7
movl $0x3, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/pnm.c
// Function: pnm_filename_open
pnm_file pnm_filename_open(const char* fname, pnm_type_t* ptype, int* pwidth, int* pheight)
{
	FILE* f;
	pnm_file pnm;

	f = fopen(fname, "rb");
	if (!f)
		return 0;

	pnm = pnm_file_open(f, ptype, pwidth, pheight);
	if (!pnm) {
		fclose(f);
		return 0;
	}

	return pnm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0xc1c(%rip), %rsi       # 0x2004
callq 0x1100
testq %rax, %rax
je 0x1413
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1421
testq %rax, %rax
jne 0x1415
movq %rbx, %rdi
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/pnm.c
// Function: pnm_file_open
pnm_file pnm_file_open(FILE* f, pnm_type_t* ptype, int* pwidth, int* pheight)
{
	char magic, typec;
	int depth;
	int i;
	pnm_file s;

	if (fscanf(f, "%c%c\n", &magic, &typec) != 2)
		return 0;

	if (magic != 'P' || (typec != '5' && typec != '6'))
		return 0;

	*ptype = (pnm_type_t)(typec - '0');

	/* comments */
	for (i = 0; i < 16; i++)
		if (!fscanf(f, "#%*[^\n]\n"))
			break;

	if (fscanf(f, "%d %d\n", pwidth, pheight) != 2)
		return 0;

	/* scanf("%d\n") matches ANY AMOUNT of whitespace after the number. */
	if (fscanf(f, "%d", &depth) != 1)
		return 0;
	if (fgetc(f) != '\n')
		return 0;

	if (depth != 255)
		return 0;

	s = (pnm_file)malloc(sizeof(*s));
	s->file = f;
	s->type = *ptype;
	s->width = *pwidth;
	s->height = *pheight;
	s->stride = ((s->type == 6) ? 3 : 1) * s->width;

	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xbc8(%rip), %rsi       # 0x2007
xorl %r13d, %r13d
leaq 0x3(%rsp), %rdx
leaq 0x2(%rsp), %rcx
xorl %eax, %eax
callq 0x1050
cmpl $0x2, %eax
jne 0x153a
cmpb $0x50, 0x3(%rsp)
jne 0x153a
movzbl 0x2(%rsp), %eax
leal -0x37(%rax), %ecx
cmpb $-0x2, %cl
jae 0x147c
xorl %r13d, %r13d
jmp 0x153a
addl $-0x30, %eax
movl %eax, (%r15)
movl $0xf, %ebp
leaq 0xb7f(%rip), %r13       # 0x200d
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x1050
subl $0x1, %ebp
setb %cl
testl %eax, %eax
je 0x14a9
testb %cl, %cl
je 0x148e
leaq 0xb66(%rip), %rsi       # 0x2016
xorl %r13d, %r13d
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1050
cmpl $0x2, %eax
jne 0x153a
leaq 0xb4e(%rip), %rsi       # 0x201d
xorl %r13d, %r13d
leaq 0x4(%rsp), %rdx
movq %r12, %rdi
xorl %eax, %eax
callq 0x1050
cmpl $0x1, %eax
jne 0x153a
movq %r12, %rdi
callq 0x1090
xorl %r13d, %r13d
cmpl $0xa, %eax
jne 0x153a
cmpl $0xff, 0x4(%rsp)
jne 0x153a
movl $0x18, %edi
callq 0x10e0
movq %rax, %r13
movq %r12, (%rax)
movl (%r15), %eax
movl %eax, 0x8(%r13)
movl (%r14), %ecx
movl %ecx, 0xc(%r13)
movl (%rbx), %edx
movl %edx, 0x10(%r13)
xorl %edx, %edx
cmpl $0x6, %eax
sete %dl
leal 0x1(,%rdx,2), %eax
imull %ecx, %eax
movl %eax, 0x14(%r13)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/pnm.c
// Function: pnm_file_read_pic
int pnm_file_read_pic(pnm_file s, pnm_pix_t* picbuf)
{
	int l;

	for (l = 0; l < s->height; l++)
		if (pnm_file_read_line(s, picbuf + l*s->stride) < 0)
			return -1;

	return 0;
}

// Assembly:
cmpl $0x0, 0x10(%rdi)
jle 0x15cb
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movslq 0x14(%r14), %rsi
movslq %ebp, %rdi
imulq %rsi, %rdi
addq %rbx, %rdi
movq (%r14), %rcx
movl $0x1, %edx
callq 0x1060
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x1, %rcx
jne 0x15c6
cmpl $0x0, 0x14(%r14)
js 0x15c6
incl %ebp
cmpl 0x10(%r14), %ebp
jl 0x158c
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/pnm.c
// Function: pnm_filename_create
pnm_file pnm_filename_create(const char* fname, pnm_type_t type, int width, int height)
{
	FILE* f;
	pnm_file pnm;

	f = fopen(fname, "wb");
	if (!f)
		return 0;

	pnm = pnm_file_create(f, type, width, height);
	if (!pnm) {
		fclose(f);
		return 0;
	}

	return pnm;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
leaq 0xa3c(%rip), %rsi       # 0x2020
callq 0x1100
testq %rax, %rax
je 0x160e
movq %rax, %rbx
movq %rax, %rdi
movl %r15d, %esi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x161b
testq %rax, %rax
jne 0x1610
movq %rbx, %rdi
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/pnm.c
// Function: pnm_file_create
pnm_file pnm_file_create(FILE* f, pnm_type_t type, int width, int height)
{
	pnm_file s;

	s = (pnm_file)malloc(sizeof(*s));

	s->file = f;
	s->type = type;
	s->width = width;
	s->height = height;
	s->stride = ((s->type == 6) ? 3 : 1) * s->width;

	fprintf(f, "P%d\n%d %d\n255\n", type, width, height);

	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl $0x18, %edi
callq 0x10e0
movq %rax, %r12
movq %r15, (%rax)
movl %r14d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movl %ebx, 0x10(%rax)
xorl %eax, %eax
cmpl $0x6, %r14d
sete %al
leal 0x1(,%rax,2), %eax
imull %ebp, %eax
movl %eax, 0x14(%r12)
leaq 0x9bd(%rip), %rsi       # 0x2023
movq %r15, %rdi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x10d0
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/pnm.c
// Function: pnm_file_write_pic
int pnm_file_write_pic(pnm_file s, const pnm_pix_t* picbuf)
{
	int l;

	for (l = 0; l < s->height; l++)
		if (pnm_file_write_line(s, picbuf + l*s->stride) < 0)
			return -1;

	return 0;
}

// Assembly:
cmpl $0x0, 0x10(%rdi)
jle 0x1703
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movslq 0x14(%r14), %rsi
movslq %ebp, %rdi
imulq %rsi, %rdi
addq %rbx, %rdi
movq (%r14), %rcx
movl $0x1, %edx
callq 0x1110
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x1, %rcx
jne 0x16fe
cmpl $0x0, 0x14(%r14)
js 0x16fe
incl %ebp
cmpl 0x10(%r14), %ebp
jl 0x16c4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/util.c
// Function: util_read_text
int util_read_text(struct aatrace_text* txt, FILE* f)
{
	size_t sz = 0x1000;
	txt->buf = (char*)malloc(sz);
	unsigned int l;

	if (!fgets(txt->buf, sz, f))
		return -1;

	txt->ll = txt->w = strlen(txt->buf) - 1;

	for (l = 1; ; l++) {
		if ((l + 1)*txt->ll + 1 > sz) {
			sz *= 2;
			txt->buf = (char*)realloc(txt->buf, sz);
		}

		if (!fgets(&txt->buf[l*txt->ll], sz - l*txt->ll, f))
			break;
	}

	txt->h = l;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1000, %r15d          # imm = 0x1000
movl $0x1000, %edi           # imm = 0x1000
callq 0x10e0
movq %rax, (%rbx)
movq %rax, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdx
callq 0x10a0
testq %rax, %rax
je 0x17bc
movq (%rbx), %rdi
callq 0x1080
decl %eax
movl %eax, 0xc(%rbx)
movl %eax, 0x8(%rbx)
xorl %r12d, %r12d
leal 0x2(%r12), %eax
imull 0x8(%rbx), %eax
incl %eax
cmpq %rax, %r15
jae 0x1792
addq %r15, %r15
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x10f0
movq %rax, (%rbx)
incl %r12d
movl 0x8(%rbx), %eax
imull %r12d, %eax
movq (%rbx), %rdi
addq %rax, %rdi
movl %r15d, %esi
subl %eax, %esi
movq %r14, %rdx
callq 0x10a0
testq %rax, %rax
jne 0x1771
movl %r12d, 0x10(%rbx)
xorl %eax, %eax
jmp 0x17c1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/util.c
// Function: util_load_text
int util_load_text(struct aatrace_text* txt, const char* fname)
{
	FILE* f = stdin;

	if (strcmp(fname, "-")) {
		f = fopen(fname, "rb");
		if (!f) {
			fprintf(stderr, "Error opening TXT file '%s': %s\n",
				fname, strerror(errno));

			return -1;
		}
	}

	if (util_read_text(txt, f) < 0) {
		fprintf(stderr, "Error reading TXT file '%s': %s\n",
			fname, strerror(errno));

		return -1;
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x27f9(%rip), %rax      # 0x3fd8
movq (%rax), %r15
leaq 0x849(%rip), %rsi       # 0x2032
movq %rbx, %rdi
callq 0x10b0
testl %eax, %eax
je 0x180c
leaq 0x808(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x1100
movq %rax, %r15
testq %rax, %rax
je 0x182e
movq %r14, %rdi
movq %r15, %rsi
callq 0x1728
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
js 0x1825
popq %rbx
popq %r14
popq %r15
retq
leaq 0x829(%rip), %rdi       # 0x2055
jmp 0x1835
leaq 0x7ff(%rip), %rdi       # 0x2034
movq %rbx, %rsi
callq 0x1140
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x181f
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/util.c
// Function: util_write_text
int util_write_text(FILE* f, const struct aatrace_text* txt)
{
	int l;

	for (l = 0; l < txt->h; l++) {
		if (fwrite(&txt->buf[l*txt->ll], txt->w, 1, f) != 1)
			return -1;

		putc('\n', f);
	}

	return (txt->w + 1)*txt->h;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x10(%rsi), %ecx
testl %ecx, %ecx
jle 0x188d
movq %rdi, %r14
xorl %ebp, %ebp
movl 0x8(%rbx), %edi
imull %ebp, %edi
addq (%rbx), %rdi
movslq 0xc(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rcx
callq 0x1110
cmpq $0x1, %rax
jne 0x1897
movl $0xa, %edi
movq %r14, %rsi
callq 0x10c0
incl %ebp
movl 0x10(%rbx), %ecx
cmpl %ecx, %ebp
jl 0x1857
movl 0xc(%rbx), %eax
incl %eax
imull %ecx, %eax
jmp 0x189c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/util.c
// Function: util_store_text
int util_store_text(const char* fname, const struct aatrace_text* txt)
{
	FILE* f = stdout;

	if (strcmp(fname, "-")) {
		f = fopen(fname, "wb");
		if (!f) {
			fprintf(stderr, "Error creating TXT file '%s': %s\n",
				fname, strerror(errno));

			return -1;
		}
	}

	if (util_write_text(f, txt) < 0) {
		fprintf(stderr, "Error writing TXT file '%s': %s\n",
			fname, strerror(errno));
		return -1;
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x271d(%rip), %rax      # 0x3fd0
movq (%rax), %r15
leaq 0x775(%rip), %rsi       # 0x2032
callq 0x10b0
testl %eax, %eax
je 0x18dd
leaq 0x753(%rip), %rsi       # 0x2020
movq %rbx, %rdi
callq 0x1100
movq %rax, %r15
testq %rax, %rax
je 0x18ff
movq %r15, %rdi
movq %r14, %rsi
callq 0x1844
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
js 0x18f6
popq %rbx
popq %r14
popq %r15
retq
leaq 0x79b(%rip), %rdi       # 0x2098
jmp 0x1906
leaq 0x770(%rip), %rdi       # 0x2076
movq %rbx, %rsi
callq 0x1179
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x18f0
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/util.c
// Function: util_load_pic
int util_load_pic(struct aatrace_pic* pic, const char* fname)
{
	pnm_file pnm;
	pnm_type_t type;

	if (strcmp(fname, "-")) {
		pnm = pnm_filename_open(fname, &type, &pic->w, &pic->h);
	} else {
		pnm = pnm_file_open(stdin, &type, &pic->w, &pic->h);
	}

	if (!pnm || type != PNM_TYPE_PGM) {
		if (errno) {
			fprintf(stderr, "Error opening PGM file '%s': %s\n",
				fname, strerror(errno));
		} else {
			fprintf(stderr, "Bad PGM file '%s'\n", fname);
		}
		return -1;
	}

	pic->ll = pic->w;
	pic->buf = (unsigned char*)malloc(pic->ll*pic->h);

	if (pnm_file_read_pic(pnm, pic->buf) < 0) {
		fprintf(stderr, "Error reading PGM file '%s': %s\n",
			fname, strerror(errno));
		return -1;
	}

	pnm_file_close(pnm);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x707(%rip), %rsi       # 0x2032
movq %rbx, %rdi
callq 0x10b0
testl %eax, %eax
je 0x194e
leaq 0xc(%r14), %rdx
leaq 0x10(%r14), %rcx
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x13d0
jmp 0x196a
movq 0x2683(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
leaq 0xc(%r14), %rdx
leaq 0x10(%r14), %rcx
leaq 0xc(%rsp), %rsi
callq 0x1421
movq %rax, %r15
testq %rax, %rax
je 0x19b1
cmpl $0x5, 0xc(%rsp)
jne 0x19b1
movl 0xc(%r14), %edi
movl %edi, 0x8(%r14)
imull 0x10(%r14), %edi
callq 0x10e0
movq %rax, (%r14)
movq %r15, %rdi
movq %rax, %rsi
callq 0x157a
testl %eax, %eax
js 0x19dc
movq %r15, %rdi
callq 0x1710
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1040
movl (%rax), %edi
movq 0x2639(%rip), %rax      # 0x3ff8
movq (%rax), %r14
testl %edi, %edi
jne 0x19e6
leaq 0x70d(%rip), %rsi       # 0x20da
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10d0
jmp 0x1a02
movq %rbx, %rdi
callq 0x11b2
jmp 0x1a02
callq 0x1120
leaq 0x6c7(%rip), %rsi       # 0x20b9
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x10d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x19a7
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/util.c
// Function: util_store_pic
int util_store_pic(const char* fname, const struct aatrace_pic* pic)
{
	pnm_file pnm;

	if (strcmp(fname, "-")) {
		pnm = pnm_filename_create(fname, PNM_TYPE_PGM, pic->w, pic->h);
	} else {
		pnm = pnm_file_create(stdout, PNM_TYPE_PGM, pic->w, pic->h);
	}

	if (!pnm) {
		fprintf(stderr, "Error creating PGM file '%s': %s\n",
			fname, strerror(errno));
		return -1;
	}

	if (pnm_file_write_pic(pnm, pic->buf) < 0) {
		fprintf(stderr, "Error writing PGM file '%s': %s\n",
			fname, strerror(errno));

		return -1;
	}

	pnm_file_close(pnm);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x617(%rip), %rsi       # 0x2032
callq 0x10b0
testl %eax, %eax
je 0x1a3b
movl 0xc(%r14), %edx
movl 0x10(%r14), %ecx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x15ce
jmp 0x1a57
movq 0x258e(%rip), %rax      # 0x3fd0
movq (%rax), %rdi
movl 0xc(%r14), %edx
movl 0x10(%r14), %ecx
movl $0x5, %esi
callq 0x161b
movq %rax, %r15
testq %rax, %rax
je 0x1a7e
movq (%r14), %rsi
movq %r15, %rdi
callq 0x16b2
testl %eax, %eax
js 0x1a88
movq %r15, %rdi
callq 0x1710
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x1229
jmp 0x1a90
movq %rbx, %rdi
callq 0x11ee
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1a78
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/util.c
// Function: util_load_font
int util_load_font(struct aatrace_font* font, const char* fname)
{
	if (util_load_pic(&font->pic, fname) < 0)
		return -1;

	if (font->pic.w != AATRACE_FONT_WIDTH) {
		fprintf(stderr, "Font '%s' has unsupported width %d\n",
			fname, font->pic.w);
		return -1;
	}

	font->w = AATRACE_FONT_WIDTH;
	font->h = AATRACE_FONT_HEIGHT;
	font->nchars = font->pic.h/AATRACE_FONT_HEIGHT;
	font->ascii_offset = AATRACE_FONT_ASCII_OFFSET;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1915
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x1ae4
movl 0xc(%r14), %ecx
cmpl $0x8, %ecx
jne 0x1aec
movabsq $0x1000000008, %rax     # imm = 0x1000000008
movq %rax, 0x18(%r14)
movl 0x10(%r14), %eax
leal 0xf(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x4, %ecx
movl %ecx, 0x20(%r14)
movl $0x20, 0x24(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2505(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x654(%rip), %rsi       # 0x2151
movq %r15, %rdx
xorl %eax, %eax
callq 0x10d0
jmp 0x1ae4
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ravenexp[P]aatrace/render.c
// Function: aatrace_render_pic
void aatrace_render_pic(struct aatrace_pic* out,
			const struct aatrace_text* txt,
			const struct aatrace_font* font)
{
	int tl, tc;

	out->ll = out->w = txt->w*font->w;
	out->h = txt->h*font->h;
	out->buf = (unsigned char*)malloc(out->ll*out->h);

	for (tl = 0; tl < txt->h; tl++)
		for (tc = 0; tc < txt->w; tc++) {
			int tile = txt->buf[tl*txt->ll + tc] - font->ascii_offset;

			aatrace_bitblt(out->buf, font->pic.buf,
				       out->ll, font->pic.ll,
				       tc*font->w, tl*font->h,
				       0, tile*font->h,
				       font->w, font->h);
		}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl 0x18(%rdx), %eax
imull 0xc(%rsi), %eax
movq %rdi, %r14
movl %eax, 0xc(%rdi)
movl %eax, 0x8(%rdi)
movq %rdx, 0x18(%rsp)
movl 0x1c(%rdx), %edi
imull 0x10(%rsi), %edi
movl %edi, 0x10(%r14)
imull %eax, %edi
callq 0x10e0
movq %r14, 0x20(%rsp)
movq %rax, (%r14)
cmpl $0x0, 0x10(%rbx)
jle 0x1c30
movl $0x0, 0xc(%rsp)
movq %rbx, 0x10(%rsp)
cmpl $0x0, 0xc(%rbx)
jle 0x1c1d
xorl %ecx, %ecx
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %edx
testl %edx, %edx
jle 0x1c0d
movq 0x10(%rsp), %rsi
movq (%rsi), %rax
movl 0x8(%rsi), %esi
movl 0xc(%rsp), %r11d
imull %r11d, %esi
addl %ecx, %esi
movsbl (%rax,%rsi), %r10d
movq 0x18(%rsp), %rax
subl 0x24(%rax), %r10d
movq 0x20(%rsp), %r8
movq (%r8), %rsi
movq (%rax), %rdi
movl 0x8(%r8), %r8d
movl 0x8(%rax), %r9d
movl 0x18(%rax), %eax
imull %edx, %r11d
imull %r8d, %r11d
movl %eax, %r15d
imull %ecx, %r15d
addl %r11d, %r15d
movl %edx, %ebp
imull %r9d, %ebp
imull %r10d, %ebp
xorl %r12d, %r12d
testl %eax, %eax
jle 0x1bff
movl %ebp, %r13d
movl %r15d, %r11d
movq %rax, %r10
movl %r13d, %r14d
movb (%rdi,%r14), %r14b
movl %r11d, %ebx
movb %r14b, (%rsi,%rbx)
incl %r11d
incl %r13d
decq %r10
jne 0x1be6
incl %r12d
addl %r8d, %r15d
addl %r9d, %ebp
cmpl %edx, %r12d
jne 0x1bd9
incl %ecx
movq 0x10(%rsp), %rbx
cmpl 0xc(%rbx), %ecx
jl 0x1b70
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl 0x10(%rbx), %eax
jl 0x1b64
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq