LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/odknt[P]st/x.c
// Function: bpress
void
bpress(XEvent *e)
{
	int btn = e->xbutton.button;
	struct timespec now;
	int snap;

	if (1 <= btn && btn <= 11)
		buttons |= 1 << (btn-1);

	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
		mousereport(e);
		return;
	}

	if (mouseaction(e, 0))
		return;

	if (btn == Button1) {
		/*
		 * If the user clicks below predefined timeouts specific
		 * snapping behaviour is exposed.
		 */
		clock_gettime(CLOCK_MONOTONIC, &now);
		if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) {
			snap = SNAP_LINE;
		} else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) {
			snap = SNAP_WORD;
		} else {
			snap = 0;
		}
		xsel.tclick2 = xsel.tclick1;
		xsel.tclick1 = now;

		selstart(evcol(e), evrow(e), snap);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x54(%rdi), %r14d
leal -0x1(%r14), %ecx
cmpl $0xa, %ecx
ja 0xf122
movl $0x1, %eax
shll %cl, %eax
orl %eax, 0xf8d6(%rip)      # 0x1e9f8
movzwl 0xf81b(%rip), %eax      # 0x1e944
testl $0xc018, %eax           # imm = 0xC018
je 0xf145
testb $0x1, 0x50(%rbx)
jne 0xf145
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xf9e1
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfbb9
cmpl $0x1, %r14d
jne 0xf26d
testl %eax, %eax
jne 0xf26d
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x6140
movq (%r14), %rdx
movq 0x8(%r14), %rax
movq %rdx, %rcx
subq 0xf83c(%rip), %rcx      # 0x1e9c0
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
cvtsi2sd %rcx, %xmm0
movq %rax, %rcx
subq 0xf82e(%rip), %rcx      # 0x1e9c8
cvtsi2sd %rcx, %xmm1
divsd 0x1ac1(%rip), %xmm1     # 0x10c68
addsd %xmm0, %xmm1
movl $0x2, %ecx
movsd 0x1ad8(%rip), %xmm0     # 0x10c90
ucomisd %xmm1, %xmm0
jae 0xf200
subq 0xf7eb(%rip), %rdx      # 0x1e9b0
imulq $0x3e8, %rdx, %rcx      # imm = 0x3E8
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
subq 0xf7dd(%rip), %rax      # 0x1e9b8
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd 0x1a7d(%rip), %xmm1     # 0x10c68
addsd %xmm0, %xmm1
movsd 0x1aa1(%rip), %xmm0     # 0x10c98
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
setae %cl
movups 0xf7a9(%rip), %xmm0     # 0x1e9b0
movups %xmm0, 0xf7b2(%rip)     # 0x1e9c0
movups 0x8(%rsp), %xmm0
movups %xmm0, 0xf796(%rip)     # 0x1e9b0
movl 0x40(%rbx), %edx
movl 0x8be8(%rip), %r8d      # 0x17e0c
xorl %esi, %esi
subl %r8d, %edx
movl $0x0, %eax
js 0xf23d
movl 0xf6f2(%rip), %eax      # 0x1e928
decl %eax
cmpl %eax, %edx
cmovll %edx, %eax
cltd
idivl 0xf6f8(%rip)            # 0x1e93c
movl %eax, %edi
movl 0x44(%rbx), %eax
subl %r8d, %eax
js 0xf25b
movl 0xf6d8(%rip), %esi      # 0x1e92c
decl %esi
cmpl %esi, %eax
cmovll %eax, %esi
movl %esi, %eax
cltd
idivl 0xf6d4(%rip)            # 0x1e938
movl %eax, %esi
movl %ecx, %edx
callq 0x7248
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/odknt[P]st/x.c
// Function: brelease
void
brelease(XEvent *e)
{
	int btn = e->xbutton.button;

	if (1 <= btn && btn <= 11)
		buttons &= ~(1 << (btn-1));

	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
		mousereport(e);
		return;
	}

	if (mouseaction(e, 1))
		return;
	if (btn == Button1)
		mousesel(e, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x54(%rdi), %r14d
leal -0x1(%r14), %ecx
cmpl $0xa, %ecx
ja 0xf296
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
roll %cl, %eax
andl %eax, 0xf762(%rip)      # 0x1e9f8
movzwl 0xf6a7(%rip), %eax      # 0x1e944
testl $0xc018, %eax           # imm = 0xC018
je 0xf2b9
testb $0x1, 0x50(%rbx)
jne 0xf2b9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf9e1
movq %rbx, %rdi
movl $0x1, %esi
callq 0xfbb9
cmpl $0x1, %r14d
jne 0xf2e4
testl %eax, %eax
jne 0xf2e4
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfc6e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/odknt[P]st/x.c
// Function: focus
void
focus(XEvent *ev)
{
	XFocusChangeEvent *e = &ev->xfocus;

	if (e->mode == NotifyGrab)
		return;

	if (ev->type == FocusIn) {
		if (xw.ime.xic)
			XSetICFocus(xw.ime.xic);
		win.mode |= MODE_FOCUSED;
		xseturgency(0);
		if (IS_SET(MODE_FOCUS))
			ttywrite("\033[I", 3, 0);
	} else {
		if (xw.ime.xic)
			XUnsetICFocus(xw.ime.xic);
		win.mode &= ~MODE_FOCUSED;
		if (IS_SET(MODE_FOCUS))
			ttywrite("\033[O", 3, 0);
	}
}

// Assembly:
pushq %rax
cmpl $0x1, 0x28(%rdi)
jne 0xf315
popq %rax
retq
cmpl $0x9, (%rdi)
movq 0xf539(%rip), %rdi      # 0x1e858
jne 0xf34b
testq %rdi, %rdi
je 0xf32b
callq 0x6760
orb $0x2, 0xf612(%rip)      # 0x1e944
xorl %edi, %edi
callq 0xd2aa
testb $0x20, 0xf605(%rip)     # 0x1e945
je 0xf313
leaq 0x2366(%rip), %rdi      # 0x116af
jmp 0xf373
testq %rdi, %rdi
je 0xf355
callq 0x6490
movl 0xf5e9(%rip), %eax      # 0x1e944
movl %eax, %ecx
andl $-0x3, %ecx
movl %ecx, 0xf5de(%rip)      # 0x1e944
btl $0xd, %eax
jae 0xf313
leaq 0x2340(%rip), %rdi      # 0x116b3
movl $0x3, %esi
xorl %edx, %edx
popq %rax
jmp 0x8045
// File: /workspace/github_c_makefile_star2_O1/odknt[P]st/x.c
// Function: propnotify
void
propnotify(XEvent *e)
{
	XPropertyEvent *xpev;
	Atom clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);

	xpev = &e->xproperty;
	if (xpev->state == PropertyNewValue &&
			(xpev->atom == XA_PRIMARY ||
			 xpev->atom == clipboard)) {
		selnotify(e);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xf42b(%rip), %rdi      # 0x1e800
leaq 0x1bc5(%rip), %rsi      # 0x10fa1
xorl %edx, %edx
callq 0x6870
cmpl $0x0, 0x38(%rbx)
jne 0xf3f8
movq 0x28(%rbx), %rcx
cmpq $0x1, %rcx
je 0xf3fa
cmpq %rax, %rcx
je 0xf3fa
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0xf593
// File: /workspace/github_c_makefile_star2_O1/odknt[P]st/x.c
// Function: cmessage
void
cmessage(XEvent *e)
{
	/*
	 * See xembed specs
	 *  http://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html
	 */
	if (e->xclient.message_type == xw.xembed && e->xclient.format == 32) {
		if (e->xclient.data.l[1] == XEMBED_FOCUS_IN) {
			win.mode |= MODE_FOCUSED;
			xseturgency(0);
		} else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) {
			win.mode &= ~MODE_FOCUSED;
		}
	} else if (e->xclient.data.l[0] == xw.wmdeletewin) {
		ttyhangup();
		exit(0);
	}
}

// Assembly:
movq 0x28(%rdi), %rax
cmpq 0xf032(%rip), %rax      # 0x1e828
jne 0xf81c
cmpl $0x20, 0x30(%rdi)
jne 0xf81c
movq 0x40(%rdi), %rax
cmpq $0x5, %rax
je 0xf82a
cmpq $0x4, %rax
jne 0xf829
orb $0x2, 0xf12f(%rip)      # 0x1e944
xorl %edi, %edi
jmp 0xd2aa
movq 0x38(%rdi), %rax
cmpq 0xf009(%rip), %rax      # 0x1e830
je 0xf832
retq
andb $-0x3, 0xf113(%rip)     # 0x1e944
retq
pushq %rax
callq 0x8378
xorl %edi, %edi
callq 0x61b0
// File: /workspace/github_c_makefile_star2_O1/odknt[P]st/x.c
// Function: clippaste
void
clippaste(const Arg *dummy)
{
	Atom clipboard;

	clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);
	XConvertSelection(xw.dpy, clipboard, xsel.xtarget, clipboard,
			xw.win, CurrentTime);
}

// Assembly:
pushq %rax
movq 0xef72(%rip), %rdi      # 0x1e800
leaq 0x170c(%rip), %rsi      # 0x10fa1
xorl %edx, %edx
callq 0x6870
movq 0xef5d(%rip), %rdi      # 0x1e800
movq 0xf0ee(%rip), %rdx      # 0x1e998
movq 0xef5f(%rip), %r8       # 0x1e810
movq %rax, %rsi
movq %rax, %rcx
xorl %r9d, %r9d
popq %rax
jmp 0x61f0
// File: /workspace/github_c_makefile_star2_O1/odknt[P]st/x.c
// Function: zoomabs
void
zoomabs(const Arg *arg)
{
	xunloadfonts();
	xloadfonts(usedfont, arg->f);
	cresize(0, 0);
	redraw();
	xhints();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xf91c
movq 0xf0e1(%rip), %rdi      # 0x1e9e0
cvtss2sd (%rbx), %xmm0
callq 0xe32f
xorl %edi, %edi
xorl %esi, %esi
callq 0xed85
callq 0x937a
popq %rbx
jmp 0xe90a
// File: /workspace/github_c_makefile_star2_O1/odknt[P]st/x.c
// Function: xunloadfonts
void
xunloadfonts(void)
{
	/* Free the loaded fonts in the font cache.  */
	while (frclen > 0)
		xunloadmatchfont(frc[--frclen].font);

	xunloadfont(&dc.font);
	xunloadfont(&dc.bfont);
	xunloadfont(&dc.ifont);
	xunloadfont(&dc.ibfont);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0xefe2(%rip), %eax      # 0x1e908
testl %eax, %eax
jle 0xf962
movq 0xefdf(%rip), %rcx      # 0x1e910
decl %eax
movl %eax, 0xefcf(%rip)      # 0x1e908
shlq $0x5, %rax
movq (%rcx,%rax), %rdi
movq 0x8(%rcx,%rax), %rbx
movq 0x10(%rcx,%rax), %r14
callq 0x6980
movq %rbx, %rdi
callq 0x67f0
movq %r14, %rdi
callq 0x6050
jmp 0xf920
leaq 0xed6f(%rip), %rdi      # 0x1e6d8
callq 0xf996
leaq 0xedab(%rip), %rdi      # 0x1e720
callq 0xf996
leaq 0xede7(%rip), %rdi      # 0x1e768
callq 0xf996
leaq 0xee23(%rip), %rdi      # 0x1e7b0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf996
// File: /workspace/github_c_makefile_star2_O1/odknt[P]st/x.c
// Function: xunloadfont
void
xunloadfont(Font *f)
{
	xunloadmatchfont(f->match);
	FcPatternDestroy(f->pattern);
	if (f->set)
		FcFontSetDestroy(f->set);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq 0x28(%rbx), %r14
movq 0x30(%rbx), %r15
callq 0x6980
movq %r14, %rdi
callq 0x67f0
movq %r15, %rdi
callq 0x6050
movq 0x40(%rbx), %rdi
callq 0x6050
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xf9db
popq %rbx
popq %r14
popq %r15
jmp 0x6600
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/odknt[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 &&
		    (match(ms->mod, state) ||  /* exact or forced */
		     match(ms->mod, state & ~forcemousemod))) {
			ms->func(&(ms->arg));
			return 1;
		}
	}

	return 0;
}

// Assembly:
movl 0x50(%rdi), %edx
movl 0x54(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
jae 0xfbd5
movl %ecx, %ecx
leaq 0x1120(%rip), %rdi      # 0x10cf0
movl (%rdi,%rcx,4), %ecx
jmp 0xfbe5
xorl %ecx, %ecx
cmpl $0x5, %eax
setne %cl
negl %ecx
orl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
andl %edx, %ecx
movl %ecx, %edx
andl $0xffff9fef, %edx       # imm = 0xFFFF9FEF
andl $0xffff9fee, %ecx       # imm = 0xFFFF9FEE
movq $-0x20, %rdi
leaq 0x876d(%rip), %r8       # 0x18370
cmpl %esi, 0x38(%rdi,%r8)
jne 0xfc2c
cmpl %eax, 0x24(%rdi,%r8)
jne 0xfc2c
movl 0x20(%rdi,%r8), %r9d
cmpl $-0x1, %r9d
je 0xfc3c
cmpl %r9d, %edx
je 0xfc3c
cmpl $-0x1, %r9d
je 0xfc3c
cmpl %r9d, %ecx
je 0xfc3c
addq $0x20, %rdi
cmpq $0x80, %rdi
jb 0xfc03
xorl %eax, %eax
retq
pushq %rax
addq %r8, %rdi
addq $0x30, %rdi
callq *-0x8(%rdi)
movl $0x1, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/odknt[P]st/x.c
// Function: mousesel
void
mousesel(XEvent *e, int done)
{
	int type, seltype = SEL_REGULAR;
	uint state = e->xbutton.state & ~(Button1Mask | forcemousemod);

	for (type = 1; type < LEN(selmasks); ++type) {
		if (match(selmasks[type], state)) {
			seltype = type;
			break;
		}
	}
	selextend(evcol(e), evrow(e), seltype, done);
	if (done)
		setsel(getsel(), e->xbutton.time);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0xffff9eee, %eax       # imm = 0xFFFF9EEE
andl 0x50(%rdi), %eax
movl $0x1, %ecx
leaq 0xfa6(%rip), %rdx       # 0x10c30
cmpl (%rdx,%rcx,4), %eax
je 0xfc9d
incq %rcx
cmpq $0x3, %rcx
jne 0xfc8a
movl $0x1, %ecx
movl 0x40(%rbx), %edx
movl 0x8165(%rip), %r8d      # 0x17e0c
xorl %esi, %esi
subl %r8d, %edx
movl $0x0, %eax
js 0xfcc0
movl 0xec6f(%rip), %eax      # 0x1e928
decl %eax
cmpl %eax, %edx
cmovll %edx, %eax
cltd
idivl 0xec75(%rip)            # 0x1e93c
movl %eax, %edi
movl 0x44(%rbx), %eax
subl %r8d, %eax
js 0xfcde
movl 0xec55(%rip), %esi      # 0x1e92c
decl %esi
cmpl %esi, %eax
cmovll %eax, %esi
movl %esi, %eax
cltd
idivl 0xec51(%rip)            # 0x1e938
movl %eax, %esi
movl %ecx, %edx
movl %ebp, %ecx
callq 0x746b
testl %ebp, %ebp
je 0xfd0d
callq 0x7604
movq 0x38(%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbbfe
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/utils/rra/rradata.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    int i,amp;
    char *input;
    FILE *in;
    RRA *h;

    argIndex = processOptions(argc,argv);

    input = 0;
    if (argc-argIndex == 0)
        {
        in = 0;
        }
    else if (argc-argIndex == 1)
        {
        input = argv[argIndex];
        }
    else
        {
        printf("usage: rradata [<input rra file> [<output wave file>]]\n");
        exit(-1);
        }

    if (input != 0)
        in = OpenFile(input,"r");

    h = newRRAHeader();

    readRRAHeader(in,h,0);

    for (i = 0; !feof(in) && i < h->samples * h->channels; ++i)
        {
        amp = readRRAAmplitude(in,stdout,h->bitsPerSample,outputComment);
        printf("%d\n",amp);
        }

    fclose(in);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %r12d
cmpl $0x2, %edi
jl 0x15e3
movl %r14d, %r13d
movl $0x1, %r12d
leaq 0x1a65(%rip), %r15      # 0x3020
movq (%rbx,%r12,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x15e3
cmpb $0x76, 0x1(%rsi)
je 0x16a4
movq %r15, %rdi
xorl %eax, %eax
callq 0x16e0
incq %r12
cmpq %r12, %r13
jne 0x15bb
movl %r13d, %r12d
subl %r12d, %r14d
jne 0x15ec
xorl %edi, %edi
jmp 0x15fd
cmpl $0x1, %r14d
jne 0x16c7
movslq %r12d, %rax
movq (%rbx,%rax,8), %rdi
testq %rdi, %rdi
je 0x1613
leaq 0x1f04(%rip), %rsi      # 0x350d
callq 0x177a
movq %rax, %rbx
jmp 0x1615
xorl %ebx, %ebx
callq 0x19f7
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1e04
movq %rbx, %rdi
callq 0x1160
testl %eax, %eax
jne 0x168b
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
leaq 0x14de(%rip), %r15      # 0x2b21
leaq 0x1b63(%rip), %r12      # 0x31ad
movl (%r14), %eax
imull 0xc(%r14), %eax
incl %r13d
cmpl %eax, %r13d
jge 0x168b
movq 0x4977(%rip), %rax      # 0x5fd8
movq (%rax), %rsi
movl 0x8(%r14), %edx
movq %rbx, %rdi
movq %r15, %rcx
callq 0x22f0
movq %r12, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x10b0
movq %rbx, %rdi
callq 0x1160
testl %eax, %eax
je 0x164a
movq %rbx, %rdi
callq 0x1090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4a8d(%rip), %rsi      # 0x6138
movq 0x4a8e(%rip), %rdx      # 0x6140
leaq 0x1958(%rip), %rdi      # 0x3011
xorl %eax, %eax
callq 0x10b0
xorl %edi, %edi
callq 0x1200
leaq 0x196c(%rip), %rdi      # 0x303a
callq 0x1070
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1200
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/util.c
// Function: OpenFile
FILE *
OpenFile(const char *fileName, const char *mode)
{
    FILE *fp;

    if ((fp = fopen(fileName, mode)) == 0)
	{
	char *s;
	switch (*mode)
	   {
	   case 'w':
	       s = "writing";
	       break;
	   case 'r':
	       s = "reading";
	       break;
	   case 'a':
	       s = "appending";
	       break;
	   default:
	       s = 0;
	       break;
	   }
	if (s)
	    Fatal("file %s could not be opened for %s\n", fileName, s);
	else
	    Fatal("file %s could not be opened mode %s\n", fileName, mode);
	}

    return fp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x11c0
testq %rax, %rax
je 0x1796
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movzbl (%r14), %eax
cmpl $0x61, %eax
je 0x17bd
cmpl $0x77, %eax
je 0x17b2
cmpl $0x72, %eax
jne 0x17c8
leaq 0x18e0(%rip), %rdx      # 0x3090
jmp 0x17c4
xorl %eax, %eax
leaq 0x18cd(%rip), %rdx      # 0x3088
jmp 0x17cc
leaq 0x18d4(%rip), %rdx      # 0x3098
xorl %eax, %eax
jmp 0x17cc
movb $0x1, %al
xorl %edx, %edx
testb %al, %al
je 0x17df
leaq 0x18ef(%rip), %rdi      # 0x30c6
movq %rbx, %rsi
movq %r14, %rdx
jmp 0x17e9
leaq 0x18bc(%rip), %rdi      # 0x30a2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x16e0
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/util.c
// Function: New
void *
New(int size)
    {
    void *p = malloc(size);
    if (p == 0)
        Fatal("New: out of memory: requested allocation of %d bytes\n",size);

    return p;
    }

// Assembly:
pushq %rbx
movl %edi, %ebx
movslq %edi, %rdi
callq 0x1180
testq %rax, %rax
je 0x181f
popq %rbx
retq
leaq 0x18c7(%rip), %rdi      # 0x30ed
movl %ebx, %esi
xorl %eax, %eax
callq 0x16e0
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/util.c
// Function: ReNew
void *
ReNew(void *q, int size)
    {
    void *p = realloc(q,size);
    if (size > 0 && p == 0)
        Fatal("ReNew: out of memory: requested allocation of %d bytes\n",size);

    return p;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq %esi, %r14
movq %r14, %rsi
callq 0x11b0
testl %r14d, %r14d
setle %cl
testq %rax, %rax
setne %dl
orb %cl, %dl
je 0x18b9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x182b(%rip), %rdi      # 0x30eb
movl %ebx, %esi
xorl %eax, %eax
callq 0x16e0
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: newRRA
RRA *
newRRA(int sr,int bps,int channels,int size)
    {
    RRA *w = (RRA *) New(sizeof(RRA));

    w->sampleRate = sr;
    w->bitsPerSample = bps;
    w->channels = channels;
    w->skip = 0;
    w->samples = size;
    w->items = 0;
    w->extra1 = 0;
    w->extra2 = 0;

    createRRAData(w);

    return w;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movl $0x40, %edi
callq 0x180d
movq %rax, %r12
movl %r15d, 0x4(%rax)
movl %r14d, 0x8(%rax)
movl %ebp, (%rax)
movl $0x0, 0x10(%rax)
movl %ebx, 0xc(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
movq %rax, %rdi
callq 0x19ae
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: createRRAData
void
createRRAData(RRA *h)
    {
    int i;

    if (h->samples == 0) return;

    //printf("creating space for %d samples\n",h->samples * h->channels);
    //printf("size of int: %d\n",sizeof(int));
    //printf("size of int * samples: %d\n",h->samples * sizeof(int));
    h->data = (int **) New(sizeof(int *) * h->channels);

    for (i = 0; i < h->channels; ++i)
        h->data[i] = (int *) New(sizeof(int) * h->samples);
    }

// Assembly:
cmpl $0x0, 0xc(%rdi)
je 0x19f6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
shll $0x3, %edi
callq 0x180d
movq %rax, 0x18(%rbx)
cmpl $0x0, (%rbx)
jle 0x19ef
xorl %r14d, %r14d
movl 0xc(%rbx), %edi
shll $0x2, %edi
callq 0x180d
movq 0x18(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x19d1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: clearRRAData
void
clearRRAData(RRA *h)
    {
    int i,j;

    if (h->samples == 0) return;

    for (i = 0; i < h->channels; ++i)
        for (j = 0; j < h->samples; ++j)
            h->data[i][j] = 0;
    }

// Assembly:
cmpl $0x0, 0xc(%rdi)
je 0x1a5a
cmpl $0x0, (%rdi)
jle 0x1a5a
xorl %eax, %eax
cmpl $0x0, 0xc(%rdi)
jle 0x1a4f
movq 0x18(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
xorl %edx, %edx
movl $0x0, (%rcx,%rdx,4)
incq %rdx
movslq 0xc(%rdi), %rsi
cmpq %rsi, %rdx
jl 0x1a3c
incq %rax
movslq (%rdi), %rcx
cmpq %rcx, %rax
jl 0x1a2c
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: newRRA_TAG
RRA_TAG *
newRRA_TAG(char *attribute,void *value,RRA_TAG *next)
    {
    RRA_TAG *t = (RRA_TAG *) New(sizeof(RRA_TAG));

    t->attribute = attribute;
    t->value = value;
    t->next = next;

    return t;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x180d
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: freeRRA
void
freeRRA(RRA *w,void (*handler)(char *,void *))
    {
    int i;
    RRA_TAG *t;

    if (handler == 0) handler = defaultFreePair;

    /* free all data */

    if (w->data)
        {
        for (i = 0; i < w->channels; ++i)
            free(w->data[i]);

        free(w->data);
        }

    /* free all tags */

    t = w->items;
    while (t != 0)
        {
        RRA_TAG *next = t->next;
        handler(t->attribute,t->value);
        free(t);
        t = next;
        }

    free(w);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0x6e(%rip), %r15        # 0x1b4e
cmovneq %rsi, %r15
cmpq $0x0, 0x18(%rdi)
je 0x1b14
cmpl $0x0, (%rbx)
jle 0x1b0b
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1040
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x1af3
movq 0x18(%rbx), %rdi
callq 0x1040
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x1b3b
movq 0x10(%r14), %r12
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq *%r15
movq %r14, %rdi
callq 0x1040
movq %r12, %r14
testq %r12, %r12
jne 0x1b1d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: cloneRRA
RRA *
cloneRRA(RRA *v,RRA_TAG *(*handler)(RRA_TAG *))
    {
    int i,j;
    RRA_TAG *t;
    RRA *w;

    if (handler == 0) handler = defaultCloneTag;

    w = newRRA(v->sampleRate,v->bitsPerSample,v->channels,v->samples);
    w->skip = v->skip;

    /* transfer over the data */

    for (i = 0; i < v->channels; ++i)
        for (j = 0; j < v->samples; ++j)
            w->data[i][j] = v->data[i][j];

    /* transfer over the tags */

    t = v->items;
    while (t != 0)
        {
        pushTag(w,handler(t));
        t = t->next;
        }

    w->maxAmp = v->maxAmp;

    return w;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xc3(%rip), %r12        # 0x1c3d
cmovneq %rsi, %r12
movups (%rdi), %xmm0
movaps %xmm0, (%rsp)
movl $0x40, %edi
callq 0x180d
movq %rax, %r14
movaps (%rsp), %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
movq %rax, %rdi
callq 0x19ae
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
cmpl $0x0, (%rbx)
jle 0x1bfa
xorl %eax, %eax
cmpl $0x0, 0xc(%rbx)
jle 0x1bef
movq 0x18(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x18(%r14), %rdx
movq (%rdx,%rax,8), %rdx
xorl %esi, %esi
movl (%rcx,%rsi,4), %edi
movl %edi, (%rdx,%rsi,4)
incq %rsi
movslq 0xc(%rbx), %rdi
cmpq %rdi, %rsi
jl 0x1bdd
incq %rax
movslq (%rbx), %rcx
cmpq %rcx, %rax
jl 0x1bc5
movq 0x28(%rbx), %r15
testq %r15, %r15
je 0x1c25
movq %r14, %r13
addq $0x28, %r13
movq %r15, %rdi
callq *%r12
movq (%r13), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%r13)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x1c0a
movl 0x20(%rbx), %eax
movl %eax, 0x20(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: displayRRA
void
displayRRA(RRA *w)
    {
    printf("channels: %d\n",w->channels);
    printf("sampleRate: %d\n",w->sampleRate);
    printf("bitsPerSample: %d\n",w->bitsPerSample);
    printf("skip: %d\n",w->skip);
    printf("samples: %d\n",w->samples);
    printf("maxAmp: %d\n",w->maxAmp);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %esi
leaq 0x14f7(%rip), %rdi      # 0x3180
xorl %eax, %eax
callq 0x10b0
movl 0x4(%rbx), %esi
leaq 0x14f4(%rip), %rdi      # 0x318e
xorl %eax, %eax
callq 0x10b0
movl 0x8(%rbx), %esi
leaq 0x14f3(%rip), %rdi      # 0x319e
xorl %eax, %eax
callq 0x10b0
movl 0x10(%rbx), %esi
leaq 0x14f5(%rip), %rdi      # 0x31b1
xorl %eax, %eax
callq 0x10b0
movl 0xc(%rbx), %esi
leaq 0x14ee(%rip), %rdi      # 0x31bb
xorl %eax, %eax
callq 0x10b0
movl 0x20(%rbx), %esi
leaq 0x14ea(%rip), %rdi      # 0x31c8
xorl %eax, %eax
popq %rbx
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: readRRA
RRA *
readRRA(FILE *in,void (*handler)(RRA *,char *,void *))
    {
    RRA *w;

    w = newRRAHeader();

    readRRAHeader(in,w,handler);

    /* derived values */

    w->maxAmp = (int) pow(2,w->bitsPerSample - 1);

    readData(in,w);

    return w;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r15
movl $0x40, %edi
callq 0x180d
movq %rax, %rbx
movaps 0x1428(%rip), %xmm0     # 0x3130
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
xorl %r14d, %r14d
movq %r14, 0x18(%rax)
movq %r14, 0x28(%rax)
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1e04
movl 0x8(%rbx), %edi
decl %edi
movsd 0x1418(%rip), %xmm0     # 0x3150
callq 0x1050
cvttsd2si %xmm0, %eax
movl %eax, 0x20(%rbx)
movl 0x4(%rbx), %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
movl %eax, 0xc(%rbx)
movq %rbx, %rdi
callq 0x19ae
movl 0x8(%rbx), %edx
leaq 0x4d9(%rip), %rcx       # 0x223a
movq %r15, %rdi
xorl %esi, %esi
callq 0x22f0
movl %eax, %ebp
movq %r15, %rdi
callq 0x1160
testl %eax, %eax
jne 0x1dce
xorl %r14d, %r14d
leaq 0x4b7(%rip), %r12       # 0x223a
movl %r14d, %eax
cltd
idivl (%rbx)
movl 0xc(%rbx), %esi
cmpl %esi, %eax
jne 0x1d9a
addl %esi, %esi
movq %rbx, %rdi
callq 0x2781
movq 0x18(%rbx), %rcx
movl %r14d, %eax
cltd
idivl (%rbx)
movq (%rcx,%rdx,8), %rcx
cltq
movl %ebp, (%rcx,%rax,4)
movl 0x8(%rbx), %edx
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x22f0
movl %eax, %ebp
incl %r14d
movq %r15, %rdi
callq 0x1160
testl %eax, %eax
je 0x1d83
movl %r14d, %eax
cltd
idivl (%rbx)
testl %edx, %edx
je 0x1de8
leaq 0x176f(%rip), %rdi      # 0x354e
movl %edx, %esi
xorl %eax, %eax
callq 0x1260
movl %r14d, %eax
cltd
idivl (%rbx)
movq %rbx, %rdi
movl %eax, %esi
callq 0x2781
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: readAttribute
static char *
readAttribute(FILE *in)
    {
    int ch;
    char *t;

    skipWhiteSpace(in,0,discardComment);

    ch = fgetc(in);

    if (ch == EOF)
        t = 0;
    else if (isdigit(ch))
        {
        char buffer[2];
        buffer[0] = ch;
        buffer[1] = '\0';
        return strdup(buffer);
        }
    else
        {
        t = readToken(in,ch);
        if (strcmp(t,"%%") == 0) 
            t = 0;
        }

    return t;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xec(%rip), %rdx        # 0x223a
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x21c0
movq %rbx, %rdi
callq 0x10e0
cmpl $-0x1, %eax
je 0x21b4
movl %eax, %ebp
callq 0x1240
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x21a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2f1f
movq %rax, %rbx
leaq 0x1334(%rip), %rsi      # 0x34c1
movq %rax, %rdi
callq 0x1120
xorl %r14d, %r14d
testl %eax, %eax
cmovneq %rbx, %r14
jmp 0x21b4
leaq 0xe(%rsp), %rdi
movb %bpl, (%rdi)
movb $0x0, 0x1(%rdi)
callq 0x1220
movq %rax, %r14
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: skipWhiteSpace
static void
skipWhiteSpace(FILE *in,FILE *out,void (*handler)(FILE *,FILE *))
    {
    int ch;

    while ((ch = fgetc(in)) && ch != EOF && (isspace(ch) || ch == '!'))
        {
        if (ch == '\n')
            {
            ++LineNumber;
            }
        else if (ch == '!')
            {
            handler(in,out);
            ++LineNumber;
            }
        }

    ungetc(ch,in);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x10e0
movl %eax, %ebp
decl %eax
cmpl $-0x3, %eax
ja 0x2228
callq 0x1240
movq %rax, %r12
cmpl $0x21, %ebp
je 0x21fe
movq (%r12), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
je 0x2228
cmpl $0xa, %ebp
je 0x2211
cmpl $0x21, %ebp
jne 0x2217
movq %rbx, %rdi
movq %r15, %rsi
callq *%r14
incl 0x3f31(%rip)            # 0x6148
movq %rbx, %rdi
callq 0x10e0
movl %eax, %ebp
decl %eax
cmpl $-0x2, %eax
jb 0x21e7
movl %ebp, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: getAttributeRRA
void *
getAttributeRRA(RRA *h,char *attribute)
    {
    RRA_TAG *t;

    t  = h->items;
    while (t != 0)
        {
        if (strcmp(attribute,t->attribute) == 0) 
            return t->value;
        t = t->next;
        }

    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x228d
movq %rsi, %r14
xorl %ebx, %ebx
movq (%r15), %rsi
movq %r14, %rdi
callq 0x1120
testl %eax, %eax
je 0x2291
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x2273
jmp 0x2295
xorl %ebx, %ebx
jmp 0x2295
movq 0x8(%r15), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: setAttributeRRA
void *
setAttributeRRA(RRA *h,char *attribute,void *value)
    {
    RRA_TAG *t;

    t  = h->items;
    while (t != 0)
        {
        if (strcmp(attribute,t->attribute) == 0) 
            {
            void *temp = t->value;
            t->value = value;
            return temp;
            }
        t = t->next;
        }

    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %r12
testq %r12, %r12
je 0x22d3
movq %rdx, %r14
movq %rsi, %r15
xorl %ebx, %ebx
movq (%r12), %rsi
movq %r15, %rdi
callq 0x1120
testl %eax, %eax
je 0x22d7
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x22b7
jmp 0x22e1
xorl %ebx, %ebx
jmp 0x22e1
movq 0x8(%r12), %rbx
movq %r14, 0x8(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: findPreviousRRAAmplitudeFD
int
findPreviousRRAAmplitudeFD(int fd)
    {
    char ch;
    int comment;
    off_t offset;

    //find beginning of the line
    comment = 0;
    read(fd,&ch,1);
    while (ch != '\n')
        {
        //printf("ch is <%c>\n",ch);
        if (ch == '!') comment = 1;
        offset = lseek(fd,-2,SEEK_CUR);
        read(fd,&ch,1);
        }

    if (comment)
        {
        lseek(fd,-1,SEEK_CUR);
        return findPreviousRRAAmplitudeFD(fd);
        }

    //find beginning of token
    read(fd,&ch,1);
    while (isspace(ch))
        {
        read(fd,&ch,1);
        }

    offset = lseek(fd,-1,SEEK_CUR);

    return offset;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %ebp, %ebp
leaq 0x7(%rsp), %r14
movl $0x1, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x1110
movzbl 0x7(%rsp), %eax
cmpl $0x21, %eax
je 0x26ca
cmpl $0xa, %eax
jne 0x26cf
jmp 0x26e4
movl $0x1, %ebp
movl %ebx, %edi
movq $-0x2, %rsi
movl $0x1, %edx
callq 0x10c0
jmp 0x26aa
testl %ebp, %ebp
je 0x270c
movl %ebx, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x10c0
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x269a
leaq 0x7(%rsp), %r15
movl $0x1, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x1110
callq 0x1240
movq %rax, %r14
movq (%rax), %rax
movsbq (%r15), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x275a
leaq 0x7(%rsp), %r15
movl $0x1, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x1110
movq (%r14), %rax
movsbq 0x7(%rsp), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x273b
movl %ebx, %edi
movq $-0x1, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: shrinkRRA
void
shrinkRRA(RRA *w,int size)
    {
    int i;

    w->samples = size;
    for (i = 0; i < w->channels; ++i)
        w->data[i] = (int *) ReNew(w->data[i],sizeof(int) * size);
    }

// Assembly:
movl %esi, 0xc(%rdi)
cmpl $0x0, (%rdi)
jle 0x27c0
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
shll $0x2, %ebx
xorl %r15d, %r15d
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x1890
movq 0x18(%r14), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0x2799
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: writeRRA
void
writeRRA(FILE *out,RRA *w,char *tag, void (*handler)(FILE *,RRA *), int offset)
    {
    int i,j;
    int samples;
    
    
    /* save the original samples because we need to reduce then */
    /* number written by 'skip' */

    samples = w->samples;

    w->samples -= w->skip;

    if (w->samples < 0) w->samples = 0;

    writeRRAHeader(out,w,tag,handler);

    for (i = 0; i < samples; ++i)
        for (j = 0; j < w->channels; ++j)
            if (i >= w->skip)
                fprintf(out,"%d\n",w->data[j][i] + offset);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rsi, %r14
movq %rdi, %r15
movslq 0xc(%rsi), %r12
movl 0x10(%rsi), %eax
movl %r12d, %esi
subl %eax, %esi
xorl %eax, %eax
testl %esi, %esi
cmovgl %esi, %eax
movl %eax, 0xc(%r14)
movq %r14, %rsi
callq 0x2855
movq %r12, (%rsp)
testq %r12, %r12
jle 0x2846
leaq 0x9a9(%rip), %r12       # 0x31ad
xorl %ebp, %ebp
cmpl $0x0, (%r14)
jle 0x283d
xorl %r13d, %r13d
movslq 0x10(%r14), %rax
cmpq %rax, %rbp
jl 0x2832
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rax
movl (%rax,%rbp,4), %edx
addl %ebx, %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1140
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x280f
incq %rbp
cmpq (%rsp), %rbp
jne 0x2806
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: defaultTagWriter
static void
defaultTagWriter(FILE *out,RRA *w)
    {
    RRA_TAG *t;
    char *value;

    t = w->items;
    while (t != 0)
        {
        int i;
        int spaces;

        value = (char *) t->value;

        spaces = 0;
        for (i = 0; i < strlen(value); ++i)
            if (isspace(value[i]))
                {
                spaces = 1;
                break;
                }

        fprintf(out,"%s: %s%s%s\n",
            t->attribute,
            spaces? "\"" : "",
            value,
            spaces? "\"" : ""
            );
        t = t->next;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rsi), %r13
testq %r13, %r13
je 0x2a2f
movq %rdi, %rbx
leaq 0xa8b(%rip), %rbp       # 0x3452
leaq 0xb95(%rip), %r14       # 0x3563
movq 0x8(%r13), %r15
movq %r15, %rdi
callq 0x10a0
movq %rbp, %rcx
testq %rax, %rax
je 0x2a0f
movq %rax, %r12
callq 0x1240
movq (%rax), %rax
xorl %ecx, %ecx
movsbq (%r15,%rcx), %rdx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0x2a08
incq %rcx
cmpq %rcx, %r12
jne 0x29ef
movq %rbp, %rcx
jmp 0x2a0f
leaq 0xb60(%rip), %rcx       # 0x356f
movq (%r13), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %r8
movq %rcx, %r9
xorl %eax, %eax
callq 0x1140
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x29ce
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: skipRRAHeaderFD
off_t
skipRRAHeaderFD(int fd)
    {
    off_t index;
    char buffer[10];
    //find start
    lseek(fd,0,SEEK_SET);
    read(fd,buffer,sizeof(buffer));
    buffer[7] = '\0';
    if (strcmp(buffer,"RRAUDIO") != 0) return -1;

    index = 0;
    lseek(fd,0,SEEK_SET);
    read(fd,buffer,2);
    while (buffer[0] != '%' || buffer[1] != '%')
        {
        ++index;
        lseek(fd,index,SEEK_SET);
        read(fd,buffer,2);
        }

    return index + 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x10c0
leaq 0x6(%rsp), %r15
movl $0xa, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x1110
movb $0x0, 0x7(%r15)
movabsq $0x4f494455415252, %rax # imm = 0x4F494455415252
movq $-0x1, %r14
cmpq %rax, (%r15)
jne 0x2b14
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10c0
leaq 0x6(%rsp), %r15
movl $0x2, %r14d
movl $0x2, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x1110
cmpb $0x25, (%r15)
jne 0x2adc
cmpb $0x25, 0x7(%rsp)
je 0x2b14
movl $0x2, %r14d
leaq 0x6(%rsp), %r15
leaq -0x1(%r14), %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x10c0
movl $0x2, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x1110
incq %r14
cmpb $0x25, 0x6(%rsp)
jne 0x2ae7
cmpb $0x25, 0x7(%rsp)
jne 0x2ae7
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: rra2fft
double *
rra2fft(RRA *h,int channel,int *length)
    {
    int i;
    double *data = 0;
    double max;

    if (channel >= h->channels)
        Fatal("not enough channels (channel zero is the first channel)\n");

    *length = (int) pow(2,ceil(log((double)h->samples)/log(2.0)));
    //printf("h->channels is %d\n",h->channels);
    //printf("samples is %d\n",h->samples);
    //printf("fftLength is %d\n",*length);

    /* fft uses one-based counting! */

    data = (double *) New(2*((*length)+1) * sizeof(double));

    /* fill the data array data here */

    max = pow(2,h->bitsPerSample - 1);
    //printf("max is %f\n",max);

    for (i = 0; i < h->samples && i < *length; ++i)
        {
        data[i * 2 + 1] = h->data[channel][i] / max;
        data[i * 2 + 2] = 0.0;
        }

    /* fill the remainder of the data array with zeros */

    for ( ; i < *length; ++i)
        {
        data[i * 2 + 1] = 0.0;
        data[i * 2 + 2] = 0.0;
        }

    /* call the fft */

    fft(data,*length,1);

    return data;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
cmpl %esi, (%rdi)
jg 0x2b87
leaq 0x908(%rip), %rdi       # 0x3488
xorl %eax, %eax
callq 0x16e0
cvtsi2sdl 0xc(%r15), %xmm0
callq 0x10f0
divsd 0x5c6(%rip), %xmm0      # 0x3160
callq 0x1230
callq 0x1030
cvttsd2si %xmm0, %edi
movl %edi, (%rbx)
shll $0x4, %edi
addl $0x10, %edi
callq 0x180d
movq %rax, %r14
movl 0x8(%r15), %edi
decl %edi
movsd 0x58a(%rip), %xmm0      # 0x3150
callq 0x1050
movslq 0xc(%r15), %rax
testq %rax, %rax
jle 0x2c18
leaq 0x10(%r14), %rcx
movl (%rbx), %esi
movslq %ebp, %rdi
xorl %edx, %edx
testl %esi, %esi
cmovlel %edx, %esi
cmpq %rdx, %rsi
je 0x2c1a
movq 0x18(%r15), %r8
movq (%r8,%rdi,8), %r8
xorps %xmm1, %xmm1
cvtsi2sdl (%r8,%rdx,4), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x8(%rcx)
movq $0x0, (%rcx)
incq %rdx
addq $0x10, %rcx
cmpq %rdx, %rax
jne 0x2be4
jmp 0x2c1a
xorl %edx, %edx
movl (%rbx), %ebx
cmpl %ebx, %edx
jge 0x2c41
movl %edx, %eax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0x8, %rdi
notl %edx
addl %ebx, %edx
shlq $0x4, %rdx
addq $0x10, %rdx
xorl %esi, %esi
callq 0x10d0
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
callq 0x2c5e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: fft2rra
void
fft2rra(RRA *h,int channel,double *data,int length)
    {
    int i;
    double max;

    /* call the inverse fft */

    fft(data,length,-1);

    /* normalize the result */

    for(i = 0; i < length; ++i)
        {
        data[2*i+1] /= length;
        data[2*i+2] /= length;
        }

    /* now place back into RRA object */

    max = pow(2,h->bitsPerSample - 1);

    for (i = 0; i < length; i += 2)
        {
        h->data[channel][i / 2] = (int) (max * data[i + 1]);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
movl %ecx, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2c5e
movl %r15d, %r12d
testl %r15d, %r15d
jle 0x2ed7
cvtsi2sd %r15d, %xmm0
movq %r12, %rax
shlq $0x4, %rax
xorl %ecx, %ecx
movsd 0x8(%rbx,%rcx), %xmm1
movsd 0x10(%rbx,%rcx), %xmm2
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx,%rcx)
divsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rbx,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x2eae
movl 0x8(%r14), %edi
decl %edi
movsd 0x26b(%rip), %xmm0      # 0x3150
callq 0x1050
testl %r15d, %r15d
jle 0x2f16
movq 0x18(%r14), %rax
movslq %ebp, %rcx
movq (%rax,%rcx,8), %rax
xorl %ecx, %ecx
movsd 0x8(%rbx,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movl %edx, (%rax,%rcx,2)
addq $0x2, %rcx
cmpq %r12, %rcx
jb 0x2efc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/lib/rra.c
// Function: readToken
static char *
readToken(FILE *in,int ch)
    {
    int index;
    char buffer[1024];

    buffer[0] = ch;

    ch = fgetc(in);

    index = 1;
    while (ch != EOF && !isspace(ch) && ch != '\"' && ch != ':')
        {
        if (index == sizeof(buffer) - 1)
            {
            buffer[sizeof(buffer)-1] = '\0';
            Fatal("file %s,line %s, token too long: %s\n",buffer);
            }
        buffer[index++] = ch;
        ch = fgetc(in);
        }

    buffer[index] = '\0';

    ungetc(ch,in);

    return StringDup(buffer);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
movb %sil, (%rsp)
callq 0x10e0
movl %eax, %ebp
cmpl $-0x1, %eax
je 0x2fae
movl $0x1, %r13d
callq 0x1240
movq %rax, %r14
leaq 0x56c(%rip), %r15       # 0x34c4
movq %rsp, %r12
movq (%r14), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xd, %eax
jb 0x2fa9
cmpl $0x22, %ebp
je 0x2fa9
cmpl $0x3a, %ebp
je 0x2fa9
cmpq $0x3ff, %r13            # imm = 0x3FF
jne 0x2f93
movb $0x0, 0x3ff(%rsp)
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x16e0
movb %bpl, (%rsp,%r13)
incq %r13
movq %rbx, %rdi
callq 0x10e0
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x2f5b
movl %r13d, %eax
jmp 0x2fb3
movl $0x1, %eax
movb $0x0, (%rsp,%rax)
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1190
movq %rsp, %rdi
callq 0x17f0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_04/minscanf.c
// Function: main
int main(int argc, char *argv[])
{
  int decimal;
  int integer;
  int octal;
  int unsigned_decimal;
  int hexadecimal_integer;
  char character;
  char str[100];
  float float_point_number;

  minscanf("%d", &decimal);
  minscanf("%i", &integer);
  minscanf("%o", &octal);
  minscanf("%u", &unsigned_decimal);
  minscanf("%x", &hexadecimal_integer);
  minscanf("%c", &character);
  minscanf("%s", str);
  minscanf("%f", &float_point_number);

  printf("decimal: %d\n", decimal);
  printf("integer: %i\n", integer);
  printf("octal: %o\n", octal);
  printf("unsigned_decimal: %u\n", unsigned_decimal);
  printf("hexadecimal_integer: %x\n", hexadecimal_integer);
  printf("character: %c\n", character);
  printf("str: %s\n", str);
  printf("float_point_number: %f\n", float_point_number);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0xef8(%rip), %rdi       # 0x205c
leaq 0x1c(%rsp), %r14
movq %r14, %rsi
xorl %eax, %eax
callq 0x12ad
leaq 0xee5(%rip), %rdi       # 0x205f
leaq 0x18(%rsp), %r15
movq %r15, %rsi
xorl %eax, %eax
callq 0x12ad
leaq 0xed2(%rip), %rdi       # 0x2062
leaq 0x14(%rsp), %r12
movq %r12, %rsi
xorl %eax, %eax
callq 0x12ad
leaq 0xebf(%rip), %rdi       # 0x2065
leaq 0x10(%rsp), %r13
movq %r13, %rsi
xorl %eax, %eax
callq 0x12ad
leaq 0xeac(%rip), %rdi       # 0x2068
leaq 0xc(%rsp), %rbp
movq %rbp, %rsi
xorl %eax, %eax
callq 0x12ad
leaq 0xe99(%rip), %rdi       # 0x206b
leaq 0x7(%rsp), %rsi
xorl %eax, %eax
callq 0x12ad
leaq 0xe89(%rip), %rdi       # 0x206e
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
callq 0x12ad
leaq 0xe79(%rip), %rdi       # 0x2071
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x12ad
movl (%r14), %esi
leaq 0xe63(%rip), %rdi       # 0x2074
xorl %eax, %eax
callq 0x1030
movl (%r15), %esi
leaq 0xe5f(%rip), %rdi       # 0x2081
xorl %eax, %eax
callq 0x1030
movl (%r12), %esi
leaq 0xe5a(%rip), %rdi       # 0x208e
xorl %eax, %eax
callq 0x1030
movl (%r13), %esi
leaq 0xe53(%rip), %rdi       # 0x2099
xorl %eax, %eax
callq 0x1030
movl (%rbp), %esi
leaq 0xe58(%rip), %rdi       # 0x20af
xorl %eax, %eax
callq 0x1030
leaq 0x7(%rsp), %rax
movsbl (%rax), %esi
leaq 0xe5b(%rip), %rdi       # 0x20c8
xorl %eax, %eax
callq 0x1030
leaq 0xe5c(%rip), %rdi       # 0x20d7
leaq 0x20(%rsp), %rsi
xorl %eax, %eax
callq 0x1030
cvtss2sd (%rbx), %xmm0
leaq 0xe4e(%rip), %rdi       # 0x20e0
movb $0x1, %al
callq 0x1030
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/smilingthax[P]libfontembed/sfnt.c
// Function: otf_read_table
char *otf_read_table(OTF_FILE *otf,char *buf,const OTF_DIRENT *table) // {{{
{
  char *ours=NULL;

  if (table->length==0) {
    return buf;
  } else if ( (table->compLength<0)||(table->length<table->compLength) ) {
    assert(0);
    return NULL;
  }

  const int pad_len=otf_padded(table->length); // for checksum...
  if (!buf) {
    ours=buf=malloc(sizeof(char)*pad_len);
    if (!buf) {
      fprintf(stderr,"Bad alloc: %s\n", strerror(errno));
      return NULL;
    }
  }

  int res;
  if (table->compLength<table->length) {
    res=otf_read_compressed_raw(otf->f,buf,table->offset,pad_len,table->compLength);
  } else {
    res=otf_read_raw(otf->f,buf,table->offset,pad_len);
  }
  if (res==pad_len) {
    return buf;
  } else if (res==table->length) {
    // (file/uncompressed) length is not a multiple of 4, fill missing padding with zero
    memset(buf+res,0,pad_len-res);
    return buf;
  } else if (res!=-1) {
    fprintf(stderr,"Short read\n");
  }
  free(ours);
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movslq 0xc(%rdx), %rbx
testq %rbx, %rbx
je 0x397d
movq %rdx, %r12
movslq 0x10(%rdx), %r13
cmpl %r13d, %ebx
jb 0x39c4
movq %rdi, %rbp
leaq 0x3(%rbx), %r15
andq $-0x4, %r15
testq %r14, %r14
je 0x389a
xorl %eax, %eax
jmp 0x38ae
movq %r15, %rdi
callq 0x21c0
movq %rax, %r14
testq %rax, %rax
je 0x39b6
movq %rax, 0x20(%rsp)
movq %r14, 0x10(%rsp)
movq (%rbp), %r14
movq %r12, 0x8(%rsp)
movl 0x8(%r12), %r12d
cmpl %ebx, %r13d
jae 0x3934
movslq %r15d, %rax
movq %rax, 0x18(%rsp)
movq %r13, %rdi
callq 0x21c0
testq %rax, %rax
je 0x398f
movq %rax, %rbp
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
movl %r13d, %ecx
callq 0x39e3
cmpl %r13d, %eax
jne 0x3996
leaq 0x18(%rsp), %rsi
movq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x2080
testl %eax, %eax
movq 0x8(%rsp), %rbx
movq %rbp, %rdi
jne 0x39aa
callq 0x21a0
movl 0x18(%rsp), %eax
jmp 0x394f
movq %r14, %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x39e3
movq 0x8(%rsp), %rbx
subl %eax, %r15d
je 0x397d
cmpl 0xc(%rbx), %eax
jne 0x396b
movslq %eax, %rdi
addq %r14, %rdi
movslq %r15d, %rdx
xorl %esi, %esi
callq 0x20c0
jmp 0x397d
cmpl $-0x1, %eax
jne 0x39bd
movq 0x20(%rsp), %rdi
callq 0x21a0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2319
jmp 0x399e
movq %rbp, %rdi
callq 0x22c6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x10(%rsp), %r14
jmp 0x394a
callq 0x22ef
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x394f
callq 0x2367
jmp 0x397a
callq 0x2345
jmp 0x3970
leaq 0x72f5(%rip), %rdi      # 0xacc0
leaq 0x707d(%rip), %rsi      # 0xaa4f
leaq 0x6943(%rip), %rcx      # 0xa31c
movl $0x81, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O1/smilingthax[P]libfontembed/sfnt.c
// Function: otf_read_raw
static int otf_read_raw(FILE *f,char *buf,long pos,int length) // {{{
{
  const int res=fseek(f,pos,SEEK_SET);
  if (res==-1) {
    fprintf(stderr,"Seek failed: %s\n", strerror(errno));
    return -1;
  }
  return fread(buf,1,length,f);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
xorl %edx, %edx
callq 0x2160
cmpl $-0x1, %eax
je 0x3a16
movslq %ebp, %rdx
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rcx
callq 0x21e0
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2393
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3a11