LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: selnormalize
void
selnormalize(void)
{
	int i;

	if (sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) {
		sel.nb.x = sel.ob.y < sel.oe.y ? sel.ob.x : sel.oe.x;
		sel.ne.x = sel.ob.y < sel.oe.y ? sel.oe.x : sel.ob.x;
	} else {
		sel.nb.x = MIN(sel.ob.x, sel.oe.x);
		sel.ne.x = MAX(sel.ob.x, sel.oe.x);
	}
	sel.nb.y = MIN(sel.ob.y, sel.oe.y);
	sel.ne.y = MAX(sel.ob.y, sel.oe.y);

	selsnap(&sel.nb.x, &sel.nb.y, -1);
	selsnap(&sel.ne.x, &sel.ne.y, +1);

	/* expand selection over line breaks */
	if (sel.type == SEL_RECTANGULAR)
		return;

  i = tlinelen(TLINE(sel.nb.y));
	if (sel.nb.x > i)
		sel.nb.x = i;
  if (sel.ne.x >= tlinelen(TLINE(sel.ne.y)))
    sel.ne.x = term.col - 1;
}

// Assembly:
cmpl $0x1, 0x12b6a(%rip)     # 0x188c4
setne %dl
movl 0x12b7d(%rip), %eax     # 0x188e0
movl 0x12b7f(%rip), %ecx     # 0x188e8
cmpl %ecx, %eax
sete %sil
orb %dl, %sil
je 0x5d92
movl 0x12b62(%rip), %esi     # 0x188dc
movl 0x12b64(%rip), %edx     # 0x188e4
cmpl %edx, %esi
movl %edx, %edi
cmovll %esi, %edi
movl %edi, 0x12b3f(%rip)     # 0x188cc
cmovgl %esi, %edx
jmp 0x5dae
cmpl %ecx, %eax
movl 0x12b42(%rip), %edx     # 0x188dc
movl 0x12b44(%rip), %esi     # 0x188e4
movl %esi, %edi
cmovll %edx, %edi
movl %edi, 0x12b21(%rip)     # 0x188cc
cmovll %esi, %edx
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, 0x12b1c(%rip)     # 0x188d4
leaq 0x12b15(%rip), %rbx     # 0x188d4
cmpl %ecx, %eax
movl %ecx, %edx
cmovll %eax, %edx
movl %edx, 0x12b04(%rip)     # 0x188d0
leaq 0x12afd(%rip), %rsi     # 0x188d0
cmovgl %eax, %ecx
movl %ecx, 0x12afc(%rip)     # 0x188d8
leaq 0x12af5(%rip), %r14     # 0x188d8
leaq 0x12ae2(%rip), %rdi     # 0x188cc
pushq $-0x1
popq %rdx
callq 0x8159
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8159
cmpl $0x2, 0x12abd(%rip)     # 0x188c4
je 0x5ec4
movl 0x12abd(%rip), %eax     # 0x188d0
movl 0x1696f(%rip), %ebp     # 0x1c788
leaq 0x12ad0(%rip), %rbx     # 0x188f0
subl %ebp, %eax
jge 0x5e46
movl 0x16956(%rip), %ecx     # 0x1c780
addl %ecx, %eax
addl $0x7d1, %eax            # imm = 0x7D1
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
movslq %edx, %rax
leaq (%rbx,%rax,8), %rax
addq $0x10, %rax
jmp 0x5e53
cltq
shlq $0x3, %rax
addq 0x12aa5(%rip), %rax     # 0x188f8
movq (%rax), %rdi
callq 0x6214
cmpl %eax, 0x12a6b(%rip)     # 0x188cc
jle 0x5e69
movl %eax, 0x12a63(%rip)     # 0x188cc
movl 0x12a64(%rip), %r14d    # 0x188d4
movl 0x12a62(%rip), %eax     # 0x188d8
subl %ebp, %eax
jge 0x5e9c
movl 0x16900(%rip), %ecx     # 0x1c780
addl %ecx, %eax
addl $0x7d1, %eax            # imm = 0x7D1
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
movslq %edx, %rax
leaq (%rbx,%rax,8), %rax
addq $0x10, %rax
jmp 0x5ea9
cltq
shlq $0x3, %rax
addq 0x12a4f(%rip), %rax     # 0x188f8
movq (%rax), %rdi
callq 0x6214
cmpl %eax, %r14d
jl 0x5ec4
movl 0x12a38(%rip), %eax     # 0x188f4
decl %eax
movl %eax, 0x12a10(%rip)     # 0x188d4
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: regionselected
int
regionselected(int x1, int y1, int x2, int y2)
{
	if (sel.ob.x == -1 || sel.mode == SEL_EMPTY ||
	    sel.alt != IS_SET(MODE_ALTSCREEN) || sel.nb.y > y2 || sel.ne.y < y1)
		return 0;

	return (sel.type == SEL_RECTANGULAR) ? sel.nb.x <= x2 && sel.ne.x >= x1
		: (sel.nb.y != y2 || sel.nb.x <= x2) &&
		  (sel.ne.y != y1 || sel.ne.x >= x1);
}

// Assembly:
xorl %eax, %eax
cmpl $-0x1, 0x128e4(%rip)    # 0x188dc
je 0x6037
cmpl $0x1, 0x128bf(%rip)     # 0x188c0
je 0x6037
movl 0x128e3(%rip), %eax     # 0x188ec
btl $0x2, 0x167bb(%rip)     # 0x1c7cc
sbbl $0x0, %eax
jne 0x6035
movl 0x128b3(%rip), %r8d     # 0x188d0
cmpl %ecx, %r8d
setg %r9b
movl 0x128ae(%rip), %eax     # 0x188d8
cmpl %esi, %eax
setl %r10b
orb %r9b, %r10b
je 0x603b
xorl %eax, %eax
movzbl %al, %eax
retq
cmpl $0x2, 0x12882(%rip)     # 0x188c4
jne 0x605a
cmpl %edx, 0x12882(%rip)     # 0x188cc
setle %cl
cmpl %edi, 0x12881(%rip)     # 0x188d4
setge %al
andb %cl, %al
jmp 0x6037
cmpl %ecx, %r8d
jne 0x6067
cmpl %edx, 0x12867(%rip)     # 0x188cc
jg 0x6035
cmpl %esi, %eax
setne %cl
cmpl %edi, 0x12862(%rip)     # 0x188d4
setge %al
orb %cl, %al
jmp 0x6037
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: tgetglyphs
char *
tgetglyphs(char *buf, const Glyph *gp, const Glyph *lgp)
{
	while (gp <= lgp)
		if (gp->mode & ATTR_WDUMMY) {
			gp++;
		} else {
			buf += utf8encode((gp++)->u, buf);
		}
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq %rbx, %r15
ja 0x6276
testb $0x8, 0x5(%r15)
jne 0x6270
movl (%r15), %edi
movq %r14, %rsi
callq 0x5b32
addq %rax, %r14
addq $0x10, %r15
jmp 0x6256
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: sigchld
void
sigchld(int a)
{
	int stat;
	pid_t p;

	if ((p = waitpid(pid, &stat, WNOHANG)) < 0)
		die("waiting for pid %hd failed: %s\n", pid, strerror(errno));

	if (pid != p) {
		if (p == 0 && wait(&stat) < 0)
			die("wait: %s\n", strerror(errno));

		/* reinstall sigchld handler */
		signal(SIGCHLD, sigchld);
		return;
	}

	if (WIFEXITED(stat) && WEXITSTATUS(stat))
		die("child exited with status %d\n", WEXITSTATUS(stat));
	else if (WIFSIGNALED(stat))
		die("child terminated due to signal %d\n", WTERMSIG(stat));
	_exit(0);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x16126(%rip), %edi     # 0x1c7f4
leaq 0xc(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x5530
movl 0x16113(%rip), %ebx     # 0x1c7f4
testl %eax, %eax
js 0x6710
cmpl %eax, %ebx
je 0x672f
testl %eax, %eax
jne 0x66fb
leaq 0xc(%rsp), %rdi
callq 0x5100
testl %eax, %eax
js 0x6775
leaq -0x3f(%rip), %rsi       # 0x66c3
pushq $0x11
popq %rdi
callq 0x5060
addq $0x10, %rsp
popq %rbx
retq
callq 0x55a0
movl (%rax), %edi
callq 0x5460
leaq 0xa012(%rip), %rdi      # 0x10735
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5a46
movl 0xc(%rsp), %eax
movl %eax, %esi
andl $0x7f, %esi
jne 0x674f
shrl $0x8, %eax
andl $0xff, %eax
je 0x676e
leaq 0xa014(%rip), %rdi      # 0x1075f
movl %eax, %esi
jmp 0x6767
movl %esi, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x676e
leaq 0xa015(%rip), %rdi      # 0x1077c
xorl %eax, %eax
callq 0x5a46
xorl %edi, %edi
callq 0x5230
callq 0x55a0
movl (%rax), %edi
callq 0x5460
leaq 0x9fcd(%rip), %rdi      # 0x10755
movq %rax, %rsi
xorl %eax, %eax
callq 0x5a46
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: kscrolldown
void
kscrolldown(const Arg* a)
{
	int n = a->i;

	if (!term.scr || IS_SET(MODE_ALTSCREEN))
		return;

	if (n < 0)
		n = MAX(term.row / -n, 1);

	if (n <= term.scr) {
		term.scr -= n;
	} else {
		n = term.scr;
		term.scr = 0;
	}

	if (sel.ob.x != -1 && !sel.alt)
		selmove(-n); /* negate change in term.scr */
	tfulldirt();
}

// Assembly:
movq %rdi, %rax
movl 0x15d99(%rip), %edi     # 0x1c788
testl %edi, %edi
je 0x6a55
testb $0x4, 0x15dd2(%rip)     # 0x1c7cc
jne 0x6a55
movl (%rax), %ecx
testl %ecx, %ecx
jns 0x6a16
movl 0x11ee8(%rip), %eax     # 0x188f0
negl %ecx
cltd
idivl %ecx
cmpl $0x2, %eax
pushq $0x1
popq %rcx
cmovgel %eax, %ecx
xorl %eax, %eax
movl %edi, %edx
subl %ecx, %edx
cmovll %eax, %edx
movl %edx, 0x15d63(%rip)     # 0x1c788
cmpl $-0x1, 0x11eb0(%rip)    # 0x188dc
je 0x700e
cmpl $0x0, 0x11eb3(%rip)     # 0x188ec
jne 0x700e
pushq %rax
cmpl %edi, %ecx
cmovll %ecx, %edi
negl %edi
callq 0x6ff5
addq $0x8, %rsp
jmp 0x700e
retq
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: tsetdirtattr
void
tsetdirtattr(int attr)
{
	int i, j;

	for (i = 0; i < term.row-1; i++) {
		for (j = 0; j < term.col-1; j++) {
			if (term.line[i][j].mode & attr) {
				term.dirty[i] = 1;
				break;
			}
		}
	}
}

// Assembly:
pushq %rbx
movq 0x15ad3(%rip), %rax     # 0x1c798
movl 0x11c25(%rip), %edx     # 0x188f0
xorl %ecx, %ecx
movl $0x1, %esi
leal -0x1(%rdx), %r8d
movslq %r8d, %r8
cmpq %r8, %rcx
jge 0x6d2e
movl 0x11c0f(%rip), %r8d     # 0x188f4
movq 0x11c0c(%rip), %r9      # 0x188f8
cmpl $0x2, %r8d
cmovll %esi, %r8d
decl %r8d
shlq $0x4, %r8
addq $0x10, %r8
xorl %r10d, %r10d
leaq 0x10(%r10), %r11
cmpq %r11, %r8
je 0x6d29
movq (%r9,%rcx,8), %rbx
movzwl 0x4(%rbx,%r10), %ebx
movq %r11, %r10
testl %edi, %ebx
je 0x6d02
movl $0x1, (%rax,%rcx,4)
movl 0x11bc7(%rip), %edx     # 0x188f0
incq %rcx
jmp 0x6cd2
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: tnew
void
tnew(int col, int row)
{
	int i, j;

	for (i = 0; i < 2; i++) {
		term.line = xmalloc(row * sizeof(Line));
		for (j = 0; j < row; j++)
			term.line[j] = xmalloc(col * sizeof(Glyph));
		term.col = col, term.row = row;
		tswapscreen();
	}
	term.dirty = xmalloc(row * sizeof(*term.dirty));
	term.tabs = xmalloc(col * sizeof(*term.tabs));
	for (i = 0; i < HISTSIZE; i++)
		term.hist[i] = xmalloc(col * sizeof(Glyph));
  treset();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movl %edi, %r12d
movslq %esi, %rax
leaq (,%rax,8), %rcx
movq %rcx, 0x10(%rsp)
movslq %edi, %rbx
movq %rbx, 0x8(%rsp)
shlq $0x4, %rbx
xorl %r14d, %r14d
movq %rax, (%rsp)
testl %eax, %eax
movl $0x0, %r15d
cmovgl %esi, %r15d
cmpl $0x2, %r14d
je 0x6dc0
movq 0x10(%rsp), %rdi
callq 0x5a1c
movq %rax, 0x11b6f(%rip)     # 0x188f8
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x6da9
movq %rbx, %rdi
callq 0x5a1c
movq 0x11b58(%rip), %rcx     # 0x188f8
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x6d8c
movl %r12d, 0x11b44(%rip)    # 0x188f4
movl %ebp, 0x11b3a(%rip)     # 0x188f0
callq 0x6e1e
incl %r14d
jmp 0x6d72
movq (%rsp), %rdi
shlq $0x2, %rdi
callq 0x5a1c
movq %rax, 0x159c4(%rip)     # 0x1c798
movq 0x8(%rsp), %rdi
shlq $0x2, %rdi
callq 0x5a1c
movq %rax, 0x159f7(%rip)     # 0x1c7e0
pushq $0x2
popq %r14
leaq 0x11afc(%rip), %r15     # 0x188f0
cmpq $0x7d2, %r14            # imm = 0x7D2
je 0x6e0e
movq %rbx, %rdi
callq 0x5a1c
movq %rax, (%r15,%r14,8)
incq %r14
jmp 0x6df4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6e72
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: tswapscreen
void
tswapscreen(void)
{
	static Line *altline;
	static int altcol, altrow;
	Line *tmpline = term.line;
	int tmpcol = term.col, tmprow = term.row;

	term.line = altline;
	term.col = altcol, term.row = altrow;
	altline = tmpline;
	altcol = tmpcol, altrow = tmprow;
	term.mode ^= MODE_ALTSCREEN;
}

// Assembly:
movq 0x11ad3(%rip), %rax     # 0x188f8
movl 0x11ac9(%rip), %ecx     # 0x188f4
movl 0x11abf(%rip), %edx     # 0x188f0
movq 0x17a10(%rip), %rsi     # 0x1e848
movq %rsi, 0x11ab9(%rip)     # 0x188f8
movl 0x17a0b(%rip), %esi     # 0x1e850
movl %esi, 0x11aa9(%rip)     # 0x188f4
movl 0x17a03(%rip), %esi     # 0x1e854
movl %esi, 0x11a99(%rip)     # 0x188f0
movq %rax, 0x179ea(%rip)     # 0x1e848
movl %ecx, 0x179ec(%rip)     # 0x1e850
movl %edx, 0x179ea(%rip)     # 0x1e854
xorb $0x4, 0x1595b(%rip)     # 0x1c7cc
retq
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: treset
void
treset(void)
{
	uint i;
  int x, y;

	tresetcursor();

	memset(term.tabs, 0, term.col * sizeof(*term.tabs));
	for (i = tabspaces; i < term.col; i += tabspaces)
		term.tabs[i] = 1;
	term.top = 0;
	term.histf = 0;
	term.scr = 0;
	term.bot = term.row - 1;
	term.mode = MODE_WRAP|MODE_UTF8;
	memset(term.trantbl, CS_USA, sizeof(term.trantbl));
	term.charset = 0;

  selremove();
	for (i = 0; i < 2; i++) {
  	tcursor(CURSOR_SAVE); /* reset saved cursor */
		for (y = 0; y < term.row; y++)
			for (x = 0; x < term.col; x++)
				tclearglyph(&term.line[y][x], 0);
		tswapscreen();
	}
  tfulldirt();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x1165b(%rip), %rbx     # 0x184dc
movl (%rbx), %eax
leaq 0x11656(%rip), %r14     # 0x184e0
movl (%r14), %ecx
andl $0x0, 0x1590c(%rip)     # 0x1c7a0
andw $0x0, 0x15908(%rip)     # 0x1c7a4
movl %eax, 0x15906(%rip)     # 0x1c7a8
movl %ecx, 0x15904(%rip)     # 0x1c7ac
andq $0x0, 0x15900(%rip)     # 0x1c7b0
movb $0x0, 0x15901(%rip)     # 0x1c7b8
movq 0x15922(%rip), %rdi     # 0x1c7e0
movslq 0x11a2f(%rip), %rdx     # 0x188f4
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x50a0
leaq 0x11601(%rip), %rax     # 0x184d8
movl (%rax), %ecx
movq 0x15900(%rip), %rdx     # 0x1c7e0
cmpl 0x11a0e(%rip), %ecx     # 0x188f4
jae 0x6ef5
movl %ecx, %esi
movl $0x1, (%rdx,%rsi,4)
addl (%rax), %ecx
jmp 0x6ee0
andl $0x0, 0x158c8(%rip)     # 0x1c7c4
andq $0x0, 0x15880(%rip)     # 0x1c784
movl 0x119e6(%rip), %eax     # 0x188f0
decl %eax
movl %eax, 0x158b6(%rip)     # 0x1c7c8
andl $0x0, 0x119a7(%rip)     # 0x188c0
movl $0x41, 0x158a9(%rip)    # 0x1c7cc
orl $-0x1, 0x119b2(%rip)    # 0x188dc
movq $0x3030303, 0x1589f(%rip) # imm = 0x3030303
xorl %r15d, %r15d
leaq 0x178d1(%rip), %r12     # 0x1e810
xorl %ebp, %ebp
cmpl $0x2, %ebp
je 0x6fde
movl 0x1587c(%rip), %eax     # 0x1c7cc
shrl $0x2, %eax
andl $0x1, %eax
imulq $0x1c, %rax, %rax
movups 0x1584b(%rip), %xmm0    # 0x1c7ac
movups %xmm0, 0xc(%rax,%r12)
movups 0x15832(%rip), %xmm0    # 0x1c7a0
movups %xmm0, (%rax,%r12)
movl 0x11977(%rip), %eax     # 0x188f0
movl 0x11975(%rip), %ecx     # 0x188f4
testl %ecx, %ecx
cmovlel %r15d, %ecx
testl %eax, %eax
cmovlel %r15d, %eax
shlq $0x4, %rcx
xorl %edx, %edx
cmpq %rax, %rdx
je 0x6fd2
movq 0x1195b(%rip), %rsi     # 0x188f8
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x6fcd
movq (%rsi,%rdx,8), %r8
movl (%r14), %r9d
movl (%rbx), %r10d
movl %r10d, 0x8(%r8,%rdi)
movl %r9d, 0xc(%r8,%rdi)
andw $0x0, 0x4(%r8,%rdi)
movl $0x20, (%r8,%rdi)
addq $0x10, %rdi
jmp 0x6f9f
incq %rdx
jmp 0x6f91
callq 0x6e1e
incl %ebp
jmp 0x6f41
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x700e
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: kscrollup
void
kscrollup(const Arg* a)
{
	int n = a->i;

	if (!term.histf || IS_SET(MODE_ALTSCREEN))
		return;

	if (n < 0)
		n = MAX(term.row / -n, 1);

	if (term.scr + n <= term.histf) {
		term.scr += n;
	} else {
		n = term.histf - term.scr;
		term.scr = term.histf;
	}

	if (sel.ob.x != -1 && !sel.alt)
		selmove(n); /* negate change in term.scr */
	tfulldirt();
}

// Assembly:
movl 0x1574e(%rip), %ecx     # 0x1c784
testl %ecx, %ecx
je 0x709d
testb $0x4, 0x1578b(%rip)     # 0x1c7cc
jne 0x709d
movl (%rdi), %edi
testl %edi, %edi
jns 0x705d
movl 0x118a1(%rip), %eax     # 0x188f0
negl %edi
cltd
idivl %edi
cmpl $0x2, %eax
pushq $0x1
popq %rdi
cmovgel %eax, %edi
movl 0x15725(%rip), %eax     # 0x1c788
leal (%rax,%rdi), %edx
cmpl %ecx, %edx
movl %ecx, %esi
cmovll %edx, %esi
movl %esi, 0x15715(%rip)     # 0x1c788
cmpl $-0x1, 0x11862(%rip)    # 0x188dc
je 0x700e
cmpl $0x0, 0x11869(%rip)     # 0x188ec
jne 0x700e
pushq %rax
movl %ecx, %esi
subl %eax, %esi
cmpl %ecx, %edx
cmovgl %esi, %edi
callq 0x6ff5
addq $0x8, %rsp
jmp 0x700e
retq
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: tresize
void
tresize(int col, int row)
{
	int *bp;

	/* col and row are always MAX(_, 1)
	if (col < 1 || row < 1) {
		fprintf(stderr, "tresize: error resizing to %dx%d\n", col, row);
		return;
	} */

	term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
	term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));
	if (col > term.col) {
		bp = term.tabs + term.col;
		memset(bp, 0, sizeof(*term.tabs) * (col - term.col));
		while (--bp > term.tabs && !*bp)
			/* nothing */ ;
		for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
			*bp = 1;
	}

	if (IS_SET(MODE_ALTSCREEN))
		tresizealt(col, row);
	else
		tresizedef(col, row);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movq 0x1541c(%rip), %rdi     # 0x1c798
movslq %esi, %rsi
shlq $0x2, %rsi
callq 0x5ade
movq %rax, 0x15409(%rip)     # 0x1c798
movq 0x1544a(%rip), %rdi     # 0x1c7e0
movslq %ebp, %r15
leaq (,%r15,4), %rsi
callq 0x5ade
movq %rax, 0x15433(%rip)     # 0x1c7e0
movslq 0x11540(%rip), %r12     # 0x188f4
cmpl %r12d, %r15d
jle 0x7410
movq %rax, %r14
movl %ebp, %eax
subl %r12d, %eax
movslq %eax, %rdx
shlq $0x2, %rdx
leaq (%r14,%r12,4), %rdi
xorl %esi, %esi
callq 0x50a0
leaq (%r14,%r12,4), %rax
addq $-0x4, %rax
movq %rax, %rcx
cmpq %r14, %rax
jbe 0x73ec
leaq -0x4(%rcx), %rax
cmpl $0x0, (%rcx)
je 0x73db
leaq 0x110e5(%rip), %rax     # 0x184d8
movl (%rax), %edx
leaq (%rcx,%rdx,4), %rcx
leaq (%r14,%r15,4), %rdx
cmpq %rdx, %rcx
jae 0x7410
movl $0x1, (%rcx)
movl (%rax), %esi
leaq (%rcx,%rsi,4), %rcx
jmp 0x73fd
testb $0x4, 0x153b5(%rip)     # 0x1c7cc
jne 0x742a
movl %ebp, %edi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x769d
movl %ebp, %edi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7438
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: tnewline
void
tnewline(int first_col)
{
	int y = term.c.y;

	if (y == term.bot) {
		tscrollup(term.top, term.bot, 1, SCROLL_SAVEHIST);
	} else {
		y++;
	}
	tmoveto(first_col ? 0 : term.c.x, y);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl 0x12d86(%rip), %ebx     # 0x1c7b4
cmpl 0x12d94(%rip), %ebx     # 0x1c7c8
jne 0x9a4a
movl 0x12d88(%rip), %edi     # 0x1c7c4
pushq $0x1
popq %rcx
movl %ebx, %esi
movl %ecx, %edx
callq 0xa4c2
jmp 0x9a4c
incl %ebx
xorl %edi, %edi
testl %ebp, %ebp
jne 0x9a58
movl 0x12d58(%rip), %edi     # 0x1c7b0
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x85af
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: tclearregion
void
tclearregion(int x1, int y1, int x2, int y2, int usecurattr)
{
	int x, y;

	/* regionselected() takes relative coordinates */
	if (regionselected(x1+term.scr, y1+term.scr, x2+term.scr, y2+term.scr))
		selremove();

	for (y = y1; y <= y2; y++) {
		term.dirty[y] = 1;
		for (x = x1; x <= x2; x++)
			tclearglyph(&term.line[y][x], usecurattr);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r15d
movl %esi, %r14d
movl %edi, %r12d
movl 0x12360(%rip), %ecx     # 0x1c788
leal (%rcx,%r12), %edi
leal (%rcx,%r14), %esi
leal (%rcx,%r15), %edx
addl %ebx, %ecx
callq 0x5fef
testl %eax, %eax
je 0xa44d
andl $0x0, 0xe47a(%rip)      # 0x188c0
orl $-0x1, 0xe48f(%rip)     # 0x188dc
movq 0x12344(%rip), %rax     # 0x1c798
movslq %r12d, %rcx
movslq %r15d, %rdx
movslq %r14d, %rsi
movslq %ebx, %rdi
movq %rcx, %r8
shlq $0x4, %r8
orq $0x8, %r8
cmpq %rdi, %rsi
jg 0xa4b6
movl $0x1, (%rax,%rsi,4)
movq 0xe47a(%rip), %r9       # 0x188f8
movq %r8, %r10
movq %rcx, %r11
cmpq %rdx, %r11
jg 0xa4b1
movq (%r9,%rsi,8), %rbx
movq 0x12314(%rip), %r14     # 0x1c7a8
movq %r14, (%rbx,%r10)
andw $0x0, -0x4(%rbx,%r10)
movl $0x20, -0x8(%rbx,%r10)
incq %r11
addq $0x10, %r10
jmp 0xa484
incq %rsi
jmp 0xa46b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/anachronic[P]st/st.c
// Function: tscrolldown
void
tscrolldown(int top, int n)
{
	int i, bot = term.bot;
	Line temp;

	if (n <= 0)
		return;
	n = MIN(n, bot-top+1);

	tsetdirt(top, bot-n);
	tclearregion(0, bot-n+1, term.col-1, bot, 1);

	for (i = bot; i >= top+n; i--) {
		temp = term.line[i];
		term.line[i] = term.line[i-n];
		term.line[i-n] = temp;
	}

	if (sel.ob.x != -1 && sel.alt == IS_SET(MODE_ALTSCREEN))
		selscroll(top, bot, n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0xa78f
movl %edi, %ebx
movslq 0x120e0(%rip), %r14     # 0x1c7c8
movl %r14d, %eax
subl %edi, %eax
leal 0x1(%rax), %r15d
cmpl %esi, %eax
cmovgel %esi, %r15d
movl %r14d, %ebp
subl %r15d, %ebp
movl %ebp, %esi
callq 0x5ec9
incl %ebp
movl 0xe1e8(%rip), %edx      # 0x188f4
decl %edx
xorl %edi, %edi
movl %ebp, %esi
movl %r14d, %ecx
callq 0xa40f
leal (%r15,%rbx), %eax
cltq
movslq %r15d, %rcx
shlq $0x3, %rcx
negq %rcx
movq %r14, %rdx
cmpq %rax, %rdx
jl 0xa75c
movq 0xe1bf(%rip), %rsi      # 0x188f8
leaq (%rsi,%rdx,8), %rdi
movq (%rsi,%rdx,8), %r8
movq (%rcx,%rdi), %rdi
movq %rdi, (%rsi,%rdx,8)
movq 0xe1a8(%rip), %rsi      # 0x188f8
addq %rcx, %rsi
movq %r8, (%rsi,%rdx,8)
decq %rdx
jmp 0xa72d
cmpl $-0x1, 0xe179(%rip)     # 0x188dc
je 0xa78f
movl 0xe181(%rip), %eax      # 0x188ec
btl $0x2, 0x12059(%rip)     # 0x1c7cc
sbbl $0x0, %eax
jne 0xa78f
movl %ebx, %edi
movl %r14d, %esi
movl %r15d, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xab71
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl 0x11c0a(%rip), %eax     # 0x1c788
addl %eax, %ebp
addl %eax, %ebx
movl 0xdd48(%rip), %eax      # 0x188d0
cmpl %eax, %ebp
setle %cl
cmpl %ebx, %eax
setle %al
andb %cl, %al
movl 0xdd3e(%rip), %ecx      # 0x188d8
cmpl %ecx, %ebp
setg %sil
cmpl %ebx, %ecx
setg %cl
orb %sil, %cl
cmpb %cl, %al
je 0xabce
testb %al, %al
je 0xabc7
movl %edx, %edi
callq 0x6ff5
cmpl %ebp, 0xdd13(%rip)      # 0x188d0
jl 0xabce
cmpl %ebx, 0xdd13(%rip)      # 0x188d8
jg 0xabce
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5d2a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rdi, (%rsp)
movl 0x139b9(%rip), %r15d    # 0x1edf0
leaq 0x13972(%rip), %r14     # 0x1edb0
movq (%r14,%r15,8), %rdi
callq 0x5340
testl %ebp, %ebp
je 0xb468
andq $0x0, (%r14,%r15,8)
leal -0x1(%r15), %eax
andl $0x7, %eax
movl %eax, 0x13993(%rip)     # 0x1edf0
movq (%r14,%rax,8), %rax
testq %rax, %rax
je 0xb486
jmp 0xb48d
testq %rbx, %rbx
je 0xb481
movq %rbx, %rdi
callq 0x5b08
movl 0x13975(%rip), %ecx     # 0x1edf0
movq %rax, (%r14,%rcx,8)
jmp 0xb491
andq $0x0, (%r14,%r15,8)
movq 0x13913(%rip), %rax     # 0x1eda0
movq %rax, (%rsp)
movq 0x137d8(%rip), %rdi     # 0x1ec70
movq %rsp, %rsi
pushq $0x1
popq %rdx
pushq $0x4
popq %rcx
leaq 0x8(%rsp), %r8
callq 0x5430
testl %eax, %eax
jne 0xb4ef
movq 0x137ba(%rip), %rdi     # 0x1ec70
movq 0x137c3(%rip), %rsi     # 0x1ec80
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x53e0
movq 0x1379f(%rip), %rdi     # 0x1ec70
movq 0x137a8(%rip), %rsi     # 0x1ec80
movq 0x137c9(%rip), %rcx     # 0x1eca8
movq %rbx, %rdx
callq 0x5450
movq (%rbx), %rdi
callq 0x5090
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl 0x138ea(%rip), %r15d    # 0x1edf0
leal 0x1(%r15), %ebx
andl $0x7, %ebx
leaq 0x1389c(%rip), %r14     # 0x1edb0
movq (%r14,%rbx,8), %rdi
callq 0x5340
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0xb52d
callq 0x5b08
jmp 0xb52f
xorl %eax, %eax
movq %rax, (%r14,%rbx,8)
movl %ebx, 0x138b7(%rip)     # 0x1edf0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x50(%rdi), %eax
movl 0x54(%rdi), %ecx
leal -0x1(%rcx), %edx
cmpl $0x4, %edx
jae 0xe744
movl %edx, %ecx
leaq 0x2e65(%rip), %rdx      # 0x115a4
movl (%rdx,%rcx,4), %ebp
jmp 0xe755
xorl %ebp, %ebp
cmpl $0x5, %ecx
setne %bpl
negl %ebp
orl $0xffffefff, %ebp       # imm = 0xFFFFEFFF
andl %eax, %ebp
movl %ebp, %eax
andl $0xffff9fef, %eax       # imm = 0xFFFF9FEF
movl %eax, 0x4(%rsp)
andl $0xffff9fee, %ebp       # imm = 0xFFFF9FEE
leaq 0xa061(%rip), %r13      # 0x187d0
xorl %r15d, %r15d
cmpq $0xdf, %r15
ja 0xe7c7
cmpl %ebx, 0x18(%r15,%r13)
jne 0xe7c1
movl 0x4(%r15,%r13), %eax
cmpl 0x54(%r14), %eax
jne 0xe7c1
movl 0x1c(%r15,%r13), %r12d
testl %r12d, %r12d
je 0xe7ae
callq 0x6fe8
cmpl $0x1, %eax
movl $0x0, %eax
sbbl %eax, %eax
orl $0x1, %eax
cmpl %eax, %r12d
jne 0xe7c1
movl (%r15,%r13), %eax
cmpl $-0x1, %eax
je 0xe7d8
cmpl %eax, 0x4(%rsp)
je 0xe7d8
cmpl %eax, %ebp
je 0xe7d8
addq $0x20, %r15
jmp 0xe772
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%r15,%r13), %rdi
addq $0x10, %rdi
callq *-0x8(%rdi)
pushq $0x1
popq %rax
jmp 0xe7c9
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/m8376/m8376.c
// Function: main
int main (int argc, char *argv[])
{
FILE *fi[8], *outf;
char fname[256];
int c, i, j;
unsigned int wd[1024];

for (i = 0; i < 8; i++) {
	sprintf (fname, "C:\\temp\\m8376\\m8376e%03d.bin", fnum[i]);
	fi[i] = fopen (fname, "rb");
	if (fi[i] == NULL) {
	    printf ("Can't open file %s\n", fname);
	    return 0;
	    }
	}

for (i = 0; i < 1024; i++) {
	wd[i] = 0;
	for (j = 7; j >=0; j--) {
	    c = fgetc (fi[j]);
	    if (c == EOF) {
		printf ("Premature end of file on file %d\n", i);
		return 0;
		}
	    wd[i] = (wd[i] << 4) | (c & 0xF);
	    }
	}

for (i = 0; i < 8; i++) fclose (fi[i]);
outf = fopen ("c:\\prom.bin", "wb");
if (outf == NULL) {
	printf ("Can't open output file\n");
	return 0;
	}
fwrite (wd, 1024, sizeof (int), outf);
fclose (outf);
return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1148, %rsp           # imm = 0x1148
leaq 0xecc(%rip), %r12       # 0x2080
leaq 0xe49(%rip), %rbx       # 0x2004
leaq 0x40(%rsp), %r14
leaq 0xe5a(%rip), %r15       # 0x2021
xorl %r13d, %r13d
cmpq $0x20, %r13
je 0x120f
movl (%r13,%r12), %edx
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
movq %r14, %rdi
movq %r15, %rsi
callq 0x1070
movq %rax, (%rsp,%r13,2)
addq $0x4, %r13
testq %rax, %rax
jne 0x11ca
leaq 0xe23(%rip), %rdi       # 0x2024
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
callq 0x1050
jmp 0x126d
xorl %ebx, %ebx
pushq $0x7
popq %rbp
cmpq $0x400, %rbx            # imm = 0x400
je 0x1281
andl $0x0, 0x140(%rsp,%rbx,4)
xorl %r14d, %r14d
movl %ebp, %r15d
testl %r15d, %r15d
js 0x1258
movl %r15d, %eax
movq (%rsp,%rax,8), %rdi
callq 0x1060
cmpl $-0x1, %eax
je 0x125d
shll $0x4, %r14d
andl $0xf, %eax
orl %eax, %r14d
movl %r14d, 0x140(%rsp,%rbx,4)
decl %r15d
jmp 0x122b
incq %rbx
jmp 0x1214
leaq 0xdd4(%rip), %rdi       # 0x2038
movl %ebx, %esi
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x1148, %rsp           # imm = 0x1148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
cmpq $0x8, %rbx
je 0x1297
movq (%rsp,%rbx,8), %rdi
callq 0x1040
incq %rbx
jmp 0x1283
leaq 0xdbc(%rip), %rdi       # 0x205a
leaq 0xdc1(%rip), %rsi       # 0x2066
callq 0x1070
testq %rax, %rax
je 0x12d4
movq %rax, %rbx
leaq 0x140(%rsp), %rdi
pushq $0x4
popq %rdx
movl $0x400, %esi            # imm = 0x400
movq %rax, %rcx
callq 0x1090
movq %rbx, %rdi
callq 0x1040
jmp 0x126d
leaq 0xd8e(%rip), %rdi       # 0x2069
callq 0x1030
jmp 0x126d
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2dc8(%rip), %rcx      # 0x4078
andl $0x0, (%rcx)
leaq -0x8(%rsp), %rsi
xorl %r10d, %r10d
movq 0x2da6(%rip), %rdi      # 0x4068
leaq 0x2db7(%rip), %r8       # 0x4080
movabsq $0x18, %r9
leaq 0x2db6(%rip), %r11      # 0x4090
movq %rsi, -0x8(%rsp)
cmpq %rdi, %rsi
jae 0x1335
movq (%rsi), %rbx
movq %r8, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x132f
movq 0x8(%r14), %rdx
cmpq %rbx, %rdx
seta %al
leaq 0xc0000(%rdx), %r15
cmpq %rbx, %r15
setb %bpl
orb %al, %bpl
jne 0x12ea
movq %rbx, %rax
subq %rdx, %rax
xorl %edx, %edx
divq %r9
cmpl $0x8, %edx
jne 0x12ea
movslq %r10d, %rax
leal 0x1(%r10), %edx
movl %edx, (%rcx)
movq %rsi, (%r11,%rax,8)
movl %edx, %r10d
addq $0x8, %rsi
jmp 0x12da
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
andw $0x0, (%rdi)
andl $0x0, 0x4(%rdi)
pushq $-0x14
popq %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0x4d27
movb %cl, 0x1c(%rdi,%rax)
movb %cl, 0x30(%rdi,%rax)
incq %rax
jmp 0x4d15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x5299(%rip), %r14      # 0x9fd0
leaq 0x15f9(%rip), %rsi      # 0x6337
movq %r14, %rdi
callq 0x2170
movzwl (%rbx), %esi
movq %rax, %rdi
callq 0x2260
movq %rax, %rdi
callq 0x20e0
leaq 0x15e2(%rip), %rsi      # 0x6342
movq %r14, %rdi
callq 0x2170
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2280
movq %rax, %rdi
callq 0x20e0
leaq 0x15c9(%rip), %rsi      # 0x634b
movq %r14, %rdi
callq 0x2170
leaq 0x1c(%rbx), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20e0
leaq 0x15b3(%rip), %rsi      # 0x6358
movq %r14, %rdi
callq 0x2170
pushq $0x8
popq %r15
leaq 0x15a7(%rip), %r14      # 0x635f
cmpq $0x1c, %r15
je 0x4dd2
movzbl (%rbx,%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
incq %r15
jmp 0x4db8
movq 0x51f7(%rip), %rdi      # 0x9fd0
popq %rbx
popq %r14
popq %r15
jmp 0x20e0
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x2
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rbx, %rcx
callq 0x22b0
leaq 0x4(%r14), %rdi
pushq $0x4
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x22b0
leaq 0x8(%r14), %rdi
pushq $0x14
popq %r12
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x22b0
addq $0x1c, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22b0
// File: /workspace/github_c_makefile_star2_O2/FirestonnneTFM[P]tfm_key_parser/src/main_sniffer.cpp
// Function: executer::get_lex_int()
int32_t executer::get_lex_int() {
	uint32_t index, arg_count;
	*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_callproperty);
	*this >> index;
	*this >> arg_count;
	assert(arg_count == 0);
	traits_info *tm = c->get_trait_by_name(abc_file::get_multiname(index));
	method_info *m = abc_file::get_method(tm->vindex);
	executer exec(m);
	assert(exec.step() == OP_getlocal_0);
	assert(exec.step() == OP_pushscope);
	int32_t a = exec.get_push();
	int32_t b = exec.get_push();
	assert(exec.step() == OP_add);
	assert(exec.step() == OP_returnvalue);
	return a + b;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x305c
movl (%r14), %edi
callq 0x2d54
movq 0x8(%rax), %rax
cmpb $0x0, (%rax)
jne 0x4f5e
movl 0xc(%rsp), %edi
callq 0x2dc2
movq %rax, %r14
movq %rax, %rdi
callq 0x36a4
movq %rbx, %rdi
callq 0x3006
cmpb $0x46, %al
jne 0x4f80
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x305c
leaq 0x24(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x305c
cmpl $0x0, (%r15)
jne 0x4f90
movl 0xc(%rsp), %edi
callq 0x2d54
movq %r14, %rdi
movq %rax, %rsi
callq 0x3968
movl 0xc(%rax), %edi
callq 0x2d94
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5bfe
movq %rbx, %rdi
callq 0x2770
cmpb $-0x30, %al
jne 0x4fa0
leaq 0x10(%rsp), %rdi
callq 0x2770
cmpb $0x30, %al
jne 0x4fb0
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x28fc
movl %eax, %ebx
movq %r14, %rdi
callq 0x28fc
movl %eax, %ebp
movq %r14, %rdi
callq 0x2770
cmpb $-0x60, %al
jne 0x4fc0
leaq 0x10(%rsp), %rdi
callq 0x2770
cmpb $0x48, %al
jne 0x4fd0
addl %ebx, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x3c, (%rax)
leaq 0x1410(%rip), %rcx      # 0x6383
movq %rcx, 0x8(%rax)
leaq 0x13e7(%rip), %rcx      # 0x6365
jmp 0x4ff0
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x3f, (%rax)
jmp 0x4fde
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x42, (%rax)
jmp 0x4fde
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x46, (%rax)
jmp 0x4fde
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x47, (%rax)
jmp 0x4fde
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x4a, (%rax)
jmp 0x4fde
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x4b, (%rax)
leaq 0x139e(%rip), %rcx      # 0x6383
movq %rcx, 0x8(%rax)
leaq 0x13a8(%rip), %rcx      # 0x6398
movq %rcx, 0x10(%rax)
leaq 0x4d95(%rip), %rsi      # 0x9d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x2270
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x305c
movl (%r14), %edi
callq 0x2d54
movq 0x8(%rax), %rax
cmpb $0x0, (%rax)
jne 0x508a
movl 0xc(%rsp), %edi
callq 0x2dc2
movq %rax, %r14
movq %rax, %rdi
callq 0x36a4
movq %rbx, %rdi
callq 0x3006
cmpb $0x66, %al
jne 0x50ac
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x305c
movl (%r15), %edi
callq 0x2d54
movq %r14, %rdi
movq %rax, %rsi
callq 0x3968
cmpb $0x0, 0x10(%rax)
je 0x50ce
cmpl $0x0, 0x14(%rax)
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x53, (%rax)
leaq 0x12e4(%rip), %rcx      # 0x6383
movq %rcx, 0x8(%rax)
leaq 0x12bb(%rip), %rcx      # 0x6365
jmp 0x50ee
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x56, (%rax)
leaq 0x12c2(%rip), %rcx      # 0x6383
movq %rcx, 0x8(%rax)
leaq 0x12cc(%rip), %rcx      # 0x6398
jmp 0x50ee
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x5a, (%rax)
leaq 0x12a0(%rip), %rcx      # 0x6383
movq %rcx, 0x8(%rax)
leaq 0x12b8(%rip), %rcx      # 0x63a6
movq %rcx, 0x10(%rax)
leaq 0x4c97(%rip), %rsi      # 0x9d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x2270
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x305c
movl (%r14), %edi
callq 0x2d54
movq 0x8(%rax), %rax
xorl %edi, %edi
cmpb $0x0, (%rax)
jne 0x5176
movl 0xc(%rsp), %edi
callq 0x2dc2
movq %rax, %r14
movq %rax, %rdi
callq 0x36a4
movq %rbx, %rdi
callq 0x3006
cmpb $0x66, %al
jne 0x5185
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x305c
movl (%r15), %edi
callq 0x2d54
movq %r14, %rdi
movq %rax, %rsi
callq 0x3968
movl 0xc(%rax), %edi
callq 0x2d08
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x18
popq %rdi
callq 0x20f0
movl $0x65, (%rax)
leaq 0x11e9(%rip), %rcx      # 0x6383
movq %rcx, 0x8(%rax)
leaq 0x11f3(%rip), %rcx      # 0x6398
movq %rcx, 0x10(%rax)
leaq 0x4be0(%rip), %rsi      # 0x9d90
movq %rax, %rdi
xorl %edx, %edx
callq 0x2270
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc(%rsp), %rdi
callq 0x1b14
leaq 0xd88(%rip), %r14       # 0x2004
movq 0x2d4d(%rip), %r15      # 0x3fd0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1120
cmpl $0x64, %eax
je 0x12bb
cmpl $0x6c, %eax
je 0x12ad
cmpl $0x74, %eax
jne 0x12c9
movq (%r15), %rdi
callq 0x1130
movl %eax, 0x14(%rsp)
jmp 0x1283
movq (%r15), %rdi
callq 0x1130
movl %eax, 0x10(%rsp)
jmp 0x1283
movq (%r15), %rdi
callq 0x1130
movl %eax, 0xc(%rsp)
jmp 0x1283
cmpl $-0x1, %eax
jne 0x1334
movq 0x2cf3(%rip), %r15      # 0x3fc8
movslq (%r15), %rax
addl $-0x2, %ebp
cmpl %ebp, %eax
jne 0x1320
movq (%rbx,%rax,8), %rsi
leaq 0x18(%rsp), %rdi
callq 0x18e8
testl %eax, %eax
js 0x1330
leaq 0x30(%rsp), %r14
leaq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x1b29
movslq (%r15), %rax
movq 0x8(%rbx,%rax,8), %rdi
movq %r14, %rsi
callq 0x19ea
sarl $0x1f, %eax
andl $0x5, %eax
jmp 0x1382
leaq 0xd29(%rip), %rdi       # 0x2050
callq 0x1060
pushq $0x3
jmp 0x1381
pushq $0x4
jmp 0x1381
cmpl $0x3a, %eax
jne 0x135e
movq 0x2cb8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2c96(%rip), %rax      # 0x3fe0
movl (%rax), %edx
leaq 0xcb9(%rip), %rsi       # 0x200c
xorl %eax, %eax
callq 0x10d0
pushq $0x2
jmp 0x1381
movq 0x2c93(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2c71(%rip), %rax      # 0x3fe0
movl (%rax), %edx
leaq 0xcb4(%rip), %rsi       # 0x202c
xorl %eax, %eax
callq 0x10d0
pushq $0x1
popq %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1302
callq 0x1890
cmpl $0x2, %ebp
je 0x132b
movq 0x2cea(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xcec(%rip), %rdi       # 0x2004
pushq $0x1e
popq %rsi
pushq $0x1
popq %rdx
callq 0x11b0
pushq $0x1
popq %rdi
callq 0x11a0
movq 0x8(%rbx), %r14
callq 0x10a0
movslq %eax, %rsi
leaq 0xce5(%rip), %rdi       # 0x2023
xorl %eax, %eax
callq 0x1a9c
callq 0x1060
movq %rax, %rbx
andl $0x0, (%rax)
movq %r14, %rdi
callq 0x137c
testl %eax, %eax
jne 0x1323
callq 0x10a0
movslq %eax, %rsi
leaq 0xcd3(%rip), %rdi       # 0x203e
xorl %eax, %eax
callq 0x1a9c
andl $0x0, (%rbx)
xorl %edi, %edi
callq 0x11a0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0x40bdc0
pushq $0x2f
popq %rsi
movq %r14, %rdi
callq 0x401058
subl %r14d, %eax
movslq %eax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x401090
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x2e
popq %rsi
callq 0x401058
subl %r14d, %eax
movslq %eax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x401090
movb $0x0, (%rbx,%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rsi
callq 0x4017ed
movq %rbx, %rdi
movq %r15, %rsi
callq 0x401020
movq %rbx, %rdi
callq 0x4010e8
movabsq $0x656b2e637369642f, %rcx # imm = 0x656B2E637369642F
movq %rcx, (%rbx,%rax)
movw $0x79, 0x8(%rbx,%rax)
movq %rbx, %rdi
callq 0x4017d9
testl %eax, %eax
jne 0x40190a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x401020
leaq 0x1000(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x40182c
movq %rbx, %rdi
callq 0x4010e8
movw $0x2f, (%rbx,%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x401060
movq %rbx, %rdi
callq 0x4010e8
movl $0x79656b2e, (%rbx,%rax) # imm = 0x79656B2E
movb $0x0, 0x4(%rbx,%rax)
movq %rbx, %rdi
callq 0x4017d9
testl %eax, %eax
jne 0x40190a
movb $0x0, 0x5(%rbx)
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x20, %rsp
movups 0x12591(%rip), %xmm0    # 0x158ec
movups %xmm0, -0x14(%rbp)
movaps 0x1257a(%rip), %xmm0    # 0x158e0
movaps %xmm0, -0x20(%rbp)
movl (%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33de
addl $0xfffffc19, %eax       # imm = 0xFFFFFC19
movl %eax, (%rdi)
movl 0x4(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33de
addl $0xfffffc19, %eax       # imm = 0xFFFFFC19
movl %eax, 0x4(%rdi)
movl 0x8(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33de
addl $0xfffffc19, %eax       # imm = 0xFFFFFC19
movl %eax, 0x8(%rdi)
movl 0xc(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
cmpl $0x3e7, %eax            # imm = 0x3E7
jl 0x33de
movl 0x10(%rdi), %eax
leal -0x3e7(%rax), %ecx
movl %ecx, 0x10(%rdi)
cmpl $0x7cf, %eax            # imm = 0x7CF
jl 0x33de
leaq -0x20(%rbp), %rdi
pushq $-0x8
popq %rsi
callq 0x33e4
addq $0x20, %rsp
popq %rbp
retq