LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/o.c
// Function: fdo
V fdo(ST s){
    I d;O b=pop(s);O n=pop(s);if(b->t!=TCB)TE;
    if(n->t==TD){O on=v['n'];for(d=0;d<n->d;++d){v['n']=newod(d);excb(b);dlo(v['n']);}dlo(n);dlo(b);v['n']=on;} //for loop
    else if(n->t==TA||n->t==TS){I ts;O on=v['n'];ts=n->t==TS;for(d=0;d<(ts?n->s.z:len(n->a));++d){v['n']=ts?newosc(n->s.s[d]):n->a->st[d];excb(b);if(ts)dlo(v['n']);}v['n']=on;dlo(n);dlo(b);} //for each
    else TE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2920
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2920
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
je 0x695b
leaq 0x4ada(%rip), %rdi      # 0xb430
callq 0x23e0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x69dd
movq 0x9255(%rip), %rax      # 0xfbc0
movq %rax, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm1
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x69bb
cvtsi2sdl -0xc(%rbp), %xmm0
callq 0x2ed0
movq %rax, 0x9225(%rip)      # 0xfbc0
movq -0x18(%rbp), %rdi
callq 0x36d0
movq 0x9215(%rip), %rdi      # 0xfbc0
callq 0x31d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6976
movq -0x20(%rbp), %rdi
callq 0x31d0
movq -0x18(%rbp), %rdi
callq 0x31d0
movq -0x28(%rbp), %rax
movq %rax, 0x91e8(%rip)      # 0xfbc0
jmp 0x6aec
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
je 0x69f3
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6ade
movq 0x91c6(%rip), %rax      # 0xfbc0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x6a33
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x6a44
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2a60
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpq %rcx, %rax
jae 0x6abf
cmpl $0x0, -0x2c(%rbp)
je 0x6a72
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x30e0
movq %rax, -0x50(%rbp)
jmp 0x6a89
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, 0x912c(%rip)      # 0xfbc0
movq -0x18(%rbp), %rdi
callq 0x36d0
cmpl $0x0, -0x2c(%rbp)
je 0x6aaf
movq 0x9116(%rip), %rdi      # 0xfbc0
callq 0x31d0
jmp 0x6ab1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6a17
movq -0x38(%rbp), %rax
movq %rax, 0x90f6(%rip)      # 0xfbc0
movq -0x20(%rbp), %rdi
callq 0x31d0
movq -0x18(%rbp), %rdi
callq 0x31d0
jmp 0x6aea
leaq 0x494b(%rip), %rdi      # 0xb430
callq 0x23e0
jmp 0x6aec
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/o.c
// Function: toca
V toca(ST st,O o){
    if(o->t==TS){ST ca=newst();I p=0;for(;p<o->s.z;++p)psh(ca,newosc(o->s.s[p]));psh(st,newoa(ca));dlo(o);}
    else if(o->t==TA){msrt(dfsrt,0,st,o->a);psh(st,o);}
    else if(o->t==TCB){O a=pop(st);if(a->t!=TA)TE;msrt(cbsrt,o,st,a->a);psh(st,a);}
    else TE;}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x7066
callq 0x2810
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x703b
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x30e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x28c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6ff9
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3140
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x28c0
movq -0x10(%rbp), %rdi
callq 0x31d0
jmp 0x7100
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x709a
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq -0x282(%rip), %rdi      # 0x6e00
xorl %eax, %eax
movl %eax, %esi
callq 0x6e60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x28c0
jmp 0x70fe
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x70f0
movq -0x8(%rbp), %rdi
callq 0x2920
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
je 0x70c5
leaq 0x4370(%rip), %rdi      # 0xb430
callq 0x23e0
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
leaq -0x29c(%rip), %rdi      # 0x6e40
callq 0x6e60
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x28c0
jmp 0x70fc
leaq 0x4339(%rip), %rdi      # 0xb430
callq 0x23e0
jmp 0x70fe
jmp 0x7100
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0x76b3
movl $0x20, %edi
callq 0x2040
jmp 0x7697
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x7839
movq -0x28(%rbp), %rax
leaq 0x3cc2(%rip), %rcx      # 0xb394
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x3dc4(%rip), %rdi      # 0xb4af
movb $0x1, %al
callq 0x2100
jmp 0x7839
movl $0x22, %edi
callq 0x2040
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x777b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x7, %eax
jl 0x7762
movsbq -0x1d(%rbp), %rax
cmpq $0xe, %rax
jae 0x7762
movsbl -0x1d(%rbp), %eax
subl $0x7, %eax
movslq %eax, %rcx
leaq 0x7bb6(%rip), %rax      # 0xf304
movsbl (%rax,%rcx), %esi
leaq 0x3d5a(%rip), %rdi      # 0xb4b3
movb $0x0, %al
callq 0x2100
jmp 0x776b
movsbl -0x1d(%rbp), %edi
callq 0x2040
jmp 0x776d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7709
leaq 0x3d35(%rip), %rdi      # 0xb4b7
callq 0x2080
jmp 0x7839
leaq 0x3d26(%rip), %rdi      # 0xb4b9
callq 0x2080
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2a60
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x77ed
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x7680
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x77a0
jmp 0x7839
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x3cbe(%rip), %rdi      # 0xb4bc
movb $0x0, %al
callq 0x2100
jmp 0x7839
leaq 0x3cb4(%rip), %rdi      # 0xb4c2
callq 0x2080
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x7680
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x7680
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x800, %rsp            # imm = 0x800
movl $0x1, 0x78fb(%rip)      # 0xf320
leaq 0x3af3(%rip), %rdi      # 0xb51f
movb $0x0, %al
callq 0x2100
leaq 0x3aec(%rip), %rdi      # 0xb526
movb $0x0, %al
callq 0x2100
leaq -0x800(%rbp), %rdi
movq 0x7541(%rip), %rax      # 0xef90
movq (%rax), %rdx
movl $0x800, %esi            # imm = 0x800
callq 0x2160
cmpq $0x0, %rax
jne 0x7a64
jmp 0x7a85
leaq 0x7cc5(%rip), %rdi      # 0xf730
callq 0x2170
cmpl $0x0, %eax
jne 0x7a83
leaq -0x800(%rbp), %rdi
xorl %esi, %esi
callq 0x78c0
jmp 0x7a33
leaq 0x3a26(%rip), %rdi      # 0xb4b2
movl $0x1, %esi
callq 0x78c0
addq $0x800, %rsp            # imm = 0x800
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7cbc
cmpl $0x0, -0xc(%rbp)
jg 0x7cc1
jmp 0x7da7
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7d05
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x7d05
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7da7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x7da7
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x1d(%rbp)
jge 0x7d23
cmpl $0x20, -0x1c(%rbp)
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x7d2c
jmp 0x7d63
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7d0c
jmp 0x7d65
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7da5
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7d65
jmp 0x7da7
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7e4a
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x7e38
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x7e2e
cmpl $0x1, -0x1c(%rbp)
jle 0x7e15
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x21c0
jmp 0x7e2c
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x7e2e
movq $0x0, -0x8(%rbp)
jmp 0x7eaf
jmp 0x7e3a
movq -0x30(%rbp), %rax
addq $0x208, %rax            # imm = 0x208
movq %rax, -0x30(%rbp)
jmp 0x7dcf
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x1, -0x1c(%rbp)
jle 0x7e73
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x21c0
jmp 0x7e8a
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x208, %rcx            # imm = 0x208
movq %rcx, -0x30(%rbp)
movq $0x0, 0x208(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7f46
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x7f34
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x7f2a
cmpl $0x1, -0x1c(%rbp)
jle 0x7f1e
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x2120
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x7f9c
jmp 0x7f36
movq -0x30(%rbp), %rax
addq $0x208, %rax            # imm = 0x208
movq %rax, -0x30(%rbp)
jmp 0x7edf
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x1, -0x1c(%rbp)
jle 0x7f6b
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x2120
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x208, %rcx            # imm = 0x208
movq %rcx, -0x30(%rbp)
movq $0x0, 0x208(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8036
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x8024
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x801a
cmpl $0x1, -0x1c(%rbp)
jle 0x800e
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x2120
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x808c
jmp 0x8026
movq -0x30(%rbp), %rax
addq $0x208, %rax            # imm = 0x208
movq %rax, -0x30(%rbp)
jmp 0x7fcf
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x1, -0x1c(%rbp)
jle 0x805b
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x2120
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x208, %rcx            # imm = 0x208
movq %rcx, -0x30(%rbp)
movq $0x0, 0x208(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x7e8e(%rip), %rax      # 0x101a0
addq $0x50, %rax
cmpq %rax, 0x7ed3(%rip)      # 0x101f0
jb 0x832b
leaq 0x3255(%rip), %rdi      # 0xb57b
callq 0x8af0
movl -0x4(%rbp), %ecx
movq 0x7ebb(%rip), %rax      # 0x101f0
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x7ead(%rip)      # 0x101f0
movl %ecx, (%rax)
movl 0x8061(%rip), %ecx      # 0x103ac
movq 0x804e(%rip), %rax      # 0x103a0
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x8040(%rip)      # 0x103a0
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/libregexp/regcomp.c
// Function: lex
static	int
lex(int literal, int dot_type)
{
	int quoted;

	quoted = nextc(&yyrune);
	if(literal || quoted){
		if(yyrune == 0)
			return END;
		return RUNE;
	}

	switch(yyrune){
	case 0:
		return END;
	case '*':
		return STAR;
	case '?':
		return QUEST;
	case '+':
		return PLUS;
	case '|':
		return OR;
	case '.':
		return dot_type;
	case '(':
		return LBRA;
	case ')':
		return RBRA;
	case '^':
		return BOL;
	case '$':
		return EOL;
	case '[':
		return bldcclass();
	}
	return RUNE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x802b(%rip), %rdi      # 0x103b0
callq 0x8b40
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x8399
cmpl $0x0, -0x10(%rbp)
je 0x83ba
cmpl $0x0, 0x8010(%rip)      # 0x103b0
jne 0x83ae
movl $0xff, -0x4(%rbp)
jmp 0x84a3
movl $0x7f, -0x4(%rbp)
jmp 0x84a3
movl 0x7ff0(%rip), %eax      # 0x103b0
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x8439
jmp 0x83c9
movl -0x14(%rbp), %eax
subl $0x24, %eax
je 0x8489
jmp 0x83d7
movl -0x14(%rbp), %eax
subl $0x28, %eax
je 0x846e
jmp 0x83e5
movl -0x14(%rbp), %eax
subl $0x29, %eax
je 0x8477
jmp 0x83f3
movl -0x14(%rbp), %eax
subl $0x2a, %eax
je 0x8442
jmp 0x83fd
movl -0x14(%rbp), %eax
subl $0x2b, %eax
je 0x8454
jmp 0x8407
movl -0x14(%rbp), %eax
subl $0x2e, %eax
je 0x8466
jmp 0x8411
movl -0x14(%rbp), %eax
subl $0x3f, %eax
je 0x844b
jmp 0x841b
movl -0x14(%rbp), %eax
subl $0x5b, %eax
je 0x8492
jmp 0x8425
movl -0x14(%rbp), %eax
subl $0x5e, %eax
je 0x8480
jmp 0x842f
movl -0x14(%rbp), %eax
subl $0x7c, %eax
je 0x845d
jmp 0x849c
movl $0xff, -0x4(%rbp)
jmp 0x84a3
movl $0x85, -0x4(%rbp)
jmp 0x84a3
movl $0x87, -0x4(%rbp)
jmp 0x84a3
movl $0x86, -0x4(%rbp)
jmp 0x84a3
movl $0x83, -0x4(%rbp)
jmp 0x84a3
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x84a3
movl $0x82, -0x4(%rbp)
jmp 0x84a3
movl $0x81, -0x4(%rbp)
jmp 0x84a3
movl $0xc3, -0x4(%rbp)
jmp 0x84a3
movl $0xc4, -0x4(%rbp)
jmp 0x84a3
callq 0x8bf0
movl %eax, -0x4(%rbp)
jmp 0x84a3
movl $0x7f, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/libregexp/regcomp.c
// Function: operator
static	void
operator(int t)
{
	if(t==RBRA && --nbra<0)
		rcerror("unmatched right paren");
	if(t==LBRA){
		if(++cursubid >= NSUBEXP)
			rcerror ("too many subexpressions");
		nbra++;
		if(lastwasand)
			operator(CAT);
	} else
		evaluntil(t);
	if(t != RBRA)
		pushator(t);
	lastwasand = FALSE;
	if(t==STAR || t==QUEST || t==PLUS || t==RBRA)
		lastwasand = TRUE;	/* these look like operands */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x81, -0x4(%rbp)
jne 0x84e4
movl 0x7cd2(%rip), %eax      # 0x1019c
addl $-0x1, %eax
movl %eax, 0x7cc9(%rip)      # 0x1019c
cmpl $0x0, %eax
jge 0x84e4
leaq 0x313b(%rip), %rdi      # 0xb61a
callq 0x88d0
cmpl $0x82, -0x4(%rbp)
jne 0x8531
movl 0x7eb9(%rip), %eax      # 0x103ac
addl $0x1, %eax
movl %eax, 0x7eb0(%rip)      # 0x103ac
cmpl $0x20, %eax
jl 0x850d
leaq 0x3128(%rip), %rdi      # 0xb630
callq 0x88d0
movl 0x7c89(%rip), %eax      # 0x1019c
addl $0x1, %eax
movl %eax, 0x7c80(%rip)      # 0x1019c
cmpl $0x0, 0x7e85(%rip)      # 0x103a8
je 0x852f
movl $0x84, %edi
callq 0x84b0
jmp 0x8539
movl -0x4(%rbp), %edi
callq 0x8610
cmpl $0x81, -0x4(%rbp)
je 0x854a
movl -0x4(%rbp), %edi
callq 0x8300
movl $0x0, 0x7e54(%rip)      # 0x103a8
cmpl $0x85, -0x4(%rbp)
je 0x8578
cmpl $0x87, -0x4(%rbp)
je 0x8578
cmpl $0x86, -0x4(%rbp)
je 0x8578
cmpl $0x81, -0x4(%rbp)
jne 0x8582
movl $0x1, 0x7e26(%rip)      # 0x103a8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x7e06(%rip)      # 0x103a8
je 0x85ae
movl $0x84, %edi
callq 0x84b0
movl -0x4(%rbp), %edi
callq 0x90a0
movq %rax, -0x10(%rbp)
cmpl $0xc5, -0x4(%rbp)
je 0x85cc
cmpl $0xc6, -0x4(%rbp)
jne 0x85db
movq 0x7de5(%rip), %rcx      # 0x103b8
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpl $0x7f, -0x4(%rbp)
jne 0x85ee
movl 0x7dc9(%rip), %ecx      # 0x103b0
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x90f0
movl $0x1, 0x7da3(%rip)      # 0x103a8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x7635(%rip)      # 0x10188
je 0x8b68
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x8be0
movq -0x10(%rbp), %rdi
movq 0x761d(%rip), %rsi      # 0x10190
callq 0xa8f0
movl %eax, %ecx
movq 0x760f(%rip), %rax      # 0x10190
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x7602(%rip)      # 0x10190
movq -0x10(%rbp), %rax
cmpl $0x5c, (%rax)
jne 0x8bc6
movq -0x10(%rbp), %rdi
movq 0x75ee(%rip), %rsi      # 0x10190
callq 0xa8f0
movl %eax, %ecx
movq 0x75e0(%rip), %rax      # 0x10190
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x75d3(%rip)      # 0x10190
movl $0x1, -0x4(%rbp)
jmp 0x8be0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8bd9
movl $0x1, 0x75af(%rip)      # 0x10188
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/libregexp/regcomp.c
// Function: newinst
static	Reinst*
newinst(int t)
{
	freep->type = t;
	freep->l.left = 0;
	freep->r.right = 0;
	return freep++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
movq 0x6fef(%rip), %rax      # 0x100a0
movl %ecx, (%rax)
movq 0x6fe6(%rip), %rax      # 0x100a0
movq $0x0, 0x10(%rax)
movq 0x6fd7(%rip), %rax      # 0x100a0
movq $0x0, 0x8(%rax)
movq 0x6fc8(%rip), %rax      # 0x100a0
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x6fba(%rip)      # 0x100a0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/libregexp/regcomp.c
// Function: pushand
static	void
pushand(Reinst *f, Reinst *l)
{
	if(andp >= &andstack[NSTACK])
		cant("operand stack overflow");
	andp->first = f;
	andp->last = l;
	andp++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x70f9(%rip), %rax      # 0x10200
addq $0x140, %rax            # imm = 0x140
cmpq %rax, 0x722c(%rip)      # 0x10340
jb 0x9122
leaq 0x252b(%rip), %rdi      # 0xb648
callq 0x8af0
movq -0x8(%rbp), %rcx
movq 0x7213(%rip), %rax      # 0x10340
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x7205(%rip), %rax      # 0x10340
movq %rcx, 0x8(%rax)
movq 0x71fa(%rip), %rax      # 0x10340
addq $0x10, %rax
movq %rax, 0x71ef(%rip)      # 0x10340
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/libregexp/regcomp.c
// Function: popator
static	int
popator(void)
{
	if(atorp <= &atorstack[0])
		cant("operator stack underflow");
	--subidp;
	return *--atorp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7035(%rip), %rax      # 0x101a0
cmpq %rax, 0x707e(%rip)      # 0x101f0
ja 0x9180
leaq 0x2502(%rip), %rdi      # 0xb67d
callq 0x8af0
movq 0x7219(%rip), %rax      # 0x103a0
addq $-0x4, %rax
movq %rax, 0x720e(%rip)      # 0x103a0
movq 0x7057(%rip), %rax      # 0x101f0
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, 0x7049(%rip)      # 0x101f0
movl -0x4(%rax), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x703e(%rip), %rax      # 0x10200
cmpq %rax, 0x7177(%rip)      # 0x10340
ja 0x91f5
movl -0x4(%rbp), %esi
leaq 0x24c1(%rip), %rdi      # 0xb696
callq 0x9210
movl $0xc2, %edi
callq 0x90a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x90f0
movq 0x7144(%rip), %rax      # 0x10340
addq $-0x10, %rax
movq %rax, 0x7139(%rip)      # 0x10340
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/libregexp/regcomp.c
// Function: regerr2
static	void
regerr2(char *s, int c)
{
	char buf[100];
	char *cp = buf;
	while(*s)
		*cp++ = *s++;
	*cp++ = c;
	*cp = '\0';
	rcerror(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9257
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x78(%rbp)
movb %cl, (%rax)
jmp 0x922a
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x78(%rbp)
movb %cl, (%rax)
movq -0x78(%rbp), %rax
movb $0x0, (%rax)
leaq -0x70(%rbp), %rdi
callq 0x88d0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x90(%rbp), %rdi
leaq 0x23fe(%rip), %rsi      # 0xb6ab
movl $0x84, %edx
callq 0x2060
leaq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x83, %edx
callq 0x2130
leaq -0x90(%rbp), %rdi
leaq 0x21d7(%rip), %rsi      # 0xb4b1
movl $0x83, %edx
callq 0x2130
leaq -0x90(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x20e0
movq -0x98(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x20b0
movl $0x1, %edi
callq 0x2250
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x2920, %rsp           # imm = 0x2920
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9385
cmpl $0x0, -0x24(%rbp)
jle 0x9385
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x936c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9383
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x9385
movl $0x0, -0x50(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x7f, (%rax)
jne 0x93c3
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x80, 0x8(%rax)
jae 0x93c3
movl $0x7f, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0xc3, (%rax)
jne 0x93d9
movl $0xc3, -0x50(%rbp)
leaq -0x14c0(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x2910(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x14c0(%rbp), %rax
addq $0x1450, %rax           # imm = 0x1450
addq $-0x410, %rax           # imm = 0xFBF0
movq %rax, -0x60(%rbp)
leaq -0x2910(%rbp), %rax
addq $0x1450, %rax           # imm = 0x1450
addq $-0x410, %rax           # imm = 0xFBF0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x70(%rbp), %r8
callq 0x94a0
movl %eax, -0x2914(%rbp)
cmpl $0x0, -0x2914(%rbp)
jl 0x944f
movl -0x2914(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9488
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x70(%rbp), %r8
callq 0x9b40
movl %eax, -0x2914(%rbp)
cmpl $0x0, -0x2914(%rbp)
jl 0x9481
movl -0x2914(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9488
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x2920, %rsp           # imm = 0x2920
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/libregexp/regexec.c
// Function: regexec2
static int
regexec2(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
)
{
	int rv;
	Relist *relist0, *relist1;

	/* mark space */
	relist0 = malloc(BIGLISTSIZE*sizeof(Relist));
	if(relist0 == NULL)
		return -1;
	relist1 = malloc(BIGLISTSIZE*sizeof(Relist));
	if(relist1 == NULL){
		free(relist0);
		return -1;
	}
	j->relist[0] = relist0;
	j->relist[1] = relist1;
	j->reliste[0] = relist0 + BIGLISTSIZE - 2;
	j->reliste[1] = relist1 + BIGLISTSIZE - 2;

	rv = regexec1(progp, bol, mp, ms, j);
	free(relist0);
	free(relist1);
	return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl $0x1fbd0, %edi          # imm = 0x1FBD0
callq 0x21e0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x9b7c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c21
movl $0x1fbd0, %edi          # imm = 0x1FBD0
callq 0x21e0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x9ba3
movq -0x40(%rbp), %rdi
callq 0x2030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9c21
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
addq $0x1fbd0, %rcx          # imm = 0x1FBD0
addq $-0x410, %rcx           # imm = 0xFBF0
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rcx
addq $0x1fbd0, %rcx          # imm = 0x1FBD0
addq $-0x410, %rcx           # imm = 0xFBF0
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
callq 0x94a0
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2030
movq -0x48(%rbp), %rdi
callq 0x2030
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x2920, %rsp           # imm = 0x2920
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9eb5
cmpl $0x0, -0x24(%rbp)
jle 0x9eb5
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9e9c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9eb3
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x9eb5
movl $0x0, -0x50(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x7f, (%rax)
jne 0x9ef3
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x80, 0x8(%rax)
jae 0x9ef3
movl $0x7f, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0xc3, (%rax)
jne 0x9f09
movl $0xc3, -0x50(%rbp)
leaq -0x14c0(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x2910(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x14c0(%rbp), %rax
addq $0x1450, %rax           # imm = 0x1450
addq $-0x410, %rax           # imm = 0xFBF0
movq %rax, -0x60(%rbp)
leaq -0x2910(%rbp), %rax
addq $0x1450, %rax           # imm = 0x1450
addq $-0x410, %rax           # imm = 0xFBF0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x70(%rbp), %r8
callq 0x9fd0
movl %eax, -0x2914(%rbp)
cmpl $0x0, -0x2914(%rbp)
jl 0x9f7f
movl -0x2914(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9fb8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq -0x70(%rbp), %r8
callq 0xa620
movl %eax, -0x2914(%rbp)
cmpl $0x0, -0x2914(%rbp)
jl 0x9fb1
movl -0x2914(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9fb8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x2920, %rsp           # imm = 0x2920
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phase[P]o/libregexp/rregexec.c
// Function: rregexec2
static int
rregexec2(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[5*LISTSIZE], relist1[5*LISTSIZE];

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

	return rregexec1(progp, bol, mp, ms, j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xcb50, %rsp           # imm = 0xCB50
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x65c0(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
leaq -0xcb50(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq -0x65c0(%rbp), %rcx
addq $0x6590, %rcx           # imm = 0x6590
addq $-0x410, %rcx           # imm = 0xFBF0
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq -0xcb50(%rbp), %rcx
addq $0x6590, %rcx           # imm = 0x6590
addq $-0x410, %rcx           # imm = 0xFBF0
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x9fd0
addq $0xcb50, %rsp           # imm = 0xCB50
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xaacd
jmp 0xaaa9
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rbp)
cmpl $0x0, (%rax)
je 0xaabf
jmp 0xaaa9
movq -0x10(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0xab08
jmp 0xaacf
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xab00
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0xaafe
movq -0x10(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0xab08
jmp 0xaacf
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jae 0xab3a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x20f0
movq %rax, -0x8(%rbp)
jmp 0xabb4
jmp 0xab3c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x80, -0x18(%rbp)
jae 0xab7f
cmpl $0x0, -0x18(%rbp)
jne 0xab5f
movq $0x0, -0x8(%rbp)
jmp 0xabb4
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0xab71
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xabb4
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xab3c
movq -0x10(%rbp), %rsi
leaq -0x1c(%rbp), %rdi
callq 0xa8f0
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0xaba1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xabb4
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0xab3c
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x244c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2620
jmp 0x244e
cmpl $0x2, -0x8(%rbp)
je 0x247d
movq 0x12b9d(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xcb9f(%rip), %rsi      # 0xf004
leaq 0xcbae(%rip), %rdx      # 0xf01a
movb $0x0, %al
callq 0x21c0
movl $0x1, %edi
callq 0x22b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2dd0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x24d9
jmp 0x249a
callq 0x20a0
cmpl $0x0, (%rax)
je 0x24bf
leaq 0xcb7c(%rip), %rdi      # 0xf027
movb $0x0, %al
callq 0x26e0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x24cd
leaq 0xcb61(%rip), %rdi      # 0xf027
movb $0x0, %al
callq 0x2930
jmp 0x24cf
movl $0x1, %edi
callq 0x22b0
movq -0x18(%rbp), %rdi
callq 0x2510
cmpl $0x0, %eax
je 0x24f1
movl $0x1, %edi
callq 0x22b0
movq -0x20(%rbp), %rdi
callq 0x2f90
xorl %edi, %edi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/tests/kvlds-blocking/main.c
// Function: set_get_blocking
static int
set_get_blocking(struct wire_requestqueue * Q)
{
	struct kvldskey * key;
	struct kvldskey * val;
	struct kvldskey * res;
	const char * key_str = "key";
	const char * val_str = "val";

	/* Create pair to store. */
	key = kvldskey_create((const uint8_t *)key_str, strlen(key_str));
	val = kvldskey_create((const uint8_t *)val_str, strlen(val_str));

	/* Store pair. */
	if (kvlds_set(Q, key, val))
		goto err0;

	/* Retrieve value. */
	if (kvlds_get(Q, key, &res))
		goto err0;

	/* Check that it matches the expected one. */
	if (val->len != res->len)
		goto err0;
	if (memcmp(res->buf, val->buf, val->len))
		goto err0;

	/* Clean up. */
	kvldskey_free(key);
	kvldskey_free(val);
	kvldskey_free(res);

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xd8b5(%rip), %rax      # 0xfdd8
movq %rax, -0x30(%rbp)
leaq 0xcb1b(%rip), %rax      # 0xf049
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2100
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2b70
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2100
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x2b70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x33a0
cmpl $0x0, %eax
je 0x258c
jmp 0x2601
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x34c0
cmpl $0x0, %eax
je 0x25a4
jmp 0x2601
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x25b8
jmp 0x2601
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %edx
callq 0x21a0
cmpl $0x0, %eax
je 0x25dd
jmp 0x2601
movq -0x18(%rbp), %rdi
callq 0x2040
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x2608
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1050
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xe63(%rip), %rsi       # 0x2004
callq 0x1040
cmpl $0x0, %eax
jne 0x11f5
leaq 0xe58(%rip), %rdi       # 0x200a
movb $0x0, %al
callq 0x1030
cmpl $0x2, -0x8(%rbp)
jl 0x11d7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xe43(%rip), %rdi       # 0x2011
movb $0x0, %al
callq 0x1030
jmp 0x11e5
leaq 0xe37(%rip), %rdi       # 0x2015
movb $0x0, %al
callq 0x1030
leaq 0xe5a(%rip), %rdi       # 0x2046
movb $0x0, %al
callq 0x1030
jmp 0x1262
movq -0x18(%rbp), %rdi
leaq 0xe1b(%rip), %rsi       # 0x201b
callq 0x1040
cmpl $0x0, %eax
jne 0x1252
cmpl $0x3, -0x8(%rbp)
jl 0x1242
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1060
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1060
movl -0x1c(%rbp), %esi
addl %eax, %esi
leaq 0xde6(%rip), %rdi       # 0x201f
movb $0x0, %al
callq 0x1030
jmp 0x1250
leaq 0xdda(%rip), %rdi       # 0x2023
movb $0x0, %al
callq 0x1030
jmp 0x1260
leaq 0xdde(%rip), %rdi       # 0x2037
movb $0x0, %al
callq 0x1030
jmp 0x1262
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/event.c
// Function: event
static int _event(char const * progname)
{
	int ret;
	Event * event;

	printf("%s: Testing event_new()\n", progname);
	if((event = event_new()) == NULL)
		return -1;
	printf("%s: Testing event_loop()\n", progname);
	event_register_idle(event, _event_on_idle, event);
	ret = event_loop(event);
	event_delete(event);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xe1d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1050
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1206
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1247
movq -0x10(%rbp), %rsi
leaq 0xe0c(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1030
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x29(%rip), %rsi        # 0x1250
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x1070
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1080
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
jge 0x1255
movl $0x1, -0x4(%rbp)
jmp 0x12ca
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1930
cmpl $0x0, %eax
jge 0x1274
movl $0x2, -0x4(%rbp)
jmp 0x12ca
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1e90
cmpl $0x0, %eax
jge 0x1293
movl $0x3, -0x4(%rbp)
jmp 0x12ca
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x1f40
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1d60
cmpl $0x0, %eax
jge 0x12c3
movl $0x4, -0x4(%rbp)
jmp 0x12ca
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1d01(%rip), %rsi      # 0x3004
callq 0x1100
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x131d
movq $0x0, -0x8(%rbp)
jmp 0x1358
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1370
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1350
movq -0x30(%rbp), %rdi
callq 0x1070
movq $0x0, -0x8(%rbp)
jmp 0x1358
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)