LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/anachronic[P]st/st.c
// Function: selscroll
void
selscroll(int top, int bot, int n)
{
	/* turn absolute coordinates into relative */
	top += term.scr, bot += term.scr;

	if (BETWEEN(sel.nb.y, top, bot) != BETWEEN(sel.ne.y, top, bot)) {
		selclear();
	} else if (BETWEEN(sel.nb.y, top, bot)) {
		selmove(n);
		if (sel.nb.y < top || sel.ne.y > bot)
			selclear();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl 0x13fc1(%rip), %eax     # 0x20d78
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x13fb5(%rip), %eax     # 0x20d78
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %ecx
xorl %eax, %eax
cmpl 0x100ec(%rip), %ecx     # 0x1cec0
movb %al, -0xd(%rbp)
jg 0xcde8
movl 0x100e1(%rip), %eax     # 0x1cec0
cmpl -0x8(%rbp), %eax
setle %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %ecx
xorl %eax, %eax
cmpl 0x100ca(%rip), %ecx     # 0x1cec8
movb %al, -0xe(%rbp)
jg 0xce12
movl 0x100bf(%rip), %eax     # 0x1cec8
cmpl -0x8(%rbp), %eax
setle %al
movb %al, -0xe(%rbp)
movl -0x14(%rbp), %eax
movb -0xe(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0xce29
callq 0x5f40
jmp 0xce66
movl -0x4(%rbp), %eax
cmpl 0x1008e(%rip), %eax     # 0x1cec0
jg 0xce64
movl 0x10086(%rip), %eax     # 0x1cec0
cmpl -0x8(%rbp), %eax
jg 0xce64
movl -0xc(%rbp), %edi
callq 0x7bd0
movl 0x10073(%rip), %eax     # 0x1cec0
cmpl -0x4(%rbp), %eax
jl 0xce5d
movl 0x10070(%rip), %eax     # 0x1cec8
cmpl -0x8(%rbp), %eax
jle 0xce62
callq 0x5f40
jmp 0xce64
jmp 0xce66
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/anachronic[P]st/st.c
// Function: tloadaltscreen
void
tloadaltscreen(int clear, int savecursor)
{
	int col, row, def = !IS_SET(MODE_ALTSCREEN);

	if (savecursor)
		tcursor(CURSOR_SAVE);
	if (def) {
		col = term.col, row = term.row;
		tswapscreen();
		term.scr = 0;
		tresizealt(col, row);
	}
	if (clear)
		tclearregion(0, 0, term.col-1, term.row-1, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x13f38(%rip), %eax     # 0x20dbc
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xcea4
xorl %edi, %edi
callq 0x9090
cmpl $0x0, -0x14(%rbp)
je 0xced6
movl 0x10034(%rip), %eax     # 0x1cee4
movl %eax, -0xc(%rbp)
movl 0x10027(%rip), %eax     # 0x1cee0
movl %eax, -0x10(%rbp)
callq 0x79e0
movl $0x0, 0x13ead(%rip)     # 0x20d78
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x82f0
cmpl $0x0, -0x4(%rbp)
je 0xcefd
movl 0x10002(%rip), %edx     # 0x1cee4
subl $0x1, %edx
movl 0xfff5(%rip), %ecx      # 0x1cee0
subl $0x1, %ecx
xorl %esi, %esi
movl $0x1, %r8d
movl %esi, %edi
callq 0xbe10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anachronic[P]st/st.c
// Function: tloaddefscreen
void
tloaddefscreen(int clear, int loadcursor)
{
	int col, row, alt = IS_SET(MODE_ALTSCREEN);

	if (alt) {
		if (clear)
			tclearregion(0, 0, term.col-1, term.row-1, 1);
		col = term.col, row = term.row;
		tswapscreen();
	}
	if (loadcursor)
		tcursor(CURSOR_LOAD);
	if (alt)
		tresizedef(col, row);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x13e98(%rip), %eax     # 0x20dbc
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xcf79
cmpl $0x0, -0x4(%rbp)
je 0xcf62
movl 0xff9d(%rip), %edx      # 0x1cee4
subl $0x1, %edx
movl 0xff90(%rip), %ecx      # 0x1cee0
subl $0x1, %ecx
xorl %esi, %esi
movl $0x1, %r8d
movl %esi, %edi
callq 0xbe10
movl 0xff7c(%rip), %eax      # 0x1cee4
movl %eax, -0xc(%rbp)
movl 0xff6f(%rip), %eax      # 0x1cee0
movl %eax, -0x10(%rbp)
callq 0x79e0
cmpl $0x0, -0x8(%rbp)
je 0xcf89
movl $0x1, %edi
callq 0x9090
cmpl $0x0, -0x14(%rbp)
je 0xcf9a
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x85b0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/anachronic[P]st/st.c
// Function: rscrolldown
void
rscrolldown(int n)
{
	int i;
	Line temp;

	/* can never be true as of now
	if (IS_SET(MODE_ALTSCREEN))
		return; */

	if ((n = MIN(n, term.histf)) <= 0)
		return;

	for (i = term.c.y + n; i >= n; i--) {
		temp = term.line[i];
		term.line[i] = term.line[i-n];
		term.line[i-n] = temp;
	}
	for (/*i = n - 1 */; i >= 0; i--) {
		temp = term.line[i];
		term.line[i] = term.hist[term.histi];
		term.hist[term.histi] = temp;
		term.histi = (term.histi - 1 + HISTSIZE) % HISTSIZE;
	}
	term.c.y += n;
	term.histf -= n;
	if ((i = term.scr - n) >= 0) {
		term.scr = i;
	} else {
		term.scr = 0;
		if (sel.ob.x != -1 && !sel.alt)
			selmove(-i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x13390(%rip), %eax     # 0x20d74
jge 0xd9ee
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xd9f7
movl 0x13380(%rip), %eax     # 0x20d74
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jg 0xda07
jmp 0xdb53
movl 0x13397(%rip), %eax     # 0x20da4
addl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jl 0xda74
movq 0xf4c6(%rip), %rax      # 0x1cee8
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq 0xf4b3(%rip), %rax      # 0x1cee8
movl -0x8(%rbp), %ecx
subl -0x4(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0xf49f(%rip), %rax      # 0x1cee8
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdx
movq 0xf48c(%rip), %rax      # 0x1cee8
movl -0x8(%rbp), %ecx
subl -0x4(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xda13
jmp 0xda76
cmpl $0x0, -0x8(%rbp)
jl 0xdaef
movq 0xf465(%rip), %rax      # 0x1cee8
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movslq 0x132da(%rip), %rcx     # 0x20d70
leaq 0xf443(%rip), %rax      # 0x1cee0
movq 0x10(%rax,%rcx,8), %rdx
movq 0xf43f(%rip), %rax      # 0x1cee8
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdx
movslq 0x132b4(%rip), %rcx     # 0x20d70
leaq 0xf41d(%rip), %rax      # 0x1cee0
movq %rdx, 0x10(%rax,%rcx,8)
movl 0x132a2(%rip), %eax     # 0x20d70
subl $0x1, %eax
addl $0x7d0, %eax            # imm = 0x7D0
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
movl %edx, 0x1328c(%rip)     # 0x20d70
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xda76
movl -0x4(%rbp), %eax
addl 0x132ac(%rip), %eax     # 0x20da4
movl %eax, 0x132a6(%rip)     # 0x20da4
movl -0x4(%rbp), %ecx
movl 0x1326d(%rip), %eax     # 0x20d74
subl %ecx, %eax
movl %eax, 0x13265(%rip)     # 0x20d74
movl 0x13263(%rip), %eax     # 0x20d78
subl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jl 0xdb2b
movl -0x8(%rbp), %eax
movl %eax, 0x1324f(%rip)     # 0x20d78
jmp 0xdb53
movl $0x0, 0x13243(%rip)     # 0x20d78
cmpl $-0x1, 0xf390(%rip)     # 0x1cecc
je 0xdb51
cmpl $0x0, 0xf397(%rip)      # 0x1cedc
jne 0xdb51
xorl %edi, %edi
subl -0x8(%rbp), %edi
callq 0x7bd0
jmp 0xdb53
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/anachronic[P]st/x.c
// Function: xsettitle
void
xsettitle(char *p, int pop)
{
 	XTextProperty prop;
 
	free(titlestack[tstki]);
	if (pop) {
		titlestack[tstki] = NULL;
		tstki = (tstki - 1 + TITLESTACKSIZE) % TITLESTACKSIZE;
		p = titlestack[tstki] ? titlestack[tstki] : opt_title;
	} else if (p) {
		titlestack[tstki] = xstrdup(p);
	} else {
		titlestack[tstki] = NULL;
		p = opt_title;
	}

	if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
	                                &prop) != Success)
		return;
	XSetWMName(xw.dpy, xw.win, &prop);
	XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname);
	XFree(prop.value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq 0x14e3a(%rip), %rcx     # 0x233e0
leaq 0x14df3(%rip), %rax     # 0x233a0
movq (%rax,%rcx,8), %rdi
callq 0x5340
cmpl $0x0, -0xc(%rbp)
je 0xe62e
movslq 0x14e1d(%rip), %rcx     # 0x233e0
leaq 0x14dd6(%rip), %rax     # 0x233a0
movq $0x0, (%rax,%rcx,8)
movl 0x14e08(%rip), %eax     # 0x233e0
subl $0x1, %eax
addl $0x8, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, 0x14df4(%rip)     # 0x233e0
movslq 0x14ded(%rip), %rcx     # 0x233e0
leaq 0x14da6(%rip), %rax     # 0x233a0
cmpq $0x0, (%rax,%rcx,8)
je 0xe619
movslq 0x14dd8(%rip), %rcx     # 0x233e0
leaq 0x14d91(%rip), %rax     # 0x233a0
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
jmp 0xe624
movq 0x14d70(%rip), %rax     # 0x23390
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe678
cmpq $0x0, -0x8(%rbp)
je 0xe655
movq -0x8(%rbp), %rdi
callq 0x5b80
movq %rax, %rdx
movslq 0x14d98(%rip), %rcx     # 0x233e0
leaq 0x14d51(%rip), %rax     # 0x233a0
movq %rdx, (%rax,%rcx,8)
jmp 0xe676
movslq 0x14d84(%rip), %rcx     # 0x233e0
leaq 0x14d3d(%rip), %rax     # 0x233a0
movq $0x0, (%rax,%rcx,8)
movq 0x14d1e(%rip), %rax     # 0x23390
movq %rax, -0x8(%rbp)
jmp 0xe678
movq 0x14be1(%rip), %rdi     # 0x23260
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0x30(%rbp), %r8
callq 0x5430
cmpl $0x0, %eax
je 0xe69d
jmp 0xe6db
movq 0x14bbc(%rip), %rdi     # 0x23260
movq 0x14bc5(%rip), %rsi     # 0x23270
leaq -0x30(%rbp), %rdx
callq 0x53e0
movq 0x14ba5(%rip), %rdi     # 0x23260
movq 0x14bae(%rip), %rsi     # 0x23270
movq 0x14bcf(%rip), %rcx     # 0x23298
leaq -0x30(%rbp), %rdx
callq 0x5450
movq -0x30(%rbp), %rdi
callq 0x5090
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anachronic[P]st/x.c
// Function: xpushtitle
void
xpushtitle(void)
{
	int tstkin = (tstki + 1) % TITLESTACKSIZE;

	free(titlestack[tstkin]);
	titlestack[tstkin] = titlestack[tstki] ? xstrdup(titlestack[tstki]) : NULL;
	tstki = tstkin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x14ce2(%rip), %eax     # 0x233e0
addl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x14c89(%rip), %rax     # 0x233a0
movq (%rax,%rcx,8), %rdi
callq 0x5340
movslq 0x14cb9(%rip), %rcx     # 0x233e0
leaq 0x14c72(%rip), %rax     # 0x233a0
cmpq $0x0, (%rax,%rcx,8)
je 0xe752
movslq 0x14ca4(%rip), %rcx     # 0x233e0
leaq 0x14c5d(%rip), %rax     # 0x233a0
movq (%rax,%rcx,8), %rdi
callq 0x5b80
movq %rax, -0x10(%rbp)
jmp 0xe75a
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xe75a
movq -0x10(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x14c37(%rip), %rax     # 0x233a0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
movl %eax, 0x14c6a(%rip)     # 0x233e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/anachronic[P]st/x.c
// Function: mouseaction
int
mouseaction(XEvent *e, uint release)
{
	MouseShortcut *ms;

	/* ignore Button<N>mask for Button<N> - it's set on release */
	uint state = e->xbutton.state & ~buttonmask(e->xbutton.button);

	for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) {
		if (ms->release == release &&
		    ms->button == e->xbutton.button &&
		    (!ms->altscrn || (ms->altscrn == (tisaltscreen() ? 1 : -1))) &&
		    (match(ms->mod, state) ||  /* exact or forced */
		     match(ms->mod, state & ~forcemousemod))) {
			ms->func(&(ms->arg));
			return 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %edi
callq 0x13640
movl %eax, %ecx
movl -0x28(%rbp), %eax
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x24(%rbp)
leaq 0x9937(%rip), %rax      # 0x1cdb0
movq %rax, -0x20(%rbp)
leaq 0x992c(%rip), %rax      # 0x1cdb0
addq $0xe0, %rax
cmpq %rax, -0x20(%rbp)
jae 0x13545
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x13532
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jne 0x13532
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x134e6
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x7bb0
movl %eax, %esi
movl -0x2c(%rbp), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jne 0x13532
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x24(%rbp), %esi
callq 0x12d10
cmpl $0x0, %eax
jne 0x13517
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x24(%rbp), %esi
movl 0x9898(%rip), %eax      # 0x1cda0
xorl $-0x1, %eax
andl %eax, %esi
callq 0x12d10
cmpl $0x0, %eax
je 0x13532
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x1354c
jmp 0x13534
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x1347d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/cgc/cgc.c
// Function: find_roots
static void find_roots(jmp_buf env)
{
  num_roots = 0;

  /* Since a frame was pushed to call find_roots,
     stack variables during original_main() are definitely
     deeper than `stack_now` */
  void **stack_now = (void **)&stack_now;

  /* Scan the stack for pointers */
  while ((void *)stack_now < stack_init) {
    if (looks_like_allocated(*stack_now))
      root_addrs[num_roots++] = (struct node **)stack_now;
    stack_now++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2c65(%rip), %rax      # 0x4078
movl $0x0, (%rax)
leaq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x2c3c(%rip), %rax      # 0x4068
jae 0x1476
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x14f0
cmpl $0x0, %eax
je 0x1468
movq -0x10(%rbp), %rdx
leaq 0x2c2e(%rip), %rax      # 0x4078
movl (%rax), %eax
movl %eax, %esi
addl $0x1, %esi
leaq 0x2c20(%rip), %rcx      # 0x4078
movl %esi, (%rcx)
movslq %eax, %rcx
leaq 0x2c2c(%rip), %rax      # 0x4090
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x1421
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/cgc/cgc.c
// Function: looks_like_allocated
static int looks_like_allocated(struct gc_node *p)
{
  /* Walk through chunks, checking the pointer range */
  for (struct gc_chunk *c = chunks; c; c = c->next) {
    if ((p >= c->mem)
        && (p <= (c->mem + NODES_PER_CHUNK))) {
      /* looks like a pointer; make sure it matches a `gc_node`
         start position */
      uintptr_t delta = ((char *)p - (char *)c->mem);
      if ((delta % sizeof(struct gc_node)) == offsetof(struct gc_node, n))
        return 1;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x2b81(%rip), %rax      # 0x4080
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1574
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x1565
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $0xc0000, %rcx          # imm = 0xC0000
cmpq %rcx, %rax
ja 0x1565
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x18, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x8, %rdx
jne 0x1563
movl $0x1, -0x4(%rbp)
jmp 0x157b
jmp 0x1565
jmp 0x1567
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1506
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: keys::keys()
keys::keys() {
	version = 0;
	login = 0;
	for (unsigned i = 0; i < 20; ++i) {
		hash[i] = 0;
		handshake[i] = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jae 0x8da8
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movb $0x0, 0x8(%rax,%rcx)
movl -0xc(%rbp), %ecx
movb $0x0, 0x1c(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8d83
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: keys::print()
void keys::print() {
	std::cout << "version = " << version << std::endl;
	std::cout << "login = " << login << std::endl;
	std::cout << "handshake = " << handshake << std::endl;
	std::cout << "hash =";
	for (unsigned i = 0; i < 20; ++i) {
		printf(" %02x", hash[i]);
	}
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8205(%rip), %rdi      # 0x10fd0
leaq 0x28bd(%rip), %rsi      # 0xb68f
callq 0x2160
movq %rax, %rdi
movq -0x18(%rbp), %rax
movzwl (%rax), %esi
callq 0x2290
movq %rax, %rdi
movq 0x81d0(%rip), %rsi      # 0x10fc0
callq 0x21b0
movq 0x81d4(%rip), %rdi      # 0x10fd0
leaq 0x2897(%rip), %rsi      # 0xb69a
callq 0x2160
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x22b0
movq %rax, %rdi
movq 0x819f(%rip), %rsi      # 0x10fc0
callq 0x21b0
movq 0x81a3(%rip), %rdi      # 0x10fd0
leaq 0x286f(%rip), %rsi      # 0xb6a3
callq 0x2160
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x1c, %rsi
callq 0x2160
movq %rax, %rdi
movq 0x816d(%rip), %rsi      # 0x10fc0
callq 0x21b0
movq 0x8171(%rip), %rdi      # 0x10fd0
leaq 0x284a(%rip), %rsi      # 0xb6b0
callq 0x2160
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jae 0x8e9d
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movzbl 0x8(%rax,%rcx), %esi
leaq 0x282c(%rip), %rdi      # 0xb6b7
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8e72
movq 0x812c(%rip), %rdi      # 0x10fd0
movq 0x8115(%rip), %rsi      # 0x10fc0
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: keys::write_to(_IO_FILE*)
void keys::write_to(FILE *f) {
	fwrite(&version, 2, 1, f);
	fwrite(&login, 4, 1, f);
	fwrite(hash, 1, 20, f);
	fwrite(handshake, 1, 20, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movl $0x2, %esi
movl $0x1, %edx
callq 0x22e0
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x22e0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x14, %edx
callq 0x22e0
movq -0x18(%rbp), %rdi
addq $0x1c, %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x14, %edx
callq 0x22e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: executer::get_lex_bool()
bool executer::get_lex_bool() {
	uint32_t index;
	*this >> index;
	if (strlen(abc_file::get_multiname(index)->ns_str))
		fatal("class is out of our namespace");
	class_info *c = abc_file::get_class_by_name(index);
	c->do_static_init();
	assert(next() == OP_getproperty);
	*this >> index;
	traits_info *trait = c->get_trait_by_name(abc_file::get_multiname(index));
	if (! trait->has_loaded_value)
		fatal("The static trait does not have a loaded value");
	return trait->loaded_value != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x43e0
movl -0xc(%rbp), %edi
callq 0x35e0
movq 0x8(%rax), %rdi
callq 0x20d0
cmpq $0x0, %rax
je 0x93c0
movl $0x18, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x233e(%rip), %rsi      # 0xb6bd
leaq 0x2355(%rip), %rdx      # 0xb6db
movl $0x53, %ecx
callq 0x2f40
jmp 0x9392
movq -0x40(%rbp), %rdi
leaq 0x79eb(%rip), %rsi      # 0x10d88
xorl %eax, %eax
movl %eax, %edx
callq 0x22a0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x94e7
movl -0xc(%rbp), %edi
callq 0x36f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4f90
movq -0x38(%rbp), %rdi
callq 0x42e0
movzbl %al, %eax
cmpl $0x66, %eax
je 0x9442
movl $0x18, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x22ef(%rip), %rsi      # 0xb6f0
leaq 0x22d3(%rip), %rdx      # 0xb6db
movl $0x56, %ecx
callq 0x2f40
jmp 0x9414
movq -0x48(%rbp), %rdi
leaq 0x7969(%rip), %rsi      # 0x10d88
xorl %eax, %eax
movl %eax, %edx
callq 0x22a0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x94e7
jmp 0x9444
movq -0x38(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x43e0
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %edi
callq 0x35e0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x52c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x94d4
movl $0x18, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x2268(%rip), %rsi      # 0xb6fe
leaq 0x223e(%rip), %rdx      # 0xb6db
movl $0x5a, %ecx
callq 0x2f40
jmp 0x94a9
movq -0x58(%rbp), %rdi
leaq 0x78d4(%rip), %rsi      # 0x10d88
xorl %eax, %eax
movl %eax, %edx
callq 0x22a0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x94e7
movq -0x30(%rbp), %rax
cmpl $0x0, 0x14(%rax)
setne %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22d0
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: executer::get_lex_str()
char *executer::get_lex_str() {
	uint32_t index;
	*this >> index;
	if (strlen(abc_file::get_multiname(index)->ns_str))
		return abc_file::get_str(0);
	class_info *c = abc_file::get_class_by_name(index);
	c->do_static_init();
	assert(next() == OP_getproperty);
	*this >> index;
	traits_info *trait = c->get_trait_by_name(abc_file::get_multiname(index));
	return abc_file::get_str(trait->vindex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x43e0
movl -0x14(%rbp), %edi
callq 0x35e0
movq 0x8(%rax), %rdi
callq 0x20d0
cmpq $0x0, %rax
je 0x9534
xorl %edi, %edi
callq 0x3520
movq %rax, -0x8(%rbp)
jmp 0x95f2
movl -0x14(%rbp), %edi
callq 0x36f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4f90
movq -0x40(%rbp), %rdi
callq 0x42e0
movzbl %al, %eax
cmpl $0x66, %eax
je 0x95b3
movl $0x18, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x217b(%rip), %rsi      # 0xb6f0
leaq 0x215f(%rip), %rdx      # 0xb6db
movl $0x65, %ecx
callq 0x2f40
jmp 0x9588
movq -0x48(%rbp), %rdi
leaq 0x77f5(%rip), %rsi      # 0x10d88
xorl %eax, %eax
movl %eax, %edx
callq 0x22a0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2110
jmp 0x95fc
jmp 0x95b5
movq -0x40(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x43e0
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %edi
callq 0x35e0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x52c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x3520
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: find_version()
static void find_version() {
	class_info *c = abc_file::get_class(0);
	executer exec(c->ctor);
	exec.step_until(OP_constructsuper);
	exec.step_until(OP_setproperty);
	assert(exec.next() == OP_getlex);
	if (! exec.get_lex_bool()) {
		fatal("(unimplemented) The key version is burried deeper");
	}
	key.version = (uint16_t)abc_file::get_double(c->traits[0].vindex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
xorl %edi, %edi
callq 0x36b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0xad00
leaq -0x18(%rbp), %rdi
movl $0x49, %esi
callq 0x2d70
leaq -0x18(%rbp), %rdi
movl $0x61, %esi
callq 0x2d70
leaq -0x18(%rbp), %rdi
callq 0x42e0
movzbl %al, %eax
cmpl $0x60, %eax
je 0x999d
movl $0x18, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x1d94(%rip), %rsi      # 0xb6f0
leaq 0x1d78(%rip), %rdx      # 0xb6db
movl $0x13c, %ecx            # imm = 0x13C
callq 0x2f40
jmp 0x996f
movq -0x30(%rbp), %rdi
leaq 0x740e(%rip), %rsi      # 0x10d88
xorl %eax, %eax
movl %eax, %edx
callq 0x22a0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2110
jmp 0x9a2d
jmp 0x999f
leaq -0x18(%rbp), %rdi
callq 0x9330
testb $0x1, %al
jne 0x9a05
movl $0x18, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x1dd4(%rip), %rsi      # 0xb79b
leaq 0x1d0d(%rip), %rdx      # 0xb6db
movl $0x13e, %ecx            # imm = 0x13E
callq 0x2f40
jmp 0x99da
movq -0x38(%rbp), %rdi
leaq 0x73a3(%rip), %rsi      # 0x10d88
xorl %eax, %eax
movl %eax, %edx
callq 0x22a0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2110
jmp 0x9a2d
movq -0x8(%rbp), %rdi
addq $0x68, %rdi
xorl %esi, %esi
callq 0x54c0
movl 0xc(%rax), %edi
callq 0x35b0
cvttsd2si %xmm0, %eax
movw %ax, 0x7fbd(%rip)       # 0x119e4
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: is_mark1(method_info*)
static bool is_mark1(method_info *m) {
	if (m->param_type.length() != 1)
		return false;
	if (m->code.length() < 30)
		return false;
	if (! streq(m->param_type[0]->str, "Event"))
		return false;
	uint8_t expected[9] = { 0xd0, 0x30, 0x57, 0x2a, 0xd6, 0x30, 0x65, 0x01, 0x20 };
	for (unsigned i = 0; i < 9; ++i) {
		if (m->code[i] != expected[i])
			return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xae00
cmpl $0x1, %eax
je 0xaa13
movb $0x0, -0x1(%rbp)
jmp 0xaaae
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0xae10
cmpl $0x1e, %eax
jae 0xaa2e
movb $0x0, -0x1(%rbp)
jmp 0xaaae
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5430
movq (%rax), %rax
movq 0x10(%rax), %rdi
leaq 0xda3(%rip), %rsi       # 0xb7ea
callq 0x2230
cmpl $0x0, %eax
je 0xaa57
movb $0x0, -0x1(%rbp)
jmp 0xaaae
movq 0xe5c(%rip), %rax       # 0xb8ba
movq %rax, -0x19(%rbp)
movb 0xe5a(%rip), %al        # 0xb8c2
movb %al, -0x11(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x9, -0x20(%rbp)
jae 0xaaaa
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movl -0x20(%rbp), %esi
callq 0x7210
movzbl (%rax), %eax
movl -0x20(%rbp), %ecx
movzbl -0x19(%rbp,%rcx), %ecx
cmpl %ecx, %eax
je 0xaa9d
movb $0x0, -0x1(%rbp)
jmp 0xaaae
jmp 0xaa9f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xaa72
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: do_mark0(method_info*)
static void do_mark0(method_info *m) {
	executer exec(m);
	exec.step_until(OP_iftrue);
	exec.step_until(OP_getlocal);
	get_hash_quad(&exec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xad00
leaq -0x18(%rbp), %rdi
movl $0x11, %esi
callq 0x2d70
leaq -0x18(%rbp), %rdi
movl $0x62, %esi
callq 0x2d70
leaq -0x18(%rbp), %rdi
callq 0xac30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: do_mark1(method_info*)
static void do_mark1(method_info *m) {
	executer exec(m);
	exec.step_until(OP_pushnull);
	exec.step_until(OP_pushnull);
	exec.step_until(OP_pushnull);
	exec.step_until(OP_getlocal_3);
	get_hash_quad(&exec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xad00
leaq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x2d70
leaq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x2d70
leaq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x2d70
leaq -0x18(%rbp), %rdi
movl $0xd3, %esi
callq 0x2d70
leaq -0x18(%rbp), %rdi
callq 0xac30
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/testdiff.c
// Function: main
int main(int argc, char* argv[])
{
	struct aatrace_pic src, dst;
	struct aatrace_diff_ctx ctx;
	int c;

	aatrace_diff_ctx_init(&ctx);

	while ((c = getopt(argc, argv, ":l:d:t:")) != -1) {
		switch(c) {
		case 'l':
			ctx.scale = atoi(optarg);
			break;
		case 'd':
			ctx.kernel = (enum aatrace_diff_kernel)atoi(optarg);
			break;
		case 't':
			ctx.threshold = (unsigned)atoi(optarg);
			break;
		case ':':
			fprintf(stderr, "Option -%c requires an operand\n", optopt);
			return 2;
		default:
		case '?':
			fprintf(stderr, "Unrecognized option: -%c\n", optopt);
			return 1;
		}
	}

	if (optind != argc - 2) {
		puts(usage);
		return 3;
	}

	if (util_load_pic(&src, argv[optind]) < 0)
		return 4;

	aatrace_diff(&dst, &src, &ctx);

	if (util_store_pic(argv[optind + 1], &dst) < 0)
		return 5;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x4c(%rbp), %rdi
callq 0x2090
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x1d67(%rip), %rdx      # 0x3004
callq 0x1130
movl %eax, -0x50(%rbp)
cmpl $-0x1, %eax
je 0x1387
movl -0x50(%rbp), %eax
movl %eax, -0x54(%rbp)
subl $0x3a, %eax
je 0x1326
jmp 0x12bb
movl -0x54(%rbp), %eax
subl $0x3f, %eax
je 0x1355
jmp 0x12c9
movl -0x54(%rbp), %eax
subl $0x64, %eax
je 0x12fe
jmp 0x12d3
movl -0x54(%rbp), %eax
subl $0x6c, %eax
je 0x12e7
jmp 0x12dd
movl -0x54(%rbp), %eax
subl $0x74, %eax
je 0x1312
jmp 0x1353
movq 0x3ce2(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x1140
movl %eax, -0x48(%rbp)
jmp 0x1382
movq 0x3ccb(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x1140
movl %eax, -0x4c(%rbp)
jmp 0x1382
movq 0x3cb7(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x1140
movl %eax, -0x44(%rbp)
jmp 0x1382
movq 0x3ccb(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x3ca9(%rip), %rax      # 0x4fe0
movl (%rax), %edx
leaq 0x1ccc(%rip), %rsi      # 0x300c
movb $0x0, %al
callq 0x10e0
movl $0x2, -0x4(%rbp)
jmp 0x141e
jmp 0x1355
movq 0x3c9c(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x3c7a(%rip), %rax      # 0x4fe0
movl (%rax), %edx
leaq 0x1cbd(%rip), %rsi      # 0x302c
movb $0x0, %al
callq 0x10e0
movl $0x1, -0x4(%rbp)
jmp 0x141e
jmp 0x128f
movq 0x3c3a(%rip), %rax      # 0x4fc8
movl (%rax), %eax
movl -0x8(%rbp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
je 0x13af
leaq 0x1caf(%rip), %rdi      # 0x3050
callq 0x1060
movl $0x3, -0x4(%rbp)
jmp 0x141e
movq -0x10(%rbp), %rax
movq 0x3c0e(%rip), %rcx      # 0x4fc8
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1d20
cmpl $0x0, %eax
jge 0x13d8
movl $0x4, -0x4(%rbp)
jmp 0x141e
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0x20c0
movq -0x10(%rbp), %rax
movq 0x3bd4(%rip), %rcx      # 0x4fc8
movl (%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1eb0
cmpl $0x0, %eax
jge 0x1417
movl $0x5, -0x4(%rbp)
jmp 0x141e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/diff.c
// Function: aatrace_diff
void aatrace_diff(struct aatrace_pic* dst,
		  const struct aatrace_pic* src,
		  const struct aatrace_diff_ctx* ctx)
{
	dst->w = src->w;
	dst->h = src->h;
	dst->ll = src->ll;

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

	switch (ctx->kernel) {
	default:
	case AATRACE_DIFF_KERNEL_NONE:
		memcpy(dst->buf, src->buf, src->ll*src->h);
		break;
	case AATRACE_DIFF_KERNEL_2x2:
		aatrace_diff2(dst->buf, src->buf, src->ll, src->h,
			      ctx->scale, ctx->threshold);
		break;
	case AATRACE_DIFF_KERNEL_3x3:
		aatrace_diff3(dst->buf, src->buf, src->ll, src->h,
			      ctx->scale, ctx->threshold);
		break;
	case AATRACE_DIFF_KERNEL_4x4:
		aatrace_diff4(dst->buf, src->buf, src->ll, src->h,
			      ctx->scale, ctx->threshold);
		break;
	}
}

// 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
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %eax
movl 0x10(%rcx), %ecx
imull %ecx, %eax
movl %eax, %edi
callq 0x1100
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x2143
movq -0x20(%rbp), %rax
leaq 0x10e6(%rip), %rcx      # 0x3220
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2145
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x10f0
jmp 0x2207
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0x18(%rbp), %rax
movl 0x8(%rax), %r9d
callq 0x2210
jmp 0x2207
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0x18(%rbp), %rax
movl 0x8(%rax), %r9d
callq 0x2380
jmp 0x2207
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0x18(%rbp), %rax
movl 0x8(%rax), %r9d
callq 0x2570
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ravenexp[P]aatrace/diff.c
// Function: aatrace_diff2
static
void aatrace_diff2(unsigned char* d, unsigned char* s,
		   int w, int h,
		   unsigned int scale,
		   unsigned int threshold)
{
	int l, i;
	unsigned int D;

	for (l = 0; l < h - 1; l++)
		for (i = l*w; i < (l + 1)*w - 1; i++) {
			D = abs(s[i + w] - s[i] + s[i + w + 1] - s[i + 1])
			  + abs(s[i + 1] - s[i] + s[i + w + 1] - s[i + w]);

			D = (D*scale)/4;
			D = (D > 255) ? 255 : D;
			d[i] = (D >= threshold) ? D : 0;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2378
movl -0x24(%rbp), %eax
imull -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
imull -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2368
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
addl -0x14(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
movq -0x10(%rbp), %rdx
movslq -0x28(%rbp), %rsi
movzbl (%rdx,%rsi), %edx
subl %edx, %ecx
movq -0x10(%rbp), %rdx
movl -0x28(%rbp), %esi
addl -0x14(%rbp), %esi
addl $0x1, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
addl %edx, %ecx
movq -0x10(%rbp), %rdx
movl -0x28(%rbp), %esi
addl -0x14(%rbp), %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
subl %edx, %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
imull -0x1c(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x2c(%rbp)
cmpl $0xff, -0x2c(%rbp)
jbe 0x2327
movl $0xff, %eax
movl %eax, -0x30(%rbp)
jmp 0x232d
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jb 0x2343
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x234a
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x234a
movl -0x34(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x224c
jmp 0x236a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2231
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/daemonize/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * pidfile;

	/*
	 * This will allocate some memory for the program name, which will be
	 * freed by an atexit() function.  The non-daemonized fork of this
	 * program will call _exit() to quit without calling that function.
	 * This might cause a memory checker to issue an invalid warning
	 * which should be suppressed.
	 */
	WARNP_INIT;

	/* Parse command-line argument. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_daemonize pidfile\n");
		goto err0;
	}
	pidfile = argv[1];

	/* Print current pid. */
	warn0("before daemonize, pid:\t%jd", (intmax_t)getpid());

	/* Launch daemon. */
	if (daemonize(pidfile))
		goto err0;

	/* Print current pid. */
	warn0("after daemonize, pid:\t%jd", (intmax_t)getpid());

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12ec
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1be0
jmp 0x12ee
cmpl $0x2, -0x8(%rbp)
je 0x130e
movq 0x3cfd(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1cff(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x1120
jmp 0x1375
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x10a0
movslq %eax, %rsi
leaq 0x1cfa(%rip), %rdi      # 0x3023
movb $0x0, %al
callq 0x1ef0
callq 0x1060
movl $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x1380
cmpl $0x0, %eax
je 0x134b
jmp 0x1375
jmp 0x134d
callq 0x10a0
movslq %eax, %rsi
leaq 0x1ce2(%rip), %rdi      # 0x303e
movb $0x0, %al
callq 0x1ef0
callq 0x1060
movl $0x0, (%rax)
xorl %edi, %edi
callq 0x1180
movl $0x1, %edi
callq 0x1180
nop
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_04/getugid.c
// Function: main
int main(int argc, char *argv[])
{
	int ret;

	printf("real user/group ID:      %d/%d\n", getuid(), getgid());
	printf("effective user/group ID: %d/%d\n", geteuid(), getegid());
#ifdef _HAS_GETRESUID
	printf("saved user/group ID:     %d/%d\n", getsuid(), getsgid());
#endif

	if (argc > 1) {
		ret = open(argv[1], O_RDONLY);
		printf("file %s can%s be read\n",
			argv[1], ret < 0 ? "'t" : "");
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1040
movl %eax, -0x20(%rbp)
callq 0x1080
movl -0x20(%rbp), %esi
movl %eax, %edx
leaq 0xe25(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
callq 0x1060
movl %eax, -0x1c(%rbp)
callq 0x1090
movl -0x1c(%rbp), %esi
movl %eax, %edx
leaq 0xe25(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1050
callq 0x1280
movl %eax, -0x18(%rbp)
callq 0x12b0
movl -0x18(%rbp), %esi
movl %eax, %edx
leaq 0xe25(%rip), %rdi       # 0x2044
movb $0x0, %al
callq 0x1050
cmpl $0x1, -0x8(%rbp)
jle 0x126e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x10a0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %ecx
leaq 0xdd1(%rip), %rdx       # 0x2023
leaq 0xe22(%rip), %rax       # 0x207b
cmpl $0x0, %ecx
cmovlq %rax, %rdx
leaq 0xdfd(%rip), %rdi       # 0x2064
movb $0x0, %al
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zefie[P]zefie_3k_iso_patcher/zefie_3k_iso_patcher.c
// Function: file_exists
bool file_exists(char *filename) {
	print_debug("checking if %s exists\n",filename);
	if (access(filename, 0) != -1) {
		print_debug("%s exists\n",filename);
		return true;
	}
	print_debug("%s does NOT exist\n",filename);
	return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0xa782f(%rip), %rdi     # 0x4a9004
movb $0x0, %al
callq 0x4017b0
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x462af0
cmpl $-0x1, %eax
je 0x40180a
movq 0x8(%rsp), %rsi
leaq 0xa7817(%rip), %rdi     # 0x4a9010
movb $0x0, %al
callq 0x4017b0
movl $0x1, 0x14(%rsp)
jmp 0x401825
movq 0x8(%rsp), %rsi
leaq 0xa7805(%rip), %rdi     # 0x4a901b
movb $0x0, %al
callq 0x4017b0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zefie[P]zefie_3k_iso_patcher/zefie_3k_iso_patcher.c
// Function: getFileDir
void getFileDir(char *filename, char *ret) {
	print_debug("attempting to find directory for %s\n",filename);
	char tmp[PATH_MAX];
	realpath(filename, tmp);
	if (!tmp) {
		printf("Error finding directory for %s (Err %i).\n", filename, errno);
		return;
	}
	print_debug("realpath for %s returned %s\n",filename,tmp);
	char *pos = strrchr(tmp, 47);
	int strpos = (pos - tmp);
	strncpy(ret, tmp, strpos);
	print_debug("found directory %s\n",ret);
}

// Assembly:
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, 0x1020(%rsp)
movq %rsi, 0x1018(%rsp)
movq 0x1020(%rsp), %rsi
leaq 0xa77d8(%rip), %rdi     # 0x4a902e
movb $0x0, %al
callq 0x4017b0
movq 0x1020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40c080
movq 0x1020(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xa77d0(%rip), %rdi     # 0x4a9053
movb $0x0, %al
callq 0x4017b0
leaq 0x10(%rsp), %rdi
movl $0x2f, %esi
callq 0x401050
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x4(%rsp)
movq 0x1018(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movslq 0x4(%rsp), %rdx
callq 0x401088
movq 0x1018(%rsp), %rsi
leaq 0xa779b(%rip), %rdi     # 0x4a9070
movb $0x0, %al
callq 0x4017b0
addq $0x1028, %rsp           # imm = 0x1028
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zefie[P]zefie_3k_iso_patcher/zefie_3k_iso_patcher.c
// Function: getFileNoExt
void getFileNoExt(char *filename, char *ret) {
	print_debug("attempting to remove extention from %s\n",filename);
	char filenoext[PATH_MAX];
	char *pos = strrchr(filename, 46);
	int strpos = (pos - filename);
	strncpy(ret, filename, strpos);
	ret[strpos] = 0;
	print_debug("result: %s\n",ret);
}

// Assembly:
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, 0x1020(%rsp)
movq %rsi, 0x1018(%rsp)
movq 0x1020(%rsp), %rsi
leaq 0xa776e(%rip), %rdi     # 0x4a9084
movb $0x0, %al
callq 0x4017b0
movq 0x1020(%rsp), %rdi
movl $0x2e, %esi
callq 0x401050
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x1020(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x4(%rsp)
movq 0x1018(%rsp), %rdi
movq 0x1020(%rsp), %rsi
movslq 0x4(%rsp), %rdx
callq 0x401088
movq 0x1018(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x1018(%rsp), %rsi
leaq 0xa772a(%rip), %rdi     # 0x4a90ac
movb $0x0, %al
callq 0x4017b0
addq $0x1028, %rsp           # imm = 0x1028
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zefie[P]zefie_3k_iso_patcher/zefie_3k_iso_patcher.c
// Function: findKeyfile
void findKeyfile(char *filename, char *ret) {	
	char filepath[PATH_MAX];
	getFileDir(filename, filepath);
	strcpy(ret, filepath);
	strcat(ret, "/disc.key");
	print_debug("attempting to find keyfile %s\n",ret);
	if (!file_exists(ret)) {
		print_debug("%s does NOT exist\n",ret);
		strcpy(ret, filepath);
		char filenoext[PATH_MAX];
		getFileNoExt(filename, filenoext);
		strcat(ret,"/");
		strcat(ret,filenoext);
		print_debug("attempting to find keyfile %s\n",ret);
		strncat(ret, ".key", -1);
		if (!file_exists(ret)) {
			print_debug("%s does NOT exist\n",ret);
			ret[5] = 0;
		}
	}
}

// Assembly:
subq $0x2018, %rsp           # imm = 0x2018
movq %rdi, 0x2010(%rsp)
movq %rsi, 0x2008(%rsp)
movq 0x2010(%rsp), %rdi
leaq 0x1000(%rsp), %rsi
callq 0x401830
movq 0x2008(%rsp), %rdi
leaq 0x1000(%rsp), %rsi
callq 0x401020
movq 0x2008(%rsp), %rdi
leaq 0xa76c8(%rip), %rsi     # 0x4a90b8
callq 0x401058
movq 0x2008(%rsp), %rsi
leaq 0xa76be(%rip), %rdi     # 0x4a90c2
movb $0x0, %al
callq 0x4017b0
movq 0x2008(%rsp), %rdi
callq 0x4017c0
cmpl $0x0, %eax
jne 0x401ae7
movq 0x2008(%rsp), %rsi
leaq 0xa75eb(%rip), %rdi     # 0x4a901b
movb $0x0, %al
callq 0x4017b0
movq 0x2008(%rsp), %rdi
leaq 0x1000(%rsp), %rsi
callq 0x401020
movq 0x2010(%rsp), %rdi
movq %rsp, %rsi
callq 0x4018f0
movq 0x2008(%rsp), %rdi
leaq 0xaea71(%rip), %rsi     # 0x4b04dc
callq 0x401058
movq 0x2008(%rsp), %rdi
movq %rsp, %rsi
callq 0x401058
movq 0x2008(%rsp), %rsi
leaq 0xa7633(%rip), %rdi     # 0x4a90c2
movb $0x0, %al
callq 0x4017b0
movq 0x2008(%rsp), %rdi
leaq 0xa7618(%rip), %rsi     # 0x4a90bd
movq $-0x1, %rdx
callq 0x4010a0
movq 0x2008(%rsp), %rdi
callq 0x4017c0
cmpl $0x0, %eax
jne 0x401ae5
movq 0x2008(%rsp), %rsi
leaq 0xa7549(%rip), %rdi     # 0x4a901b
movb $0x0, %al
callq 0x4017b0
movq 0x2008(%rsp), %rax
movb $0x0, 0x5(%rax)
jmp 0x401ae7
addq $0x2018, %rsp           # imm = 0x2018
retq
nop
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: reset_counter
void reset_counter(struct counter *c) {
	c->n = 0;
	c->n1k = 0;
	c->n1m = 0;
	c->n1g = 0;
	c->n1t = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: count
void count(struct counter *c) {
	char	msg[] = "statistics counter overflow";
	c->n++;
	if (c->n >= 1000) {
		c->n -= 1000;
		c->n1k++;
		if (c->n1k >= 1000) {
			c->n1k -= 1000;
			c->n1m++;
			if (c->n1m >= 1000) {
				c->n1m -= 1000;
				c->n1g++;
				if (c->n1g >= 1000) {
					c->n1t -= 1000;
					c->n1t++;
					if (c->n1t >= 1000) {
						error(msg, NOEXPR);
					}
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1e63d(%rip), %rax     # 0x219e0
movq %rax, -0x30(%rbp)
movq 0x1e63a(%rip), %rax     # 0x219e8
movq %rax, -0x28(%rbp)
movq 0x1e637(%rip), %rax     # 0x219f0
movq %rax, -0x20(%rbp)
movl 0x1e635(%rip), %eax     # 0x219f8
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x3e8, (%rax)          # imm = 0x3E8
jl 0x34a3
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpl $0x3e8, 0x4(%rax)       # imm = 0x3E8
jl 0x34a1
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x3e8, 0x8(%rax)       # imm = 0x3E8
jl 0x349f
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
subl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
cmpl $0x3e8, 0xc(%rax)       # imm = 0x3E8
jl 0x349d
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x3e8, 0x10(%rax)      # imm = 0x3E8
jl 0x349b
leaq -0x30(%rbp), %rdi
movq $-0x8, %rsi
callq 0x34b0
jmp 0x349d
jmp 0x349f
jmp 0x34a1
jmp 0x34a3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)