LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: prologue
static void
prologue(Isel *s, Func *fn, size_t sz)
{
	Loc *rsp;
	Loc *rbp;
	Loc *stksz;
	Loc *phys;
	size_t i;

	rsp = locphysreg(Rrsp);
	rbp = locphysreg(Rrbp);
	stksz = loclit(sz, ModeQ);
	/* enter function */
	g(s, Ipush, rbp, NULL);
	g(s, Imov, rsp, rbp, NULL);
	g(s, Isub, stksz, rsp, NULL);
	/* save registers */
	for (i = 0; savedregs[i] != Rnone; i++) {
		phys = locphysreg(savedregs[i]);
		s->calleesave[i] = locreg(phys->mode);
		if (isfloatmode(phys->mode)) {
			g(s, Imovs, phys, s->calleesave[i], NULL);
		} else {
			g(s, Imov, phys, s->calleesave[i], NULL);
		}
	}
	if (s->envp)
		g(s, Imov, locphysreg(Rrax), s->envp, NULL);
	addarglocs(s, fn);
	s->nsaved = i;
	s->stksz = stksz; /* need to update if we spill */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x3b, %edi
callq 0xffc0
movq %rax, -0x20(%rbp)
movl $0x3c, %edi
callq 0xffc0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x101f0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x1b, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0xbf80
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x7, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rcx
leaq 0x518a9(%rip), %rax     # 0x60200
cmpl $0x0, (%rax,%rcx,4)
je 0xea06
movq -0x40(%rbp), %rcx
leaq 0x51894(%rip), %rax     # 0x60200
movl (%rax,%rcx,4), %edi
callq 0xffc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xff10
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rdx, 0x78(%rax,%rcx,8)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xfd70
cmpl $0x0, %eax
je 0xe9cd
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x78(%rax,%rcx,8), %rcx
movl $0x27, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
jmp 0xe9f3
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x78(%rax,%rcx,8), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
jmp 0xe9f5
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xe94c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0xea43
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x35, %edi
callq 0xffc0
movq -0x48(%rbp), %rdi
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd9f0
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x3a8(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: isel
static void
isel(Isel *s, Node *n)
{
	switch (n->type) {
	case Nexpr:
		selexpr(s, n);
		break;
	case Ndecl:
		break;
	default:
		die("Bad node type in isel()");
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x8, %eax
je 0xeaab
jmp 0xeaa1
movl -0x14(%rbp), %eax
subl $0xb, %eax
je 0xeaba
jmp 0xeabc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xaaf0
jmp 0xeaca
jmp 0xeaca
leaq 0x3ded6(%rip), %rdi     # 0x4c999
movb $0x0, %al
callq 0x1df20
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: load
static void
load(Isel *s, Loc *a, Loc *b)
{
	Loc *l;

	assert(b->type == Locreg);
	if (a->type == Locreg)
		l = locmem(0, b, NULL, a->mode);
	else
		l = a;
	if (isfloatmode(b->mode))
		g(s, Imovs, l, b, NULL);
	else
		g(s, Imov, l, b, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xf21f
jmp 0xf23e
leaq 0x3d4fc(%rip), %rdi     # 0x4c722
leaq 0x3d469(%rip), %rsi     # 0x4c696
movl $0x10e, %edx            # imm = 0x10E
leaq 0x3d4fb(%rip), %rcx     # 0x4c734
callq 0x6160
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xf264
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
callq 0x10050
movq %rax, -0x20(%rbp)
jmp 0xf26c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xfd70
cmpl $0x0, %eax
je 0xf29c
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x27, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
jmp 0xf2b9
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: tymode
static Mode
tymode(Type *t)
{
	/* FIXME: What should the mode for, say, structs be when we have no
	 * intention of loading /through/ the pointer? For now, we'll just say it's
	 * the pointer mode, since we expect to address through the pointer */
	t = tybase(t);
	switch (t->type) {
	case Tyflt32:	return ModeF;	break;
	case Tyflt64:	return ModeD;	break;
	default:
		if (isstacktype(t))
			return ModeQ;
		switch (tysize(t)) {
		case 1:	return ModeB;	break;
		case 2:	return ModeW;	break;
		case 4:	return ModeL;	break;
		case 8:	return ModeQ;	break;
		}
		break;
	}
	return ModeNone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36a30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xf, %eax
je 0xf2f3
jmp 0xf2e9
movl -0x14(%rbp), %eax
subl $0x10, %eax
je 0xf2fc
jmp 0xf305
movl $0x5, -0x4(%rbp)
jmp 0xf373
movl $0x6, -0x4(%rbp)
jmp 0xf373
movq -0x10(%rbp), %rdi
callq 0x369d0
cmpl $0x0, %eax
je 0xf31c
movl $0x4, -0x4(%rbp)
jmp 0xf373
movq -0x10(%rbp), %rdi
callq 0x1c0f0
decq %rax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0xf36a
movq -0x20(%rbp), %rax
leaq 0x3d25b(%rip), %rcx     # 0x4c598
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0xf373
movl $0x2, -0x4(%rbp)
jmp 0xf373
movl $0x3, -0x4(%rbp)
jmp 0xf373
movl $0x4, -0x4(%rbp)
jmp 0xf373
jmp 0xf36c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: ismergablemul
static int
ismergablemul(Node *n, int *r)
{
	int v;

	if (exprop(n) != Omul)
		return 0;
	if (exprop(n->expr.args[1]) != Olit)
		return 0;
	if (n->expr.args[1]->expr.args[0]->type != Nlit)
		return 0;
	if (n->expr.args[1]->expr.args[0]->lit.littype != Lint)
		return 0;
	v = n->expr.args[1]->expr.args[0]->lit.intval;
	if (v != 2 && v != 4 && v != 8)
		return 0;
	*r = v;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x4, %eax
je 0xf3aa
movl $0x0, -0x4(%rbp)
jmp 0xf455
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2f210
cmpl $0x35, %eax
je 0xf3cc
movl $0x0, -0x4(%rbp)
jmp 0xf455
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x9, 0x8(%rax)
je 0xf3ee
movl $0x0, -0x4(%rbp)
jmp 0xf455
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x2, 0x18(%rax)
je 0xf410
movl $0x0, -0x4(%rbp)
jmp 0xf455
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0xf445
cmpl $0x4, -0x1c(%rbp)
je 0xf445
cmpl $0x8, -0x1c(%rbp)
je 0xf445
movl $0x0, -0x4(%rbp)
jmp 0xf455
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: tymodepart
static Mode tymodepart(Type *t, int is_float, size_t displacement)
{
	assert(isstacktype(t));
	size_t sz = tysize(t);

	if (is_float) {
		switch(sz - displacement) {
		case 4: return ModeF; break;
		default: return ModeD; break;
		}
	} else {
		switch(sz - displacement) {
		case 1: return ModeB; break;
		case 2: return ModeW; break;
		case 4: return ModeL; break;
		default: return ModeQ; break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x369d0
cmpl $0x0, %eax
je 0xf483
jmp 0xf4a2
leaq 0x3d2fe(%rip), %rdi     # 0x4c788
leaq 0x3d205(%rip), %rsi     # 0x4c696
movl $0x5c, %edx
leaq 0x3d2fa(%rip), %rcx     # 0x4c797
callq 0x6160
movq -0x10(%rbp), %rdi
callq 0x1c0f0
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xf4da
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
jne 0xf4d1
jmp 0xf4c8
movl $0x5, -0x4(%rbp)
jmp 0xf52b
movl $0x6, -0x4(%rbp)
jmp 0xf52b
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
subq $0x1, %rax
je 0xf509
jmp 0xf4f1
movq -0x30(%rbp), %rax
subq $0x2, %rax
je 0xf512
jmp 0xf4fd
movq -0x30(%rbp), %rax
subq $0x4, %rax
je 0xf51b
jmp 0xf524
movl $0x1, -0x4(%rbp)
jmp 0xf52b
movl $0x2, -0x4(%rbp)
jmp 0xf52b
movl $0x3, -0x4(%rbp)
jmp 0xf52b
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: call
static void
call(Isel *s, Node *n)
{
	AsmOp op;
	Node *fn;
	Loc *f, *e;

	if (exprop(n) == Ocall) {
		op = Icall;
		fn = n->expr.args[0];
		assert(tybase(exprtype(fn))->type == Tycode);
		f = locmeml(htget(s->globls, fn), NULL, NULL, mode(fn));
	} else {
		op = Icallind;
		f = selexpr(s, n->expr.args[0]);
		e = selexpr(s, n->expr.args[1]);
		g(s, Imov, e, locphysreg(Rrax), NULL);
	}
	g(s, op, f, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x2d, %eax
jne 0xf8f5
movl $0x32, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
cmpl $0x1e, (%rax)
jne 0xf8a0
jmp 0xf8bf
leaq 0x3cfbb(%rip), %rdi     # 0x4c862
leaq 0x3cde8(%rip), %rsi     # 0x4c696
movl $0x21a, %edx            # imm = 0x21A
leaq 0x3cfcd(%rip), %rcx     # 0x4c887
callq 0x6160
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x49490
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc110
movq -0x38(%rbp), %rdi
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10120
movq %rax, -0x28(%rbp)
jmp 0xf963
movl $0x33, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
callq 0xaaf0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rsi
callq 0xaaf0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x35, %edi
callq 0xffc0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0xbf80
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: varloc
static Loc *
varloc(Isel *s, Node *n)
{
	ssize_t off;
	Loc *l, *rip;

	/* we need to try getting it from the stack first, in case we
	 * forced it to stack for addressing */
	if (hthas(s->globls, n)) {
		rip = locphysreg(Rrip);
		l = locmeml(htget(s->globls, n), rip, NULL, mode(n));
	} else if (hthas(s->envoff, n)) {
		off = ptoi(htget(s->envoff, n));
		l = locmem(off, s->envp, NULL, mode(n));
	} else if (hthas(s->stkoff, n)) {
		off = ptoi(htget(s->stkoff, n));
		l = locmem(-off, locphysreg(Rrbp), NULL, mode(n));
	} else if (stacknode(n)) {
		assert(0);
	} else {
		l = htget(s->reglocs, n);
		if (!l) {
			l = locreg(mode(n));
			htput(s->reglocs, n, l);
		}
	}
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0xf9f6
movl $0x65, %edi
callq 0xffc0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc110
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x10120
movq %rax, -0x20(%rbp)
jmp 0xfb49
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0xfa62
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, %rdi
callq 0xfd10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc110
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x10050
movq %rax, -0x20(%rbp)
jmp 0xfb47
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0xfacf
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, %rdi
callq 0xfd10
movq %rax, -0x18(%rbp)
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x3c, %edi
callq 0xffc0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc110
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x10050
movq %rax, -0x20(%rbp)
jmp 0xfb45
movq -0x10(%rbp), %rdi
callq 0x167b0
cmpl $0x0, %eax
je 0xfafc
leaq 0x3e23a(%rip), %rdi     # 0x4dd1e
leaq 0x3cbab(%rip), %rsi     # 0x4c696
movl $0xa2, %edx
leaq 0x3cdaa(%rip), %rcx     # 0x4c8a1
callq 0x6160
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x49490
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xfb41
movq -0x10(%rbp), %rdi
callq 0xc110
movl %eax, %edi
callq 0xff10
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x49100
jmp 0xfb43
jmp 0xfb45
jmp 0xfb47
jmp 0xfb49
movq -0x20(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: stor
static void
stor(Isel *s, Loc *a, Loc *b)
{
	Loc *l;

	assert(a->type == Locreg || a->type == Loclit);
	if (b->type == Locreg)
		l = locmem(0, b, NULL, b->mode);
	else
		l = b;
	if (isfloatmode(b->mode))
		g(s, Imovs, a, l, NULL);
	else
		g(s, Imov, a, l, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0xfb86
movq -0x10(%rbp), %rax
cmpl $0x5, (%rax)
jne 0xfb88
jmp 0xfba7
leaq 0x3cc4e(%rip), %rdi     # 0x4c7dd
leaq 0x3cb00(%rip), %rsi     # 0x4c696
movl $0x11e, %edx            # imm = 0x11E
leaq 0x3cc62(%rip), %rcx     # 0x4c804
callq 0x6160
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xfbcd
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
callq 0x10050
movq %rax, -0x20(%rbp)
jmp 0xfbd5
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xfd70
cmpl $0x0, %eax
je 0xfc05
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x27, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
jmp 0xfc22
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xbf80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: forcefltmode
static Mode
forcefltmode(Mode m)
{
	assert(m != ModeNone);
	switch (m) {
	case ModeQ: return ModeD;
	case ModeD: return ModeD;
	default: return ModeF;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xfc43
jmp 0xfc62
leaq 0x3cbda(%rip), %rdi     # 0x4c824
leaq 0x3ca45(%rip), %rsi     # 0x4c696
movl $0x71, %edx
leaq 0x3cbd5(%rip), %rcx     # 0x4c832
callq 0x6160
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x4, %eax
je 0xfc79
jmp 0xfc6f
movl -0xc(%rbp), %eax
subl $0x6, %eax
je 0xfc82
jmp 0xfc8b
movl $0x6, -0x4(%rbp)
jmp 0xfc92
movl $0x6, -0x4(%rbp)
jmp 0xfc92
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/isel.c
// Function: forceintmode
static Mode
forceintmode(Mode m)
{
	assert(m != ModeNone);
	switch (m) {
	case ModeD: return ModeQ;
	case ModeF: return ModeL;
	default: return m;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xfcb3
jmp 0xfcd2
leaq 0x3cb6a(%rip), %rdi     # 0x4c824
leaq 0x3c9d5(%rip), %rsi     # 0x4c696
movl $0x7c, %edx
leaq 0x3cb7d(%rip), %rcx     # 0x4c84a
callq 0x6160
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x5, %eax
je 0xfcf2
jmp 0xfcdf
movl -0xc(%rbp), %eax
subl $0x6, %eax
jne 0xfcfb
jmp 0xfce9
movl $0x4, -0x4(%rbp)
jmp 0xfd01
movl $0x3, -0x4(%rbp)
jmp 0xfd01
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/locs.c
// Function: locstrlbl
Loc *
locstrlbl(char *lbl)
{
	Loc *l;

	l = zalloc(sizeof(Loc));
	l->type = Loclbl;
	l->mode = ModeQ;
	l->lbl = strdup(lbl);
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x48160
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movl $0x4, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/locs.c
// Function: loclbl
Loc *
loclbl(Node *e)
{
	Node *lbl;
	assert(e->type == Nexpr);
	lbl = e->expr.args[0];
	assert(lbl->type == Nlit);
	assert(lbl->lit.littype == Llbl);
	return locstrlbl(lbl->lit.lblval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0xfe58
jmp 0xfe77
leaq 0x3cb52(%rip), %rdi     # 0x4c9b1
leaq 0x3cb5c(%rip), %rsi     # 0x4c9c2
movl $0x44, %edx
leaq 0x3cb57(%rip), %rcx     # 0x4c9c9
callq 0x6160
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x9, 0x8(%rax)
jne 0xfe92
jmp 0xfeb1
leaq 0x3cb44(%rip), %rdi     # 0x4c9dd
leaq 0x3cb22(%rip), %rsi     # 0x4c9c2
movl $0x46, %edx
leaq 0x3cb1d(%rip), %rcx     # 0x4c9c9
callq 0x6160
movq -0x10(%rbp), %rax
cmpl $0x6, 0x18(%rax)
jne 0xfebd
jmp 0xfedc
leaq 0x3cb2b(%rip), %rdi     # 0x4c9ef
leaq 0x3caf7(%rip), %rsi     # 0x4c9c2
movl $0x47, %edx
leaq 0x3caf2(%rip), %rcx     # 0x4c9c9
callq 0x6160
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xfda0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/locs.c
// Function: locregid
static Loc *
locregid(regid id, Mode m)
{
	Loc *l;

	l = zalloc(sizeof(Loc));
	l->type = Locreg;
	l->mode = m;
	l->reg.id = id;
	locmap = xrealloc(locmap, maxregid * sizeof(Loc*));
	locmap[l->reg.id] = l;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x38, %edi
callq 0x48160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x6ca1c(%rip), %rdi     # 0x7c9a0
movq 0x6ca1d(%rip), %rsi     # 0x7c9a8
shlq $0x3, %rsi
callq 0x48240
movq %rax, 0x6ca05(%rip)     # 0x7c9a0
movq -0x18(%rbp), %rdx
movq 0x6c9fa(%rip), %rax     # 0x7c9a0
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/locs.c
// Function: locphysreg
Loc *
locphysreg(Reg r)
{
	static Loc *physregs[Nreg] = {0,};

	if (physregs[r])
		return physregs[r];
	physregs[r] = locreg(regmodes[r]);
	physregs[r]->reg.colour = r;
	return physregs[r];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x6c9d9(%rip), %rax     # 0x7c9b0
cmpq $0x0, (%rax,%rcx,8)
je 0xfff4
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x6c9c6(%rip), %rax     # 0x7c9b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x10045
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x50220(%rip), %rax     # 0x60220
movl (%rax,%rcx,4), %edi
callq 0xff10
movq %rax, %rdx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x6c999(%rip), %rax     # 0x7c9b0
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %ecx
movl -0xc(%rbp), %eax
movl %eax, %edx
leaq 0x6c986(%rip), %rax     # 0x7c9b0
movq (%rax,%rdx,8), %rax
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x6c973(%rip), %rax     # 0x7c9b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/locs.c
// Function: locmem
Loc *
locmem(long disp, Loc *base, Loc *idx, Mode mode)
{
	Loc *l;

	l = zalloc(sizeof(Loc));
	l->type = Locmem;
	l->mode = mode;
	l->mem.constdisp = disp;
	l->mem.base = base;
	l->mem.idx = idx;
	l->mem.scale = 1;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x38, %edi
callq 0x48160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x3, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/locs.c
// Function: locmeml
Loc *
locmeml(char *disp, Loc *base, Loc *idx, Mode mode)
{
	Loc *l;

	l = zalloc(sizeof(Loc));
	l->type = Locmeml;
	l->mode = mode;
	l->mem.lbldisp = strdup(disp);
	l->mem.base = base;
	l->mem.idx = idx;
	l->mem.scale = 1;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x38, %edi
callq 0x48160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x4, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x6330
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/locs.c
// Function: loclit
Loc *
loclit(long val, Mode m)
{
	Loc *l;

	l = zalloc(sizeof(Loc));
	l->type = Loclit;
	l->mode = m;
	l->lit = val;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x38, %edi
callq 0x48160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/main.c
// Function: usage
static void
usage(char *prog)
{
	printf("%s [-?|-h] [-o outfile] [-O dir] [-d[dbgopts]] inputs\n", prog);
	printf("\t-?|-h\tPrint this help\n");
	printf("\t-o\tOutput to outfile\n");
	printf("\t-O dir\tOutput to dir\n");
	printf("\t-S\tGenerate assembly source alongside object code\n");
	printf("\t-T\tCompile in test mode\n");
	printf("\t-c\tEnable additional (possibly flaky) checking\n");
	printf("\t-I path\tAdd 'path' to use search path\n");
	printf("\t-d\tPrint debug dumps. Recognized options: f r p i\n");
	printf("\t-G\tGenerate asm in gas syntax\n");
	printf("\t-9\tGenerate asm in plan 9 syntax\n");
	printf("\t-d opts: additional debug logging. Options are listed below:\n");
	printf("\t\tf: log folded trees\n");
	printf("\t\tl: log lowered pre-cfg trees\n");
	printf("\t\tT: log tree immediately\n");
	printf("\t\tr: log register allocation activity\n");
	printf("\t\ti: log instruction selection activity\n");
	printf("\t\tu: log type unifications\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x3d073(%rip), %rdi     # 0x4d82a
movb $0x0, %al
callq 0x6120
leaq 0x3d09c(%rip), %rdi     # 0x4d861
movb $0x0, %al
callq 0x6120
leaq 0x3d0a6(%rip), %rdi     # 0x4d879
movb $0x0, %al
callq 0x6120
leaq 0x3d0af(%rip), %rdi     # 0x4d890
movb $0x0, %al
callq 0x6120
leaq 0x3d0b8(%rip), %rdi     # 0x4d8a7
movb $0x0, %al
callq 0x6120
leaq 0x3d0de(%rip), %rdi     # 0x4d8db
movb $0x0, %al
callq 0x6120
leaq 0x3d0ea(%rip), %rdi     # 0x4d8f5
movb $0x0, %al
callq 0x6120
leaq 0x3d10d(%rip), %rdi     # 0x4d926
movb $0x0, %al
callq 0x6120
leaq 0x3d127(%rip), %rdi     # 0x4d94e
movb $0x0, %al
callq 0x6120
leaq 0x3d14d(%rip), %rdi     # 0x4d982
movb $0x0, %al
callq 0x6120
leaq 0x3d15f(%rip), %rdi     # 0x4d9a2
movb $0x0, %al
callq 0x6120
leaq 0x3d174(%rip), %rdi     # 0x4d9c5
movb $0x0, %al
callq 0x6120
leaq 0x3d1a5(%rip), %rdi     # 0x4da04
movb $0x0, %al
callq 0x6120
leaq 0x3d1ae(%rip), %rdi     # 0x4da1b
movb $0x0, %al
callq 0x6120
leaq 0x3d1c0(%rip), %rdi     # 0x4da3b
movb $0x0, %al
callq 0x6120
leaq 0x3d1cd(%rip), %rdi     # 0x4da56
movb $0x0, %al
callq 0x6120
leaq 0x3d1e6(%rip), %rdi     # 0x4da7d
movb $0x0, %al
callq 0x6120
leaq 0x3d201(%rip), %rdi     # 0x4daa6
movb $0x0, %al
callq 0x6120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/main.c
// Function: dirname
static char *
dirname(char *path)
{
	char *p;

	p = strrchr(path, '/');
	if (p)
		return strdupn(path, p - path);
	else
		return xstrdup(".");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x6140
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x108ff
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
callq 0x4a340
movq %rax, -0x8(%rbp)
jmp 0x1090f
leaq 0x43887(%rip), %rdi     # 0x5418d
callq 0x4a390
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/main.c
// Function: hasmain
static int
hasmain(void)
{
	Node *n, *name;

	name = mknsname(Zloc, NULL, "main");
	n = getdcl(file.globls, name);
	if (!n)
		return 0;
	n = n->decl.name;
	if (n->name.ns)
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x3d17d(%rip), %rdx     # 0x4dac2
callq 0x2fec0
movq %rax, -0x18(%rbp)
movq 0x6c4d3(%rip), %rdi     # 0x7ce28
movq -0x18(%rbp), %rsi
callq 0x334b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10972
movl $0x0, -0x4(%rbp)
jmp 0x10999
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x10992
movl $0x0, -0x4(%rbp)
jmp 0x10999
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/main.c
// Function: swapout
static void
swapout(char* buf, size_t sz, char* suf) {
	char* psuffix;
	psuffix = strrchr(outfile, '.');
	if (psuffix != NULL)
		swapsuffix(buf, sz, outfile, psuffix, suf);
	else
		bprintf(buf, sz, "%s%s", outfile, suf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x6c315(%rip), %rdi     # 0x7cce0
movl $0x2e, %esi
callq 0x6140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x109fe
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x6c2f1(%rip), %rdx     # 0x7cce0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x4a450
jmp 0x10a1f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x6c2d3(%rip), %rcx     # 0x7cce0
movq -0x18(%rbp), %r8
leaq 0x3d0c8(%rip), %rdx     # 0x4dae0
movb $0x0, %al
callq 0x4a230
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/main.c
// Function: gentempfile
static char *
gentempfile(char *buf, size_t bufsz, char *path, char *suffix)
{
	char *tmpdir;
	char *base;
	struct timeval tv;

	tmpdir = getenv("TMPDIR");
	if (!tmpdir)
		tmpdir = "/tmp";
	base = strrchr(path, '/');
	if (base)
		base++;
	else
		base = path;
	gettimeofday(&tv, NULL);
	bprintf(buf, bufsz, "%s/tmp%lx%lx-%s%s", tmpdir, (long)tv.tv_sec, (long)tv.tv_usec, base, suffix);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x3d078(%rip), %rdi     # 0x4dac7
callq 0x6030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x10a6a
leaq 0x3d068(%rip), %rax     # 0x4dace
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x6140
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x10a91
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x10a99
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6150
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x30(%rbp), %r10
movq -0x20(%rbp), %rax
leaq 0x3d00a(%rip), %rdx     # 0x4dad3
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x4a230
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/main.c
// Function: genuse
static void
genuse(char *path)
{
	FILE *f;
	char buf[256];
	char *psuffix;
	size_t i;

	if (outfile != NULL)
		swapout(buf, 1024, ".use");
	else {
		psuffix = strrchr(path, '+');
		i = 0;
		if (objdir)
			i = bprintf(buf, sizeof buf, "%s/", objdir);
		if (psuffix != NULL)
			swapsuffix(buf + i, sizeof buf - i, path, psuffix, ".use");
		else
			swapsuffix(buf + i, sizeof buf - i, path, ".myr", ".use");
	}
	mkpath(buf);
	f = fopen(buf, "w");
	if (!f) {
		fprintf(stderr, "could not open path %s\n", buf);
		exit(1);
	}
	writeuse(f);
	fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x6c1d9(%rip)     # 0x7cce0
je 0x10b26
leaq -0x110(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
leaq 0x43996(%rip), %rdx     # 0x544b2
callq 0x109b0
jmp 0x10be8
movq -0x8(%rbp), %rdi
movl $0x2b, %esi
callq 0x6140
movq %rax, -0x118(%rbp)
movq $0x0, -0x120(%rbp)
cmpq $0x0, 0x6c1a2(%rip)     # 0x7ccf0
je 0x10b78
leaq -0x110(%rbp), %rdi
movq 0x6c192(%rip), %rcx     # 0x7ccf0
movl $0x100, %esi            # imm = 0x100
leaq 0x3cf7b(%rip), %rdx     # 0x4dae5
movb $0x0, %al
callq 0x4a230
movq %rax, -0x120(%rbp)
cmpq $0x0, -0x118(%rbp)
je 0x10bb5
leaq -0x110(%rbp), %rdi
addq -0x120(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
subq -0x120(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x118(%rbp), %rcx
leaq 0x43904(%rip), %r8      # 0x544b2
callq 0x4a450
jmp 0x10be6
leaq -0x110(%rbp), %rdi
addq -0x120(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
subq -0x120(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq 0x3cc4b(%rip), %rcx     # 0x4d825
leaq 0x438d1(%rip), %r8      # 0x544b2
callq 0x4a450
jmp 0x10be8
leaq -0x110(%rbp), %rdi
callq 0x10ef0
leaq -0x110(%rbp), %rdi
leaq 0x3aa3d(%rip), %rsi     # 0x4b63f
callq 0x62d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10c3b
movq 0x4e3d7(%rip), %rax     # 0x5eff0
movq (%rax), %rdi
leaq -0x110(%rbp), %rdx
leaq 0x3cebf(%rip), %rsi     # 0x4dae9
movb $0x0, %al
callq 0x6230
movl $0x1, %edi
callq 0x6310
movq -0x10(%rbp), %rdi
callq 0x3e550
movq -0x10(%rbp), %rdi
callq 0x60f0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/main.c
// Function: mkpath
static void
mkpath(char *p)
{
	char *e, path[256];

	e = p;
	assert(strlen(p) < sizeof(path));
	while ((e = strstr(e, "/")) != NULL) {
		memcpy(path, p, (e - p));
		path[e - p] = 0;
		mkdir(path, 0755);
		e++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6100
cmpq $0x100, %rax            # imm = 0x100
jae 0x10f1a
jmp 0x10f39
leaq 0x3cbe0(%rip), %rdi     # 0x4db01
leaq 0x3cbf2(%rip), %rsi     # 0x4db1a
movl $0x4b, %edx
leaq 0x3cbed(%rip), %rcx     # 0x4db21
callq 0x6160
jmp 0x10f3b
movq -0x10(%rbp), %rdi
leaq 0x3cba1(%rip), %rsi     # 0x4dae7
callq 0x6360
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x10fa2
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
subq %rax, %rdx
callq 0x6260
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movb $0x0, -0x110(%rbp,%rax)
leaq -0x110(%rbp), %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x6090
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x10f3b
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: rclass
Rclass
rclass(Loc *l)
{
	switch (l->mode) {
	case ModeNone:	return Classbad;
	case Nmode:	return Classbad;
	case ModeB:	return Classint;
	case ModeW:	return Classint;
	case ModeL:	return Classint;
	case ModeQ:	return Classint;

	case ModeF:	return Classflt;
	case ModeD:	return Classflt;
	}
	return Classbad;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x11025
movq -0x18(%rbp), %rax
leaq 0x3cba8(%rip), %rcx     # 0x4db7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x1102c
movl $0x0, -0x4(%rbp)
jmp 0x1102c
movl $0x1, -0x4(%rbp)
jmp 0x1102c
movl $0x1, -0x4(%rbp)
jmp 0x1102c
movl $0x1, -0x4(%rbp)
jmp 0x1102c
movl $0x1, -0x4(%rbp)
jmp 0x1102c
movl $0x2, -0x4(%rbp)
jmp 0x1102c
movl $0x2, -0x4(%rbp)
jmp 0x1102c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: issubreg
int
issubreg(Loc *a, Loc *b)
{
	if(a->type != Locreg || b->type != Locreg)
		return 0;
	if(a->reg.colour == Rnone || b->reg.colour == Rnone)
		return 0;
	return rclass(a) == rclass(b) && a->mode != b->mode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x11062
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x1106b
movl $0x0, -0x4(%rbp)
jmp 0x110ca
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x1107f
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x11088
movl $0x0, -0x4(%rbp)
jmp 0x110ca
movq -0x10(%rbp), %rdi
callq 0x10fb0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10fb0
movl -0x20(%rbp), %ecx
movl %eax, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jne 0x110bf
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: dumbmov
int
dumbmov(Loc *a, Loc *b)
{
	/*
	 * moving a reg to itself is dumb,
	 * but we generate a lot of these as part
	 * of register coalescing.
	 */
	if (a->type != Locreg || b->type != Locreg)
		return 0;
	if (a->reg.colour == Rnone || b->reg.colour == Rnone)
		return 0;
	return a->reg.colour == b->reg.colour;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x110fe
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x11107
movl $0x0, -0x4(%rbp)
jmp 0x1113d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x1111b
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x11124
movl $0x0, -0x4(%rbp)
jmp 0x1113d
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: replacealias
void
replacealias(Isel *s, Loc **map, size_t nreg, Insn *insn)
{
	size_t i;
	Loc *l;

	if (!map)
		return;
	for (i = 0; i < insn->nargs; i++) {
		l = insn->args[i];
		if (l->type == Locreg) {
			insn->args[i] = locmap[getalias(s, l->reg.id)];
		} else if (l->type == Locmem || l->type == Locmeml) {
			if (l->mem.base)
				l->mem.base = locmap[getalias(s, l->mem.base->reg.id)];
			if (l->mem.idx)
				l->mem.idx = locmap[getalias(s, l->mem.idx->reg.id)];
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11174
jmp 0x11293
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x11293
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x111e4
leaq 0x6b7f1(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x112a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
jmp 0x11280
movq -0x30(%rbp), %rax
cmpl $0x3, (%rax)
je 0x111fa
movq -0x30(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x1127e
movq -0x30(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1123b
leaq 0x6b794(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x112a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq (%rax,%rcx,8), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1127c
leaq 0x6b753(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x112a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rax,%rcx,8), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x1127e
jmp 0x11280
jmp 0x11282
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1117c
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: mkworklist
static void
mkworklist(Isel *s)
{
	size_t i;

	for (i = 0; bsiter(s->initial, &i); i++) {
		if (bshas(s->prepainted, i))
			continue;
		else if (!istrivial(s, i))
			wlput(&s->wlspill, &s->nwlspill, locmap[i]);
		else if (moverelated(s, i)) {
			wlput(&s->wlfreeze, &s->nwlfreeze, locmap[i]);
		}
		else
			wlput(&s->wlsimp, &s->nwlsimp, locmap[i]);
		locmap[i]->reg.colour = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x4c8(%rax), %rdi
leaq -0x10(%rbp), %rsi
callq 0x48860
cmpl $0x0, %eax
je 0x127fc
movq -0x8(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x1271f
jmp 0x127eb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14530
cmpl $0x0, %eax
jne 0x12760
movq -0x8(%rbp), %rdi
addq $0x470, %rdi            # imm = 0x470
movq -0x8(%rbp), %rsi
addq $0x478, %rsi            # imm = 0x478
leaq 0x6a252(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x14590
jmp 0x127d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x145d0
cmpl $0x0, %eax
je 0x127a1
movq -0x8(%rbp), %rdi
addq $0x480, %rdi            # imm = 0x480
movq -0x8(%rbp), %rsi
addq $0x488, %rsi            # imm = 0x488
leaq 0x6a211(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x14590
jmp 0x127ce
movq -0x8(%rbp), %rdi
addq $0x490, %rdi            # imm = 0x490
movq -0x8(%rbp), %rsi
addq $0x498, %rsi            # imm = 0x498
leaq 0x6a1e2(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x14590
jmp 0x127d0
jmp 0x127d2
leaq 0x6a1c7(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x126e4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: simp
static void
simp(Isel *s)
{
	Loc *l;
	regid m;
	size_t i;

	l = lpop(&s->wlsimp, &s->nwlsimp);
	wlput(&s->selstk, &s->nselstk, l);
	for (i = 0; i < s->ngadj[l->reg.id]; i++) {
		m = s->gadj[l->reg.id][i];
		if (adjavail(s, m))
			decdegree(s, m);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x490, %rdi            # imm = 0x490
movq -0x8(%rbp), %rsi
addq $0x498, %rsi            # imm = 0x498
callq 0x48300
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4a0, %rdi            # imm = 0x4A0
movq -0x8(%rbp), %rsi
addq $0x4a8, %rsi            # imm = 0x4A8
movq -0x10(%rbp), %rdx
callq 0x14590
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x3c0(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x10(%rdx), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x12c61
movq -0x8(%rbp), %rax
movq 0x3b8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x146a0
cmpl $0x0, %eax
je 0x12c51
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14720
jmp 0x12c53
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x12bf2
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: coalesce
static void
coalesce(Isel *s)
{
	Insn *m;
	regid u, v, tmp;

	m = lpop(&s->wlmove, &s->nwlmove);
	bsdel(s->wlmoveset, m->uid);
	u = getalias(s, m->args[0]->reg.id);
	v = getalias(s, m->args[1]->reg.id);

	if (bshas(s->prepainted, v)) {
		tmp = u;
		u = v;
		v = tmp;
	}

	if (u == v) {
		lappend(&s->mcoalesced, &s->nmcoalesced, m);
		wladd(s, u);
		wladd(s, v);
	} else if (constrained(s, u, v)) {
		lappend(&s->mconstrained, &s->nmconstrained, m);
		wladd(s, u);
		wladd(s, v);
	} else if (combinable(s, u, v)) {
		lappend(&s->mcoalesced, &s->nmcoalesced, m);
		combine(s, u, v);
		wladd(s, u);
	} else {
		lappend(&s->mactive, &s->nmactive, m);
		bsput(s->mactiveset, m->uid);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x460, %rdi            # imm = 0x460
movq -0x8(%rbp), %rsi
addq $0x468, %rsi            # imm = 0x468
callq 0x48300
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x458(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x48af0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x112a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x112a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x4c0(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
je 0x12d15
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x12d5d
movq -0x8(%rbp), %rdi
addq $0x410, %rdi            # imm = 0x410
movq -0x8(%rbp), %rsi
addq $0x418, %rsi            # imm = 0x418
movq -0x10(%rbp), %rdx
callq 0x48290
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14ce0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14ce0
jmp 0x12e40
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x14e30
cmpl $0x0, %eax
je 0x12db1
movq -0x8(%rbp), %rdi
addq $0x420, %rdi            # imm = 0x420
movq -0x8(%rbp), %rsi
addq $0x428, %rsi            # imm = 0x428
movq -0x10(%rbp), %rdx
callq 0x48290
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14ce0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14ce0
jmp 0x12e3e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x14f30
cmpl $0x0, %eax
je 0x12e06
movq -0x8(%rbp), %rdi
addq $0x410, %rdi            # imm = 0x410
movq -0x8(%rbp), %rsi
addq $0x418, %rsi            # imm = 0x418
movq -0x10(%rbp), %rdx
callq 0x48290
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x15050
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14ce0
jmp 0x12e3c
movq -0x8(%rbp), %rdi
addq $0x448, %rdi            # imm = 0x448
movq -0x8(%rbp), %rsi
addq $0x450, %rsi            # imm = 0x450
movq -0x10(%rbp), %rdx
callq 0x48290
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x48a50
jmp 0x12e3e
jmp 0x12e40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)