LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/region.c
// Function: copyregion
int copyregion (int f, int n)
{
  LINE *linep;
  REGION region;
  int loffs, s;

  if ((s = getregion (&region)) != TRUE)
    return (s);
  if ((lastflag & CFKILL) == 0) /* Kill type command */
    kdelete ();
  thisflag |= CFKILL;
  linep = region.r_linep;	/* Current line */
  loffs = region.r_offset;	/* Current offset */
  while (region.r_size--)
    {
      if (loffs == llength (linep))
	{			/* End of line */
	  if ((s = kinsert ('\n')) != TRUE)
	    return (s);
	  linep = lforw (linep);
	  loffs = 0;
	}
      else
	{			/* Middle of line */
	  if ((s = kinsert (lgetc (linep, loffs))) != TRUE)
	    return (s);
	  ++loffs;
	}
    }
  return (TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rdi
callq 0x6405
testl %eax, %eax
je 0x65a7
leaq 0x7517(%rip), %rax      # 0xda40
testb $0x2, (%rax)
jne 0x6535
xorl %eax, %eax
callq 0x571f
leaq 0x752c(%rip), %rax      # 0xda68
orb $0x2, (%rax)
movq (%rsp), %r14
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %r15
movq %r15, %rax
movl $0x1, %ebx
subq $0x1, %rax
movq %rax, 0x10(%rsp)
jb 0x65ad
addq $-0x2, %r15
cmpl 0x14(%r14), %r12d
jne 0x6581
movl $0xa, %edi
callq 0x54cb
cmpl $0x1, %eax
jne 0x65ab
movq (%r14), %r14
xorl %r12d, %r12d
jmp 0x6597
movslq %r12d, %rax
movzbl 0x18(%r14,%rax), %edi
callq 0x54cb
cmpl $0x1, %eax
jne 0x65ab
incl %r12d
movq %r15, 0x10(%rsp)
decq %r15
cmpq $-0x2, %r15
jne 0x6564
jmp 0x65ad
xorl %ebx, %ebx
jmp 0x65ad
movl %eax, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/strlcpy.c
// Function: strlcpy
size_t
strlcpy(char *dst, const char *src, size_t siz)
{
	char *d = dst;
	const char *s = src;
	size_t n = siz;

	/* Copy as many bytes as will fit */
	if (n != 0) {
		while (--n != 0) {
			if ((*d++ = *s++) == '\0')
				break;
		}
	}

	/* Not enough room in dst, add NUL and traverse rest of src */
	if (n == 0) {
		if (siz != 0)
			*d = '\0';		/* NUL-terminate dst */
		while (*s++)
			;
	}

	return(s - src - 1);	/* count does not include NUL */
}

// Assembly:
movq %rsi, %rax
movq %rsi, %rcx
testq %rdx, %rdx
je 0x65f0
decq %rdx
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x65e9
movb (%rax,%rcx), %sil
movb %sil, (%rdi,%rcx)
incq %rcx
testb %sil, %sil
jne 0x65cc
addq %rax, %rcx
movq %rcx, %rdx
jmp 0x65fc
movb $0x0, (%rdi,%rcx)
addq %rax, %rcx
leaq 0x1(%rcx), %rdx
cmpb $0x0, (%rcx)
movq %rdx, %rcx
jne 0x65f0
notq %rax
addq %rdx, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/search.c
// Function: readpattern
int
readpattern(char *prompt)
{
	char	tpat[NPAT];
	char 	nprompt[NPAT + 20]; // XXX
	int	retval;
	int r;

	if (pat[0] == '\0')
	  r = mlreplyt(prompt, tpat, NPAT, '\n'); /* Read pattern */
	else {
	  sprintf(nprompt, "%s: (default %s) ", prompt, pat);
	  r = mlreplyt(nprompt, tpat, NPAT, '\n'); /* Read pattern */
	}

	if (r == ABORT) {
		retval = ABORT;
		/* specified */
	} else if (r == TRUE) {
		(void)strlcpy(pat, tpat, NPAT);
		retval = TRUE;
		/*  cr but old one */
	} else if (r == FALSE && pat[0] != '\0') {
		retval = TRUE;
	} else
		retval = FALSE;
	return (retval);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rdx
leaq 0x686d(%rip), %r14      # 0xda80
cmpb $0x0, (%r14)
je 0x723e
leaq 0x234f(%rip), %rsi      # 0x956f
leaq 0x6859(%rip), %rcx      # 0xda80
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2250
movq %rsp, %rsi
movq %rbx, %rdi
jmp 0x7244
movq %rsp, %rsi
movq %rdx, %rdi
movl $0x50, %edx
movl $0xa, %ecx
callq 0x437d
testl %eax, %eax
je 0x727c
cmpl $0x2, %eax
je 0x7289
cmpl $0x1, %eax
jne 0x7287
leaq 0x6818(%rip), %rdi      # 0xda80
movq %rsp, %rsi
movl $0x50, %edx
callq 0x65bc
movl $0x1, %eax
jmp 0x7289
movl $0x1, %eax
cmpb $0x0, (%r14)
jne 0x7289
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/search.c
// Function: forwsrch
int
forwsrch(void)
{
	LINE	*clp, *tlp;
	int	 cbo, tbo, c, i, xcase = 0;
	char	*pp;
	int	 nline;

	clp = curwp->w_dotp;
	cbo = curwp->w_doto;
	for (i = 0; pat[i]; i++)
		if (ISUPPER(CHARMASK(pat[i])))
			xcase = 1;
	for (;;) {
		if (cbo == llength(clp)) {
			if ((clp = lforw(clp)) == curbp->b_linep)
				break;
			nline++;
			cbo = 0;
			c = CCHR('J');
		} else
			c = lgetc(clp, cbo++);
		if (eq(c, pat[0], xcase) != FALSE) {
			tlp = clp;
			tbo = cbo;
			pp = &pat[1];
			while (*pp != 0) {
				if (tbo == llength(tlp)) {
					tlp = lforw(tlp);
					if (tlp == curbp->b_linep)
						goto fail;
					tbo = 0;
					c = CCHR('J');
					if (eq(c, *pp++, xcase) == FALSE)
						goto fail;
					nline++;
				} else {
					c = lgetc(tlp, tbo++);
					if (eq(c, *pp++, xcase) == FALSE)
						goto fail;
				}
			}
			curwp->w_dotp = tlp;
			curwp->w_doto = tbo;
			curwp->w_flag |= WFMOVE;
			return (TRUE);
		}
fail:		;
	}
	return (FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x6653(%rip), %rax      # 0xda48
movq (%rax), %rcx
leaq 0x6681(%rip), %rdx      # 0xda80
movzbl (%rdx), %esi
testl %esi, %esi
je 0x7434
leaq 0x1(%rdx), %rdi
xorl %eax, %eax
movl $0x1, %r8d
movl %esi, %r9d
addb $-0x41, %r9b
cmpb $0x1a, %r9b
cmovbl %r8d, %eax
movb (%rdi), %r9b
incq %rdi
testb %r9b, %r9b
jne 0x7415
testl %eax, %eax
sete %dil
jmp 0x7437
movb $0x1, %dil
movq 0x18(%rcx), %r8
movl 0x20(%rcx), %eax
leaq 0x65f3(%rip), %r9       # 0xda38
movq (%r9), %r9
leal -0x41(%rsi), %r10d
movl %r10d, -0x4(%rsp)
movl %esi, %r11d
orl $0x20, %r11d
leaq 0x2(%rdx), %rbx
cmpl 0x14(%r8), %eax
jne 0x7478
movq (%r8), %r8
movl $0xa, %r14d
xorl %eax, %eax
cmpq 0x28(%r9), %r8
jne 0x7483
jmp 0x756e
movslq %eax, %r10
incl %eax
movzbl 0x18(%r8,%r10), %r14d
cmpl %esi, %r14d
jne 0x7517
movb 0x1(%rdx), %r13b
testb %r13b, %r13b
je 0x7555
movq %rbx, %r15
movl %eax, %ebp
movq %r8, %r14
movzbl %r13b, %r12d
cmpl 0x14(%r14), %ebp
jne 0x74c1
movq (%r14), %r14
movq 0x28(%r9), %r10
xorl %ebp, %ebp
cmpl $0xa, %r12d
jne 0x745c
cmpq %r10, %r14
jne 0x750a
jmp 0x745c
movslq %ebp, %r10
incl %ebp
movzbl 0x18(%r14,%r10), %r10d
cmpb %r10b, %r13b
je 0x750a
testb %dil, %dil
je 0x745c
leal -0x41(%r10), %r13d
cmpl $0x19, %r13d
ja 0x74ee
orl $0x20, %r10d
cmpl %r12d, %r10d
je 0x750a
jmp 0x745c
leal -0x41(%r12), %r13d
orl $0x20, %r12d
cmpl $0x19, %r13d
ja 0x745c
cmpl %r10d, %r12d
jne 0x745c
movb (%r15), %r13b
incq %r15
testb %r13b, %r13b
jne 0x74a1
jmp 0x755a
testb %dil, %dil
je 0x745c
leal -0x41(%r14), %r10d
cmpl $0x19, %r10d
ja 0x753c
orl $0x20, %r14d
cmpl %esi, %r14d
jne 0x745c
jmp 0x748c
cmpl $0x19, -0x4(%rsp)
ja 0x745c
cmpl %r11d, %r14d
je 0x748c
jmp 0x745c
movq %r8, %r14
movl %eax, %ebp
movq %r14, 0x18(%rcx)
movslq %ebp, %rax
movq %rax, 0x20(%rcx)
orb $0x2, 0x3b(%rcx)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/search.c
// Function: backsrch
int
backsrch(void)
{
	LINE	*clp, *tlp;
	int	 cbo, tbo, c, i, xcase = 0;
	char	*epp, *pp;
	int	 nline;

	for (epp = &pat[0]; epp[1] != 0; ++epp);
	clp = curwp->w_dotp;
	cbo = curwp->w_doto;
	for (i = 0; pat[i]; i++)
		if (ISUPPER(CHARMASK(pat[i])))
			xcase = 1;
	for (;;) {
		if (cbo == 0) {
			clp = lback(clp);
			if (clp == curbp->b_linep)
				return (FALSE);
			nline--;
			cbo = llength(clp) + 1;
		}
		if (--cbo == llength(clp))
			c = CCHR('J');
		else
			c = lgetc(clp, cbo);
		if (eq(c, *epp, xcase) != FALSE) {
			tlp = clp;
			tbo = cbo;
			pp = epp;
			while (pp != &pat[0]) {
				if (tbo == 0) {
					tlp = lback(tlp);
					if (tlp == curbp->b_linep)
						goto fail;
					nline--;
					tbo = llength(tlp) + 1;
				}
				if (--tbo == llength(tlp))
					c = CCHR('J');
				else
					c = lgetc(tlp, tbo);
				if (eq(c, *--pp, xcase) == FALSE)
					goto fail;
			}
			curwp->w_dotp = tlp;
			curwp->w_doto = tbo;
			curwp->w_flag |= WFMOVE;
			return (TRUE);
		}
fail:		;
	}
	/* NOTREACHED */
}

// Assembly:
movq $-0x1, %rdx
leaq 0x64f9(%rip), %rax      # 0xda80
cmpb $0x0, 0x2(%rax,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x7587
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x64a7(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
movb (%rax), %sil
testb %sil, %sil
je 0x75d7
leaq 0x1(%rax), %r8
xorl %edi, %edi
movl $0x1, %r9d
addb $-0x41, %sil
cmpb $0x1a, %sil
cmovbl %r9d, %edi
movb (%r8), %sil
incq %r8
testb %sil, %sil
jne 0x75b8
testl %edi, %edi
sete %sil
jmp 0x75da
movb $0x1, %sil
movq 0x18(%rcx), %rdi
movl 0x20(%rcx), %r9d
leaq 0x644f(%rip), %r8       # 0xda38
movq (%r8), %r8
testl %r9d, %r9d
je 0x760e
movl 0x14(%rdi), %r10d
movslq %r9d, %r9
decq %r9
movl $0xa, %r11d
cmpl %r10d, %r9d
je 0x7629
movzbl 0x18(%rdi,%r9), %r11d
jmp 0x7629
movq 0x8(%rdi), %rdi
cmpq 0x28(%r8), %rdi
je 0x771e
movl 0x14(%rdi), %r9d
movl $0xa, %r11d
movl %r9d, %r10d
movzbl (%rax,%rdx), %ebx
cmpl %ebx, %r11d
jne 0x76c6
testq %rdx, %rdx
je 0x76fb
movq %rdx, %rbx
movl %r9d, %r14d
movq %rdi, %r11
testl %r14d, %r14d
je 0x7666
movslq %r14d, %r14
decq %r14
movl $0xa, %r15d
cmpl %r10d, %r14d
je 0x7681
movzbl 0x18(%r11,%r14), %r15d
jmp 0x7681
movq 0x8(%r11), %r11
cmpq 0x28(%r8), %r11
je 0x75ec
movl 0x14(%r11), %r14d
movl $0xa, %r15d
movl %r14d, %r10d
movzbl -0x1(%rax,%rbx), %r12d
cmpl %r12d, %r15d
je 0x76bf
testb %sil, %sil
je 0x75ec
leal -0x41(%r15), %ebp
cmpl $0x19, %ebp
ja 0x76a4
orl $0x20, %r15d
jmp 0x76b6
leal -0x41(%r12), %ebp
orl $0x20, %r12d
cmpl $0x19, %ebp
ja 0x75ec
cmpl %r12d, %r15d
jne 0x75ec
decq %rbx
jne 0x7648
jmp 0x7701
testb %sil, %sil
je 0x75ec
leal -0x41(%r11), %ebp
cmpl $0x19, %ebp
ja 0x76de
orl $0x20, %r11d
jmp 0x76ed
leal -0x41(%rbx), %ebp
cmpl $0x19, %ebp
ja 0x75ec
orl $0x20, %ebx
cmpl %ebx, %r11d
je 0x7636
jmp 0x75ec
movq %rdi, %r11
movl %r9d, %r14d
movq %r11, 0x18(%rcx)
movslq %r14d, %rax
movq %rax, 0x20(%rcx)
orb $0x2, 0x3b(%rcx)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x7715
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/search.c
// Function: is_prompt
static void
is_prompt(int dir, int flag, int success)
{
	if (dir == SRCH_FORW) {
		if (success != FALSE)
			is_dspl("I-search", flag);
		else
			is_dspl("Failing I-search", flag);
	} else if (dir == SRCH_BACK) {
		if (success != FALSE)
			is_dspl("I-search backward", flag);
		else
			is_dspl("Failing I-search backward", flag);
	} else
		mlwrite("Broken call to is_prompt");
}

// Assembly:
cmpl $-0x2, %edi
je 0x773c
cmpl $-0x1, %edi
jne 0x774c
testl %edx, %edx
je 0x775a
leaq 0x1e7f(%rip), %rdi      # 0x95b6
jmp 0x7888
testl %edx, %edx
je 0x7766
leaq 0x1e80(%rip), %rdi      # 0x95c7
jmp 0x7888
leaq 0x1e86(%rip), %rdi      # 0x95d9
xorl %eax, %eax
jmp 0x4246
leaq 0x1e4d(%rip), %rdi      # 0x95ae
jmp 0x7888
leaq 0x1e52(%rip), %rdi      # 0x95bf
jmp 0x7888
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/search.c
// Function: is_undo
static void
is_undo(int *pptr, int *dir)
{
	int	redo = FALSE;

	switch (cmds[cip].s_code) {
	case SRCH_BEGIN:
	case SRCH_NOPR:
		*pptr = -1;
		break;
	case SRCH_MARK:
		break;
	case SRCH_FORW:
		*dir = SRCH_BACK;
		redo = TRUE;
		break;
	case SRCH_BACK:
		*dir = SRCH_FORW;
		redo = TRUE;
		break;
	case SRCH_ACCM:
	default:
		*pptr -= 1;
		if (*pptr < 0)
			*pptr = 0;
		pat[*pptr] = '\0';
		break;
	}
	is_pop();
	if (redo)
		is_undo(pptr, dir);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x63c9(%rip), %r15      # 0xdb50
leaq 0x1d1a(%rip), %r12      # 0x94a8
movslq 0x63ab(%rip), %rax      # 0xdb40
leaq (%rax,%rax,2), %rax
movl (%r15,%rax,8), %ecx
addl $0x5, %ecx
cmpl $0x5, %ecx
ja 0x77ca
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%r14)
callq 0x78b8
jmp 0x778e
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
jmp 0x77e6
movl (%rbx), %eax
leal -0x1(%rax), %ecx
xorl %edx, %edx
testl %eax, %eax
cmovgl %ecx, %edx
movl %edx, (%rbx)
movslq %edx, %rax
leaq 0x629e(%rip), %rcx      # 0xda80
movb $0x0, (%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x78b8
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/search.c
// Function: is_find
static int
is_find(int dir)
{
  int	 plen, odoto;
	LINE	*odotp;

	odoto = curwp->w_doto;
	odotp = curwp->w_dotp;
	plen = strlen(pat);
	if (plen != 0) {
		if (dir == SRCH_FORW) {
			(void)backchar(FFARG | FFRAND, plen);
			if (forwsrch() == FALSE) {
				curwp->w_doto = odoto;
				curwp->w_dotp = odotp;
				return (FALSE);
			}
			return (TRUE);
		}
		if (dir == SRCH_BACK) {
			(void)forwchar(FFARG | FFRAND, plen);
			if (backsrch() == FALSE) {
				curwp->w_doto = odoto;
				curwp->w_dotp = odotp;
				return (FALSE);
			}
			return (TRUE);
		}
		mlwrite("bad call to is_find");
		return (FALSE);
	}
	return (FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
leaq 0x6241(%rip), %r15      # 0xda48
movq (%r15), %rax
movq 0x18(%rax), %r14
movq 0x20(%rax), %r12
leaq 0x6267(%rip), %rdi      # 0xda80
callq 0x20d0
xorl %ebx, %ebx
testl %eax, %eax
je 0x787d
cmpl $-0x2, %ebp
je 0x7841
cmpl $-0x1, %ebp
jne 0x786d
movl $0xf, %edi
movl %eax, %esi
callq 0x2412
callq 0x73e4
jmp 0x7852
movl $0xf, %edi
movl %eax, %esi
callq 0x2470
callq 0x7579
movl $0x1, %ebx
testl %eax, %eax
jne 0x787d
movslq %r12d, %rax
movq (%r15), %rcx
movq %rax, 0x20(%rcx)
movq %r14, 0x18(%rcx)
xorl %ebx, %ebx
jmp 0x787d
leaq 0x1d8a(%rip), %rdi      # 0x95fe
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4246
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/search.c
// Function: is_pop
static void
is_pop(void)
{
	if (cmds[cip].s_code != SRCH_NOPR) {
		curwp->w_doto = cmds[cip].s_doto;
		curwp->w_dotp = cmds[cip].s_dotp;
		curwp->w_flag |= WFMOVE;
		cmds[cip].s_code = SRCH_NOPR;
	}
	if (--cip <= 0)
		cip = NSRCH - 1;
}

// Assembly:
movslq 0x6281(%rip), %rax      # 0xdb40
leaq (%rax,%rax,2), %rcx
leaq 0x6286(%rip), %rdx      # 0xdb50
cmpl $-0x3, (%rdx,%rcx,8)
je 0x78f8
leaq (%rdx,%rcx,8), %rcx
movslq 0x10(%rcx), %rdx
leaq 0x6169(%rip), %rsi      # 0xda48
movq (%rsi), %rsi
movq %rdx, 0x20(%rsi)
movq 0x8(%rcx), %rdx
movq %rdx, 0x18(%rsi)
orb $0x2, 0x3b(%rsi)
movl $0xfffffffd, (%rcx)     # imm = 0xFFFFFFFD
leal -0x1(%rax), %ecx
cmpl $0x2, %eax
movl $0x7f, %eax
cmovgel %ecx, %eax
movl %eax, 0x6234(%rip)      # 0xdb40
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/tcap.c
// Function: getwinsize
void getwinsize ()
{
  int cols, rows;
#ifndef FORCE_COLS
  struct winsize ws;

  ioctl (0, TIOCGWINSZ, &ws);
  cols = ws.ws_col;
  rows = ws.ws_row;
#else
  cols = FORCE_COLS;
  rows = FORCE_ROWS;
#endif
  if ((cols < 10) || (rows < 3))
    {
      puts ("Unbelievable screen size\n");
      exit (1);
    }
  term.t_ncol = cols;
  term.t_nrow = rows-1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movl $0x5413, %esi           # imm = 0x5413
xorl %edi, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2140
movzwl 0x2(%rbx), %eax
cmpl $0xa, %eax
jb 0x797e
movzwl 0x8(%rsp), %ecx
cmpw $0x2, %cx
jbe 0x797e
movzwl %cx, %ecx
movl %eax, 0x5efc(%rip)      # 0xd86c
decl %ecx
movl %ecx, 0x5ef0(%rip)      # 0xd868
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1c8d(%rip), %rdi      # 0x9612
callq 0x2080
movl $0x1, %edi
callq 0x2260
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/tcap.c
// Function: tcapopen
void tcapopen ()
{
  char tcbuf[1024], err_str[72];
  char *p, *tv_stype;

  if ((tv_stype = getenv ("TERM")) == NULL)
    {
      puts ("Environment variable TERM not defined\n");
      exit (1);
    }
  if ((tgetent (tcbuf, tv_stype)) != 1)
    {
      snprintf (err_str, 72, "Unknown terminal type %s\n", tv_stype);
      puts (err_str);
      exit (1);
    }
  p = tcapbuf;
  CL = tgetstr ("cl", &p);
  CM = tgetstr ("cm", &p);
  CE = tgetstr ("ce", &p);
  SE = tgetstr ("se", &p);
  SO = tgetstr ("so", &p);

  if (CE == NULL)
    eolexist = FALSE;
  if (SO != NULL && SE != NULL)
    revexist = TRUE;
  if (CL == NULL || CM == NULL)
    {
      puts ("Insufficient termcap! (needs cl & cm abilities)\n");
      exit (1);
    }
  if (p >= &tcapbuf[TCAPSLEN])	/* XXX */
    {
      puts ("Terminal description too big!\n");
      exit (1);
    }
  ttopen ();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x458, %rsp            # imm = 0x458
leaq 0x1c87(%rip), %rdi      # 0x962c
callq 0x2030
testq %rax, %rax
je 0x7ab9
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2270
cmpl $0x1, %eax
jne 0x7ac2
leaq 0x6d7b(%rip), %rax      # 0xe750
movq %rsp, %rbx
movq %rax, (%rbx)
leaq 0x1c90(%rip), %rdi      # 0x9672
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21d0
movq %rax, 0x6d9d(%rip)      # 0xe790
leaq 0x1c7b(%rip), %rdi      # 0x9675
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21d0
movq %rax, 0x6d8d(%rip)      # 0xe798
leaq 0x1c66(%rip), %rdi      # 0x9678
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21d0
movq %rax, 0x6d7d(%rip)      # 0xe7a0
leaq 0x1c51(%rip), %rdi      # 0x967b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21d0
movq %rax, 0x6d6d(%rip)      # 0xe7a8
leaq 0x1c3c(%rip), %rdi      # 0x967e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21d0
movq %rax, 0x6d5d(%rip)      # 0xe7b0
cmpq $0x0, 0x6d45(%rip)      # 0xe7a0
jne 0x7a6a
leaq 0x590c(%rip), %rcx      # 0xd370
movl $0x0, (%rcx)
testq %rax, %rax
je 0x7a86
cmpq $0x0, 0x6d31(%rip)      # 0xe7a8
je 0x7a86
leaq 0x5fb0(%rip), %rax      # 0xda30
movl $0x1, (%rax)
cmpq $0x0, 0x6d02(%rip)      # 0xe790
je 0x7ae3
cmpq $0x0, 0x6d00(%rip)      # 0xe798
je 0x7ae3
leaq 0x6cef(%rip), %rax      # 0xe790
cmpq %rax, (%rsp)
jae 0x7aec
xorl %eax, %eax
callq 0x7b7c
addq $0x458, %rsp            # imm = 0x458
popq %rbx
popq %r14
retq
leaq 0x1b71(%rip), %rdi      # 0x9631
jmp 0x7af3
leaq 0x1b8f(%rip), %rdx      # 0x9658
movq %rsp, %r14
movl $0x48, %esi
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2110
movq %r14, %rdi
jmp 0x7af3
leaq 0x1b97(%rip), %rdi      # 0x9681
jmp 0x7af3
leaq 0x1bbf(%rip), %rdi      # 0x96b2
callq 0x2080
movl $0x1, %edi
callq 0x2260
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/termio.c
// Function: ttopen
void ttopen ()
{
  /* save terminal flags */
  if ((tcgetattr(0, &ostate) < 0) || (tcgetattr(0, &nstate) < 0))
    {
      puts ("Can't read terminal capabilites\n");
      exit (1);
    }
  cfmakeraw(&nstate);		/* set raw mode */
  nstate.c_cc[VMIN] = 1;
  nstate.c_cc[VTIME] = 0;	/* block indefinitely for a single char */
  if (tcsetattr(0, TCSADRAIN, &nstate) < 0)
    {
      puts ("Can't set terminal mode\n");
      exit (1);
    }
  /* provide a smaller terminal output buffer so that the type ahead
   * detection works better (more often) */
  setbuffer (stdout, &tobuf[0], TBUFSIZ);
  signal (SIGTSTP, SIG_DFL);
}

// Assembly:
pushq %rbx
leaq 0x6c3c(%rip), %rsi      # 0xe7c0
xorl %edi, %edi
callq 0x2210
testl %eax, %eax
js 0x7bf4
leaq 0x6c66(%rip), %rsi      # 0xe7fc
xorl %edi, %edi
callq 0x2210
testl %eax, %eax
js 0x7bf4
leaq 0x6c54(%rip), %rbx      # 0xe7fc
movq %rbx, %rdi
callq 0x21f0
movw $0x100, 0x6c59(%rip)    # imm = 0x100
xorl %edi, %edi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x2220
testl %eax, %eax
js 0x7bfd
movq 0x53fd(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
leaq 0x6c63(%rip), %rsi      # 0xe840
movl $0x80, %edx
callq 0x20e0
movl $0x14, %edi
xorl %esi, %esi
popq %rbx
jmp 0x2180
leaq 0x1ad6(%rip), %rdi      # 0x96d1
jmp 0x7c04
leaq 0x1aee(%rip), %rdi      # 0x96f2
callq 0x2080
movl $0x1, %edi
callq 0x2260
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/termio.c
// Function: ttclose
void ttclose ()
{
  ttflush ();
  if (tcsetattr(0, TCSADRAIN, &ostate) < 0)
    {
      puts ("Can't restore terminal flags");
      exit (1);
    }
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x20a0
movq 0x53ae(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
callq 0x21b0
leaq 0x6b8f(%rip), %rdx      # 0xe7c0
xorl %edi, %edi
movl $0x1, %esi
callq 0x2220
testl %eax, %eax
js 0x7c43
popq %rax
retq
leaq 0x1ac1(%rip), %rdi      # 0x970b
callq 0x2080
movl $0x1, %edi
callq 0x2260
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/window.c
// Function: refresh
int refresh (int f, int n)
{
  if (n >= 0)
    n++;			/* adjust to screen row */
  if (f == FALSE)
    {
      sgarbf = TRUE;
      n = 0;			/* Center dot */
    }
  curwp->w_force = n;
  curwp->w_flag |= WFFORCE;
  return (TRUE);
}

// Assembly:
testl %edi, %edi
je 0x7ccf
movl %esi, %eax
notl %eax
shrl $0x1f, %eax
addl %esi, %eax
jmp 0x7cde
leaq 0x569e(%rip), %rax      # 0xd374
movl $0x1, (%rax)
xorl %eax, %eax
leaq 0x5d63(%rip), %rcx      # 0xda48
movq (%rcx), %rcx
movb %al, 0x3a(%rcx)
orb $0x1, 0x3b(%rcx)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/window.c
// Function: nextwind
int nextwind (int f, int n)
{
  WINDOW *wp;

  if ((wp = curwp->w_wndp) == NULL)
    wp = wheadp;

  curwp = wp;
  curbp = wp->w_bufp;
  upmode ();
  return (TRUE);
}

// Assembly:
leaq 0x5d4c(%rip), %rax      # 0xda48
movq (%rax), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x7d11
leaq 0x5d52(%rip), %rcx      # 0xda60
movq (%rcx), %rcx
pushq %rax
movq %rcx, (%rax)
movq 0x8(%rcx), %rax
leaq 0x5d18(%rip), %rcx      # 0xda38
movq %rax, (%rcx)
xorl %eax, %eax
callq 0x41a8
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/window.c
// Function: prevwind
int prevwind (int f, int n)
{
  WINDOW *wp1, *wp2;

  wp1 = wheadp;
  wp2 = curwp;

  if (wp1 == wp2)
    wp2 = NULL;

  while (wp1->w_wndp != wp2)
    wp1 = wp1->w_wndp;

  curwp = wp1;
  curbp = wp1->w_bufp;
  upmode ();
  return (TRUE);
}

// Assembly:
pushq %rax
leaq 0x5d27(%rip), %rax      # 0xda60
movq (%rax), %rcx
leaq 0x5d05(%rip), %rax      # 0xda48
movq (%rax), %rsi
xorl %edx, %edx
cmpq %rsi, %rcx
cmovneq %rsi, %rdx
movq %rcx, %rsi
movq (%rcx), %rcx
cmpq %rdx, %rcx
jne 0x7d4f
movq %rsi, (%rax)
movq 0x8(%rsi), %rax
leaq 0x5cd0(%rip), %rcx      # 0xda38
movq %rax, (%rcx)
xorl %eax, %eax
callq 0x41a8
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/window.c
// Function: onlywind
int onlywind (int f, int n)
{
  WINDOW *wp;
  LINE *lp;
  int i;

  while (wheadp != curwp)
    {
      wp = wheadp;
      wheadp = wp->w_wndp;
      if (--wp->w_bufp->b_nwnd == 0)
	{
	  wp->w_bufp->b_dotp = wp->w_dotp;
	  wp->w_bufp->b_doto = wp->w_doto;
	  wp->w_bufp->b_markp = wp->w_markp;
	  wp->w_bufp->b_marko = wp->w_marko;
	}
      free ((char *) wp);
    }
  while (curwp->w_wndp != NULL)
    {
      wp = curwp->w_wndp;
      curwp->w_wndp = wp->w_wndp;
      if (--wp->w_bufp->b_nwnd == 0)
	{
	  wp->w_bufp->b_dotp = wp->w_dotp;
	  wp->w_bufp->b_doto = wp->w_doto;
	  wp->w_bufp->b_markp = wp->w_markp;
	  wp->w_bufp->b_marko = wp->w_marko;
	}
      free ((char *) wp);
    }
  lp = curwp->w_linep;
  i = curwp->w_toprow;
  while (i != 0 && lback (lp) != curbp->b_linep)
    {
      --i;
      lp = lback (lp);
    }
  curwp->w_toprow = 0;
  curwp->w_ntrows = term.t_nrow - 1;
  curwp->w_linep = lp;
  curwp->w_flag |= WFMODE | WFHARD;
  return (TRUE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5cdc(%rip), %r14      # 0xda60
movq (%r14), %rdi
leaq 0x5cba(%rip), %rbx      # 0xda48
movq (%rbx), %rax
cmpq %rax, %rdi
je 0x7e06
movq (%rdi), %rax
movq %rax, (%r14)
movq 0x8(%rdi), %rax
decb 0x31(%rax)
jne 0x7dc5
movq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rax)
movq 0x28(%rdi), %rcx
movq %rcx, 0x18(%rax)
movq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rax)
callq 0x2040
movq (%r14), %rdi
jmp 0x7d8e
movq (%rdi), %rcx
movq %rcx, (%rax)
movq 0x8(%rdi), %rax
decb 0x31(%rax)
jne 0x7dfe
movq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rax)
movq 0x28(%rdi), %rcx
movq %rcx, 0x18(%rax)
movq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rax)
callq 0x2040
movq (%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
jne 0x7dcf
movq 0x10(%rax), %rcx
movsbl 0x38(%rax), %edx
testl %edx, %edx
je 0x7e3d
leaq 0x5c17(%rip), %rsi      # 0xda38
movq (%rsi), %rsi
movq 0x28(%rsi), %rsi
movq %rcx, %rdi
movq 0x8(%rcx), %rcx
cmpq %rsi, %rcx
je 0x7e40
movq %rcx, %rdi
decl %edx
jne 0x7e28
jmp 0x7e40
movq %rcx, %rdi
movb $0x0, 0x38(%rax)
leaq 0x5a1d(%rip), %rcx      # 0xd868
movb (%rcx), %cl
decb %cl
movb %cl, 0x39(%rax)
movq %rdi, 0x10(%rax)
orb $0x18, 0x3b(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hughbarney[P]pEmacs/window.c
// Function: wpopup
WINDOW* wpopup ()
{
  WINDOW *wp;

  if (wheadp->w_wndp == NULL	/* Only 1 window */
      && splitwind (FALSE, 0) == FALSE)	/* and it won't split */
    return (NULL);
  wp = wheadp;			/* Find window to use */
  while (wp != NULL && wp == curwp)
    wp = wp->w_wndp;
  return (wp);
}

// Assembly:
pushq %rbx
leaq 0x5aa2(%rip), %rbx      # 0xda60
movq (%rbx), %rax
cmpq $0x0, (%rax)
jne 0x7fd0
callq 0x7e67
testl %eax, %eax
je 0x7fe9
leaq 0x5a71(%rip), %rax      # 0xda48
movq (%rax), %rax
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x7feb
cmpq %rax, %rbx
je 0x7fda
jmp 0x7feb
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/sparse.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	// by default ignore -o <file>
	do_output = 0;

	// Expand, linearize and show it.
	check_symbols(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		check_symbols(sparse(file));
	} END_FOR_EACH_PTR(file);

	report_stats();
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
leaq 0x51f08(%rip), %rax     # 0x61530
movl $0x0, (%rax)
movq %rbx, %rdx
callq 0x130b6
movq %rax, %rdi
callq 0xf6a3
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xf692
movq %rbx, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xf689
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xf669
testq %rdi, %rdi
je 0xf67a
callq 0x133ee
movq %rax, %rdi
callq 0xf6a3
movzwl (%r14), %eax
incq %r15
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r15
jl 0xf654
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xf649
callq 0x2c29c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/sparse.c
// Function: check_bb_context
static int check_bb_context(struct entrypoint *ep, struct basic_block *bb, int entry, int exit)
{
	if (!bb)
		return 0;
	if (bb->context == entry)
		return 0;

	/* Now that's not good.. */
	if (bb->context >= 0)
		return imbalance(ep, bb, entry, bb->context, "different lock contexts for basic block");

	bb->context = entry;
	entry += context_increase(bb, entry);
	if (entry < 0)
		return imbalance(ep, bb, entry, exit, "unexpected unlock");

	return check_children(ep, bb, entry, exit);
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0xfb66
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movq %rsi, %r15
movl 0x58(%rsi), %edx
cmpl %r12d, %edx
je 0xfb58
movq %rdi, %r13
testl %edx, %edx
js 0xfb67
leaq 0x31559(%rip), %rdx     # 0x410a1
movq %r13, %rdi
movq %r15, %rsi
callq 0xfd45
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, 0xc(%rsp)
movq %r13, 0x10(%rsp)
movl %r12d, 0x58(%r15)
movq 0x28(%r15), %rbx
testq %rbx, %rbx
je 0xfc0f
movq %rbx, %rbp
xorl %r14d, %r14d
movzwl (%rbp), %eax
testb %al, %al
jle 0xfc00
xorl %r13d, %r13d
movq 0x18(%rbp,%r13,8), %rcx
movzwl %ax, %edx
cmpl $0x100, %edx            # imm = 0x100
jb 0xfba7
testq %rcx, %rcx
je 0xfbf1
cmpq $0x0, 0x8(%rcx)
je 0xfbf1
movl (%rcx), %edx
andl $0x7f, %edx
cmpl $0x4f, %edx
jne 0xfbf1
movl 0x30(%rcx), %edx
cmpl $0x0, 0x34(%rcx)
je 0xfbcf
leal (%r14,%r12), %esi
testl %edx, %edx
je 0xfbd7
cmpl %edx, %esi
jl 0xfbdb
jmp 0xfbf1
addl %r14d, %edx
movl %edx, %r14d
jmp 0xfbf1
testl %esi, %esi
je 0xfbf1
movq 0x10(%rcx), %rdi
leaq 0x31514(%rip), %rsi     # 0x410fa
xorl %eax, %eax
callq 0x12be8
movzwl (%rbp), %eax
incq %r13
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r13
jl 0xfb92
movq 0x10(%rbp), %rbp
cmpq %rbx, %rbp
jne 0xfb87
jmp 0xfc12
xorl %r14d, %r14d
addl %r12d, %r14d
js 0xfc54
movq 0x28(%r15), %rdi
callq 0x238ba
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
movq 0x10(%rsp), %r13
je 0xfb58
movl (%rcx), %ecx
andl $0x7f, %ecx
cmpl $0x2, %ecx
jne 0xfc65
cmpl 0xc(%rsp), %r14d
je 0xfb58
leaq 0x314c1(%rip), %rdx     # 0x41110
jmp 0xfb48
leaq 0x3146e(%rip), %rdx     # 0x410c9
movq 0x10(%rsp), %r13
jmp 0xfb48
movq 0x20(%r15), %rbx
testq %rbx, %rbx
movl 0xc(%rsp), %ebp
je 0xfb58
movq %rbx, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0xfcc1
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rsi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xfc99
testq %rsi, %rsi
je 0xfcb2
movq %r13, %rdi
movl %r14d, %edx
movl %ebp, %ecx
callq 0xfb17
testl %eax, %eax
jne 0xfb53
movzwl (%r15), %eax
incq %r12
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r12
jl 0xfc84
movq 0x10(%r15), %r15
xorl %eax, %eax
cmpq %rbx, %r15
jne 0xfc79
jmp 0xfb58
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/sparse.c
// Function: imbalance
static int imbalance(struct entrypoint *ep, struct basic_block *bb, int entry, int exit, const char *why)
{
	if (Wcontext) {
		struct symbol *sym = ep->name;
		warning(bb->pos, "context imbalance in '%s' - %s", show_ident(sym->ident), why);
	}
	return -1;
}

// Assembly:
leaq 0x51848(%rip), %rax     # 0x61594
cmpl $0x0, (%rax)
je 0xfd85
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rax
movq 0x18(%rax), %rdi
callq 0x2f135
movq (%r14), %rdi
leaq 0x3136a(%rip), %rsi     # 0x410db
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12be8
retq
nop
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch3/eatyguy5.c
// Function: push_state_table
void push_state_table(lua_State *L,
                      int key,
                      int is_end_of_seq) {

  // The state of the Lua stack is given in indented comments in
  // this function to clarify the actions of each function call.

  lua_newtable(L);

    // stack = [.., {}]

  push_keypress(L, key, is_end_of_seq);

    // stack = [.., {}, key]

  lua_setfield(L, -2, "key");

    // stack = [.., {key = key}]

  lua_pushnumber(L, gettime());

    // stack = [.., {key = key}, clock]

  lua_setfield(L, -2, "clock");

    // stack = [.., {key = key, clock = clock}]
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x59ab
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x4948
leaq 0x1c6c7(%rip), %rdx     # 0x21079
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5c16
leaq -0x28(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x41a0
cvtsi2sdq (%r14), %xmm1
cvtsi2sdq 0x8(%r14), %xmm0
mulsd 0x1c628(%rip), %xmm0    # 0x21008
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x5491
leaq 0x1c68a(%rip), %rdx     # 0x2107d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5c16
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch3/eatyguy5.c
// Function: main
int main() {

  start();

  // Create a Lua state and load the module.
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);

  // Set up API functions written in C.
  lua_register(L, "timestamp", timestamp);

  // Set up API functions written in Lua.
  luaL_dofile(L, "util.lua");

  // Load eatyguy5 and run the init() function.
  luaL_dofile(L, "eatyguy5.lua");
  lua_setglobal(L, "eatyguy");
  lua_settop(L, 0);

  lua_getglobal(L, "eatyguy");
  lua_getfield(L, -1, "init");  // -1 means stack top.
  lua_call(L, 0, 0);            // 0, 0 = #args, #retvals

  lua_getglobal(L, "eatyguy");
  while (1) {
    int is_end_of_seq;
    int key = getkey(&is_end_of_seq);
    if (key == ESC_KEY || key == 'q' || key == 'Q') done();

    // Call eatyguy.loop(state).
    lua_getfield(L, -1, "loop");
    // This replaces the previous call to push_keypress().
    push_state_table(L, key, is_end_of_seq);
    lua_call(L, 1, 0);

    sleephires(0.016);  // Sleep for 16ms.
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x48f0
callq 0x14e61
movq %rax, %rbx
movq %rax, %rdi
callq 0x15064
leaq -0x76(%rip), %rsi       # 0x4a0a
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5658
leaq 0x1c5f2(%rip), %rsi     # 0x21083
movq %rbx, %rdi
callq 0x5a9c
leaq 0x1c5ed(%rip), %rsi     # 0x2108d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x145ba
testl %eax, %eax
jne 0x4ac5
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5f7f
leaq 0x1c5ca(%rip), %rsi     # 0x21096
movq %rbx, %rdi
xorl %edx, %edx
callq 0x145ba
testl %eax, %eax
jne 0x4af1
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5f7f
leaq 0x1c5ab(%rip), %r14     # 0x210a3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a9c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4cfd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5727
leaq 0x1c58c(%rip), %rdx     # 0x210ab
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x5845
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5f17
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5727
leaq -0x2c(%rbp), %r14
leaq 0x1d011(%rip), %r15     # 0x21b64
leaq -0x40(%rbp), %r12
movq %r14, %rdi
callq 0x4801
cmpl $0x1b, %eax
je 0x4bc0
movl %eax, %r13d
cmpl $0x71, %eax
je 0x4bc0
cmpl $0x51, %r13d
je 0x4bc0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x5845
movl -0x2c(%rbp), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x497e
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5f17
movq $0x0, -0x40(%rbp)
movq $0xf42400, -0x38(%rbp)  # imm = 0xF42400
movq %r12, %rdi
xorl %esi, %esi
callq 0x4190
jmp 0x4b57
callq 0x4925
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/jacereda[P]fsatrace/src/fsatest.c
// Function: exec
void
exec(char *s)
{
#ifndef _WIN32_WINNT
	int child;
	int rc;
#endif

	char *args[1000];
	args[0] = strtok(s, " ");
	for (int i = 1; i < 1000; i++) {
		args[i] = strtok(NULL, " ");
		if (args[i] == NULL)
			break;
	}

#ifdef _WIN32_WINNT
	spawnv(P_WAIT, args[0], args);
#else
	child = fork();
	if (child == 0)
		execvp(args[0], args);
	waitpid(child, &rc, 0);
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f58, %rsp           # imm = 0x1F58
leaq 0xdb6(%rip), %r14       # 0x2004
movq %r14, %rsi
callq 0x10a0
movq %rax, %rbx
movq %rax, 0x10(%rsp)
movl $0x1, %r15d
xorl %edi, %edi
movq %r14, %rsi
callq 0x10a0
movq %rax, 0x10(%rsp,%r15,8)
testq %rax, %rax
je 0x1288
leaq 0x1(%r15), %rax
cmpq $0x3e7, %r15            # imm = 0x3E7
movq %rax, %r15
jne 0x1264
callq 0x10f0
movl %eax, %ebp
testl %eax, %eax
jne 0x12a0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x10b0
leaq 0xc(%rsp), %rsi
movl %ebp, %edi
xorl %edx, %edx
callq 0x1080
addq $0x1f58, %rsp           # imm = 0x1F58
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jacereda[P]fsatrace/src/fsatest.c
// Function: main
int
main(int argc, const char *argv[])
{
	int trace = 0;
	int exitCode = 0;

	for (int i = 1; i < argc; i++) {
		const char *s = argv[i];
		FILE *	    fp;
		char *	    cmdline;
		int	    seconds;

		switch (s[0]) {
		case 'r':
			if (trace)
				printf("Reading from: %s\n", &s[1]);
			fp = fopen(&s[1], "r");
			while (fgetc(fp) != EOF)
				; // nothing
			fclose(fp);
			break;

		case 'w':
			if (trace)
				printf("Writing to: %s\n", &s[1]);
			fp = fopen(&s[1], "w");
			fputs("Written by fsatest harness\n", fp);
			fclose(fp);
			break;

		case 's':
			seconds = atoi(&s[i]);
			if (trace)
				printf("Sleeping for: %is\n", seconds);
			sleep(seconds);
			break;

		case 'f':
			if (trace)
				printf("Will return a failing exit code\n");
			exitCode = 1;
			break;

		case 'e':
			cmdline = strdup(&s[1]);
			unescape(cmdline);
			if (trace)
				printf("Running command: %s\n", cmdline);
			exec(cmdline);
			free(cmdline);
			break;

		default:
			printf("FAILED: Could not interpret command line: %s\n",
			    s);
			return 1;
		}
	}
	return exitCode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
cmpl $0x2, %edi
jl 0x13ae
movq %rsi, %rbx
movl %edi, %r14d
xorl %ebp, %ebp
movl $0x1, %r15d
leaq 0xd1f(%rip), %r12       # 0x2006
movq (%rbx,%r15,8), %rsi
movzbl (%rsi), %eax
cmpl $0x71, %eax
jle 0x1326
cmpl $0x77, %eax
je 0x1376
cmpl $0x73, %eax
je 0x133a
cmpl $0x72, %eax
jne 0x13bf
incq %rsi
movq %rsi, %rdi
movq %r12, %rsi
callq 0x1090
movq %rax, %r13
movq %r13, %rdi
callq 0x1070
cmpl $-0x1, %eax
jne 0x1317
jmp 0x139a
cmpl $0x65, %eax
je 0x134e
movl $0x1, %ebp
cmpl $0x66, %eax
je 0x13a2
jmp 0x13bf
addq %r15, %rsi
movq %rsi, %rdi
callq 0x10c0
movl %eax, %edi
callq 0x10e0
jmp 0x13a2
incq %rsi
movq %rsi, %rdi
callq 0x10d0
movq %rax, %r13
movq %rax, %rdi
callq 0x11fc
movq %r13, %rdi
callq 0x123a
movq %r13, %rdi
callq 0x1030
jmp 0x13a2
incq %rsi
movq %rsi, %rdi
leaq 0xc85(%rip), %rsi       # 0x2008
callq 0x1090
movq %rax, %r13
leaq 0xc78(%rip), %rdi       # 0x200a
movq %rax, %rsi
callq 0x1060
movq %r13, %rdi
callq 0x1040
incq %r15
cmpq %r14, %r15
jne 0x12e7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc60(%rip), %rdi       # 0x2026
xorl %eax, %eax
callq 0x1050
movl $0x1, %ebp
jmp 0x13ae
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/reseauMain.c
// Function: main
int main()
{
    // lecture et creation d'une instance de Chaines et de Reseau
    FILE* f = NULL;
    f = fopen("00014_burma.cha", "r");
    Chaines *c = lectureChaines(f);
    
    Reseau *R = reconstitueReseauListe(c);
    
    // affichage et l'enregistrement
    afficheChainesSVG(c, "chaineReseau");
    FILE* f2 = NULL;
    f2 = fopen("res.txt", "w");
    ecrireReseau(R, f2);
    
    afficheReseauSVG(R, "reso");

    //fermeture et liberation
    liberation_reseau(R);
    liberer_chaines(c);
    fclose(f);
    fclose(f2);
    
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1120(%rip), %rdi      # 0x3313
leaq 0x1129(%rip), %rsi      # 0x3323
callq 0x10e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x1a20
movq %rax, %r14
movq %rax, %rdi
callq 0x13f4
movq %rax, %r15
leaq 0x1106(%rip), %rsi      # 0x3325
movq %r14, %rdi
callq 0x1c62
leaq 0x1104(%rip), %rdi      # 0x3332
leaq 0xf71(%rip), %rsi       # 0x31a6
callq 0x10e0
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x15aa
leaq 0x10eb(%rip), %rsi      # 0x333a
movq %r15, %rdi
callq 0x179c
movq %r15, %rdi
callq 0x19fe
movq %r14, %rdi
callq 0x1fcb
movq %rbx, %rdi
callq 0x1060
movq %r12, %rdi
callq 0x1060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MuvikLabs[P]runt/runt.c
// Function: runt_init
runt_int runt_init(runt_vm *vm)
{
    vm->status = 0;
    vm->zproc = runt_proc_zero;
    vm->nil = runt_mk_ptr(RUNT_NIL, NULL);

    /* init stack */

    runt_stack_init(vm, &vm->stack);

    /* init dictionary */

    runt_dictionary_init(vm);

    /* record cells being parsed by default */

    runt_set_state(vm, RUNT_MODE_INTERACTIVE, RUNT_OFF);
    runt_set_state(vm, RUNT_MODE_RUNNING, RUNT_ON);

    vm->level = 0;
    vm->pos = 0;

    /* set print output to STDERR by default */
    vm->fp = stderr;

    /* set up plugin handle list */
    runt_list_init(&vm->plugins);

    vm->nwords = 0;
    vm->loader = load_nothing;

    runt_cell_bind(vm, &vm->empty, vm->zproc);
    runt_cell_data(vm, &vm->empty, vm->nil);

    runt_print_set(vm, runt_print_default);

    /* set up destructor list */
    runt_list_init(&vm->dtors);

    /* set up registers */
    runt_registers_init(vm);

    vm->anon = NULL;

    vm->last_cell_called = &vm->empty;

    return RUNT_OK;
}

// Assembly:
leaq 0x130(%rip), %rcx       # 0x147f
movq %rcx, 0x1160(%rdi)
leaq 0x1168(%rdi), %rax
xorl %edx, %edx
movl %edx, 0x1168(%rdi)
movq $0x0, 0x1170(%rdi)
movabsq $0x2000000000, %rsi     # imm = 0x2000000000
movq %rsi, 0x500(%rdi)
movl %edx, 0x508(%rdi)
leaq 0x548(%rdi), %rsi
movq %rsi, 0x540(%rdi)
movl %edx, 0x548(%rdi)
movl $0x0, 0x550(%rdi,%rdx)
addq $0x18, %rdx
cmpq $0xc00, %rdx            # imm = 0xC00
jne 0x139b
movq %rsi, 0x1150(%rdi)
movl $0x8, 0x1158(%rdi)
movq $0x0, 0x11b8(%rdi)
movq 0x9c22(%rip), %rdx      # 0xaff8
movq (%rdx), %rdx
movq %rdx, 0x11d8(%rdi)
xorl %edx, %edx
movl %edx, 0x11c0(%rdi)
movl %edx, 0x11f8(%rdi)
leaq 0x119(%rip), %rsi       # 0x150e
movq %rsi, 0x1200(%rdi)
leaq 0x1190(%rdi), %rsi
movq %rcx, 0x1190(%rdi)
movups (%rax), %xmm0
movups %xmm0, 0x1198(%rdi)
movq 0x10(%rax), %rcx
movq %rcx, 0x11a8(%rdi)
leaq 0x117(%rip), %rcx       # 0x153d
movq %rcx, 0x1208(%rdi)
movl %edx, 0x1210(%rdi)
leaq 0x1228(%rdi), %rcx
movl $0x1, (%rcx,%rdx)
movl $0x0, 0x20(%rcx,%rdx)
movups (%rax), %xmm0
movups %xmm0, 0x8(%rcx,%rdx)
movq 0x10(%rax), %r8
movq %r8, 0x18(%rcx,%rdx)
addq $0x28, %rdx
cmpq $0x280, %rdx            # imm = 0x280
jne 0x143a
movq $0x0, 0x14a8(%rdi)
movq %rsi, 0x14b0(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/MuvikLabs[P]runt/runt.c
// Function: runt_reinit
runt_int runt_reinit(runt_vm *vm)
{
    runt_init(vm);
    runt_cell_pool_set(vm, vm->cell_pool.cells, vm->cell_pool.size);
    runt_cell_pool_init(vm);
    runt_memory_pool_set(vm, vm->memory_pool.data, vm->memory_pool.size);
    return RUNT_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1348
movq 0x510(%rbx), %rax
movl $0x0, 0x51c(%rbx)
cmpl $0x0, 0x518(%rbx)
je 0x15e5
leaq 0x1168(%rbx), %rcx
xorl %edx, %edx
leaq -0x13b(%rip), %rsi      # 0x147f
movq %rsi, (%rax)
movups (%rcx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x10(%rcx), %rdi
movq %rdi, 0x18(%rax)
movl $0x0, 0x20(%rax)
incq %rdx
movl 0x518(%rbx), %edi
addq $0x28, %rax
cmpq %rdi, %rdx
jb 0x15ba
movl $0x0, 0x520(%rbx)
movq 0x528(%rbx), %rdi
movl 0x530(%rbx), %edx
movq $0x0, 0x534(%rbx)
xorl %esi, %esi
callq 0x1090
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/MuvikLabs[P]runt/runt.c
// Function: runt_cell_pool_init
runt_int runt_cell_pool_init(runt_vm *vm)
{
    runt_uint i;
    runt_cell *cells = vm->cell_pool.cells;

    for(i = 0; i < vm->cell_pool.size; i++) {
       runt_cell_clear(vm, &cells[i]);
    }
    vm->cell_pool.mark = 0;
    return RUNT_OK;
}

// Assembly:
cmpl $0x0, 0x518(%rdi)
je 0x167e
movq 0x510(%rdi), %rax
leaq 0x1168(%rdi), %rcx
xorl %edx, %edx
leaq -0x1d3(%rip), %rsi      # 0x147f
movq %rsi, (%rax)
movups (%rcx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x10(%rcx), %r8
movq %r8, 0x18(%rax)
movl $0x0, 0x20(%rax)
incq %rdx
movl 0x518(%rdi), %r8d
addq $0x28, %rax
cmpq %r8, %rdx
jb 0x1652
movl $0x0, 0x520(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/MuvikLabs[P]runt/runt.c
// Function: runt_load_minimal
runt_int runt_load_minimal(runt_vm *vm)
{
    /* create float type */
    runt_cell_malloc(vm, &vm->f_cell);
    runt_cell_bind(vm, vm->f_cell, rproc_float);

    /* create string type */
    runt_cell_malloc(vm, &vm->s_cell);
    runt_cell_bind(vm, vm->s_cell, rproc_string);

    /* ability to create procedures by default */
    runt_keyword_define_with_copy(vm, ":", 1, vm->zproc, rproc_begin, NULL);
    runt_keyword_define_with_copy(vm, ";", 1, vm->zproc, rproc_end, NULL);

    /* [ and ] for rec, stop */
    runt_keyword_define(vm, "[", 1, rproc_rec, NULL);
    runt_keyword_define_with_copy(vm, "]", 1, vm->zproc, rproc_stop, NULL);

    return RUNT_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x530(%rdi), %eax
movl 0x534(%rdi), %edx
leaq 0x28(%rdx), %rcx
cmpq %rax, %rcx
jae 0x172f
movq 0x528(%rbx), %rcx
addq %rdx, %rcx
movq %rcx, 0x1180(%rbx)
leal 0x28(%rdx), %esi
movl %esi, 0x534(%rbx)
cmpl $-0x1, %edx
je 0x1738
leaq -0x27a(%rip), %rax      # 0x147f
movq %rax, (%rcx)
movups 0x1168(%rbx), %xmm0
movups %xmm0, 0x8(%rcx)
movq 0x1178(%rbx), %rax
movq %rax, 0x18(%rcx)
xorl %eax, %eax
movl %eax, 0x20(%rcx)
movq 0x1180(%rbx), %rcx
movl %eax, 0x24(%rcx)
movl 0x530(%rbx), %eax
movl 0x534(%rbx), %edx
jmp 0x173d
movq 0x1180(%rbx), %rcx
jmp 0x173d
movl $0x27, %edx
leaq 0x17a(%rip), %rsi       # 0x18be
movq %rsi, (%rcx)
movl %edx, %ecx
leaq 0x28(%rcx), %rdx
cmpq %rax, %rdx
jae 0x17a7
movq 0x528(%rbx), %rax
addq %rcx, %rax
movq %rax, 0x1188(%rbx)
leal 0x28(%rcx), %edx
movl %edx, 0x534(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
je 0x17ae
leaq -0x2fe(%rip), %rcx      # 0x147f
movq %rcx, (%rax)
movups 0x1168(%rbx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x1178(%rbx), %rcx
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movl %ecx, 0x20(%rax)
movq 0x1188(%rbx), %rax
movl %ecx, 0x24(%rax)
jmp 0x17ae
movq 0x1188(%rbx), %rax
leaq 0x15b(%rip), %rcx       # 0x1910
movq %rcx, (%rax)
movq 0x1160(%rbx), %rcx
leaq 0x599a(%rip), %rsi      # 0x7160
leaq 0x273(%rip), %r8        # 0x1a40
movq %rbx, %rdi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x195f
movq 0x1160(%rbx), %rcx
leaq 0x5977(%rip), %rsi      # 0x7162
leaq 0x265(%rip), %r8        # 0x1a57
movq %rbx, %rdi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x195f
leaq 0x595b(%rip), %rsi      # 0x7164
leaq 0x31c(%rip), %rcx       # 0x1b2c
leaq 0x776(%rip), %r8        # 0x1f8d
movq %rbx, %rdi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x195f
movq 0x1160(%rbx), %rcx
leaq 0x5931(%rip), %rsi      # 0x7166
leaq 0x2fd(%rip), %r8        # 0x1b39
movq %rbx, %rdi
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x195f
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/MuvikLabs[P]runt/runt.c
// Function: runt_add_destructor
runt_uint runt_malloc(runt_vm *vm, size_t size, void **ud)
{

    runt_memory_pool *pool = &vm->memory_pool;
    runt_uint id = 0;

#ifdef ALIGNED_MALLOC
    if(size % 4 != 0) {
        size = ((size/4) + 1) * 4;
    }
#endif

    /* TODO: overload error handling */
    if(pool->used + size >= pool->size) {
        return 0;
    }

    *ud = (void *)&pool->data[pool->used];

    id = pool->used + 1;
    pool->used += size;

    return id;
}

// Assembly:
movl 0x530(%rdi), %edx
movl 0x534(%rdi), %ecx
leaq 0x28(%rcx), %r8
xorl %eax, %eax
cmpq %rdx, %r8
jae 0x3aea
movq 0x528(%rdi), %rdx
leal 0x28(%rcx), %r8d
movl %r8d, 0x534(%rdi)
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpq %r8, %rcx
je 0x3aea
leaq 0x8(%rsp), %rax
leaq (%rdx,%rcx), %r8
movq $0x0, 0x20(%rdx,%rcx)
movq %rsi, (%rdx,%rcx)
movups (%rax), %xmm0
movups %xmm0, 0x8(%rdx,%rcx)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rdx,%rcx)
movl 0x534(%rdi), %ecx
movq 0x528(%rdi), %rdx
leaq (%rdx,%rcx), %rax
leal 0x58(%rcx), %esi
movl %esi, 0x534(%rdi)
leaq -0x1b0b(%rip), %rsi     # 0x1f8d
movq %rsi, 0x8(%rdx,%rcx)
movq %r8, (%rdx,%rcx)
movups 0x1168(%rdi), %xmm0
movups %xmm0, 0x10(%rdx,%rcx)
movq 0x1178(%rdi), %rsi
movq %rsi, 0x20(%rdx,%rcx)
movl $0x0, 0x28(%rdx,%rcx)
movl 0x1210(%rdi), %ecx
testl %ecx, %ecx
jle 0x3ad6
movq 0x1218(%rdi), %rdx
movq %rdx, 0x40(%rax)
movq %rax, 0x1218(%rdi)
incl %ecx
movl %ecx, 0x1210(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/MuvikLabs[P]runt/runt.c
// Function: rproc_float
static int rproc_float(runt_vm *vm, runt_ptr p)
{
    runt_stacklet *s;
    runt_float *f;
    runt_int rc;

    f = runt_to_float(p);
    rc = runt_ppush(vm, &s);
    RUNT_ERROR_CHECK(rc);

    s->f = *f;
    s->t = RUNT_FLOAT;
    return RUNT_OK;
}

// Assembly:
pushq %rbx
movslq 0x500(%rdi), %rax
cmpl 0x504(%rdi), %eax
jne 0x18e0
leaq 0x592c(%rip), %rsi      # 0x7201
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1cb9
jmp 0x190c
leaq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x500(%rdi)
leaq (%rax,%rax,4), %rax
movss (%rcx), %xmm0
movss %xmm0, 0x20(%rdi,%rax,8)
movl $0x1, (%rdi,%rax,8)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq