LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jg 0x126cf
cmpl $0xb, -0xc(%rbp)
jg 0x126cf
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
orl 0x100bf(%rip), %eax     # 0x22788
movl %eax, 0x100b9(%rip)     # 0x22788
movl 0xffff(%rip), %eax      # 0x226d4
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0x126ff
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0x99f4(%rip), %eax      # 0x1c0e0
cmpl $0x0, %eax
jne 0x126ff
movq -0x8(%rbp), %rdi
callq 0x13540
jmp 0x12837
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x13810
cmpl $0x0, %eax
je 0x12714
jmp 0x12837
cmpl $0x1, -0xc(%rbp)
jne 0x12837
movl $0x1, %edi
leaq -0x20(%rbp), %rsi
callq 0x6140
movq 0x1001d(%rip), %rdx     # 0x22750
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rdx, %rcx
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
cvtsi2sd %rcx, %xmm1
movq 0x10007(%rip), %rcx     # 0x22758
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x27bf(%rip), %xmm2     # 0x14f20
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
movl 0x9975(%rip), %eax      # 0x1c0e4
cvtsi2sd %rax, %xmm0
ucomisd %xmm1, %xmm0
jb 0x12783
movl $0x2, -0x24(%rbp)
jmp 0x127e3
movq 0xffb6(%rip), %rdx      # 0x22740
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rdx, %rcx
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
cvtsi2sd %rcx, %xmm1
movq 0xffa0(%rip), %rcx      # 0x22748
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x2768(%rip), %xmm2     # 0x14f20
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
movl 0x9922(%rip), %eax      # 0x1c0e8
cvtsi2sd %rax, %xmm0
ucomisd %xmm1, %xmm0
jb 0x127da
movl $0x1, -0x24(%rbp)
jmp 0x127e1
movl $0x0, -0x24(%rbp)
jmp 0x127e3
movq 0xff56(%rip), %rax      # 0x22740
movq %rax, 0xff5f(%rip)      # 0x22750
movq 0xff50(%rip), %rax      # 0x22748
movq %rax, 0xff59(%rip)      # 0x22758
movq -0x20(%rbp), %rax
movq %rax, 0xff36(%rip)      # 0x22740
movq -0x18(%rbp), %rax
movq %rax, 0xff33(%rip)      # 0x22748
movq -0x8(%rbp), %rdi
callq 0x138f0
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13960
movl -0x28(%rbp), %edi
movl %eax, %esi
movl -0x24(%rbp), %edx
callq 0x6f10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jg 0x12882
cmpl $0xb, -0xc(%rbp)
jg 0x12882
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
xorl $-0x1, %eax
andl 0xff0c(%rip), %eax      # 0x22788
movl %eax, 0xff06(%rip)      # 0x22788
movl 0xfe4c(%rip), %eax      # 0x226d4
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0x128af
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0x9841(%rip), %eax      # 0x1c0e0
cmpl $0x0, %eax
jne 0x128af
movq -0x8(%rbp), %rdi
callq 0x13540
jmp 0x128d8
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x13810
cmpl $0x0, %eax
je 0x128c4
jmp 0x128d8
cmpl $0x1, -0xc(%rbp)
jne 0x128d8
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x13a90
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: bmotion
void
bmotion(XEvent *e)
{
	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
		mousereport(e);
		return;
	}

	mousesel(e, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xfde2(%rip), %eax      # 0x226d4
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0x12919
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0x97d7(%rip), %eax      # 0x1c0e0
cmpl $0x0, %eax
jne 0x12919
movq -0x8(%rbp), %rdi
callq 0x13540
jmp 0x12924
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x13a90
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x12953
jmp 0x129f7
movq -0x8(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x129ad
cmpq $0x0, 0xfc84(%rip)      # 0x225e8
je 0x12972
movq 0xfc7b(%rip), %rdi      # 0x225e8
callq 0x6760
movl 0xfd5c(%rip), %eax      # 0x226d4
orl $0x2, %eax
movl %eax, 0xfd53(%rip)      # 0x226d4
xorl %edi, %edi
callq 0xf8e0
movl 0xfd46(%rip), %eax      # 0x226d4
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x129ab
leaq 0x2f98(%rip), %rdi      # 0x15937
movl $0x3, %esi
xorl %edx, %edx
callq 0x8350
jmp 0x129f7
cmpq $0x0, 0xfc33(%rip)      # 0x225e8
je 0x129c3
movq 0xfc2a(%rip), %rdi      # 0x225e8
callq 0x6490
movl 0xfd0b(%rip), %eax      # 0x226d4
andl $-0x3, %eax
movl %eax, 0xfd02(%rip)      # 0x226d4
movl 0xfcfc(%rip), %eax      # 0x226d4
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x129f5
leaq 0x2f52(%rip), %rdi      # 0x1593b
movl $0x3, %esi
xorl %edx, %edx
callq 0x8350
jmp 0x129f7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0xfaad(%rip), %rdi      # 0x22590
leaq 0x273f(%rip), %rsi      # 0x15229
xorl %edx, %edx
callq 0x6870
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x12b29
movq -0x10(%rbp), %rax
cmpq $0x1, 0x28(%rax)
je 0x12b20
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x12b29
movq -0x8(%rbp), %rdi
callq 0x12da0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
cmpq 0xf52d(%rip), %rax      # 0x225b8
jne 0x130d8
movq -0x8(%rbp), %rax
cmpl $0x20, 0x30(%rax)
jne 0x130d8
movq -0x8(%rbp), %rax
cmpq $0x4, 0x40(%rax)
jne 0x130ba
movl 0xf62c(%rip), %eax      # 0x226d4
orl $0x2, %eax
movl %eax, 0xf623(%rip)      # 0x226d4
xorl %edi, %edi
callq 0xf8e0
jmp 0x130d6
movq -0x8(%rbp), %rax
cmpq $0x5, 0x40(%rax)
jne 0x130d4
movl 0xf609(%rip), %eax      # 0x226d4
andl $-0x3, %eax
movl %eax, 0xf600(%rip)      # 0x226d4
jmp 0x130d6
jmp 0x130f7
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
cmpq 0xf4d9(%rip), %rax      # 0x225c0
jne 0x130f5
callq 0x8880
xorl %edi, %edi
callq 0x61b0
jmp 0x130f7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: kmap
char*
kmap(KeySym k, uint state)
{
	Key *kp;
	int i;

	/* Check for mapped keys out of X11 function keys. */
	for (i = 0; i < LEN(mappedkeys); i++) {
		if (mappedkeys[i] == k)
			break;
	}
	if (i == LEN(mappedkeys)) {
		if ((k & 0xFFFF) < 0xFD00)
			return NULL;
	}

	for (kp = key; kp < key + LEN(key); kp++) {
		if (kp->k != k)
			continue;

		if (!match(kp->mask, state))
			continue;

		if (IS_SET(MODE_APPKEYPAD) ? kp->appkey < 0 : kp->appkey > 0)
			continue;
		if (IS_SET(MODE_NUMLOCK) && kp->appkey == 2)
			continue;

		if (IS_SET(MODE_APPCURSOR) ? kp->appcursor < 0 : kp->appcursor > 0)
			continue;

		return kp->s;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq $0x1, %rax
jae 0x13184
movslq -0x24(%rbp), %rcx
leaq 0x754d(%rip), %rax      # 0x1a6b8
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x13177
jmp 0x13184
jmp 0x13179
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x13156
movslq -0x24(%rbp), %rax
cmpq $0x1, %rax
jne 0x131af
movq -0x10(%rbp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
cmpq $0xfd00, %rax           # imm = 0xFD00
jae 0x131ad
movq $0x0, -0x8(%rbp)
jmp 0x1329c
jmp 0x131af
leaq 0x750a(%rip), %rax      # 0x1a6c0
movq %rax, -0x20(%rbp)
leaq 0x74ff(%rip), %rax      # 0x1a6c0
addq $0x1a20, %rax           # imm = 0x1A20
cmpq %rax, -0x20(%rbp)
jae 0x13294
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x131e3
jmp 0x13283
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movl -0x14(%rbp), %esi
callq 0x13100
cmpl $0x0, %eax
jne 0x131fc
jmp 0x13283
movl 0xf4d2(%rip), %eax      # 0x226d4
andl $0x4, %eax
cmpl $0x0, %eax
je 0x13219
movq -0x20(%rbp), %rax
movsbl 0x18(%rax), %eax
cmpl $0x0, %eax
jl 0x13226
jmp 0x13228
movq -0x20(%rbp), %rax
movsbl 0x18(%rax), %eax
cmpl $0x0, %eax
jle 0x13228
jmp 0x13283
movl 0xf4a6(%rip), %eax      # 0x226d4
andl $0x20000, %eax          # imm = 0x20000
cmpl $0x0, %eax
je 0x13247
movq -0x20(%rbp), %rax
movsbl 0x18(%rax), %eax
cmpl $0x2, %eax
jne 0x13247
jmp 0x13283
movl 0xf487(%rip), %eax      # 0x226d4
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x13266
movq -0x20(%rbp), %rax
movsbl 0x19(%rax), %eax
cmpl $0x0, %eax
jl 0x13273
jmp 0x13275
movq -0x20(%rbp), %rax
movsbl 0x19(%rax), %eax
cmpl $0x0, %eax
jle 0x13275
jmp 0x13283
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1329c
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x131ba
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xf24d(%rip), %rdi      # 0x22590
leaq 0x1edf(%rip), %rsi      # 0x15229
xorl %edx, %edx
callq 0x6870
movq %rax, -0x10(%rbp)
movq 0xf234(%rip), %rdi      # 0x22590
movq -0x10(%rbp), %rsi
movq 0xf3c1(%rip), %rdx      # 0x22728
movq -0x10(%rbp), %rcx
movq 0xf22e(%rip), %r8       # 0x225a0
xorl %eax, %eax
movl %eax, %r9d
callq 0x61f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: zoomabs
void
zoomabs(const Arg *arg)
{
	xunloadfonts();
	xloadfonts(usedfont, arg->f);
	cresize(0, 0);
	redraw();
	xhints();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x13440
movq 0xf360(%rip), %rdi      # 0x22768
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x113d0
xorl %esi, %esi
movl %esi, %edi
callq 0x122e0
callq 0x9ee0
callq 0x11950
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
jmp 0x1344a
cmpl $0x0, 0xf247(%rip)      # 0x22698
jle 0x13493
movq 0xf246(%rip), %rax      # 0x226a0
movl 0xf238(%rip), %ecx      # 0x22698
addl $-0x1, %ecx
movl %ecx, 0xf22f(%rip)      # 0x22698
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe170
jmp 0x1344a
leaq 0xefbe(%rip), %rdi      # 0x22458
addq $0x10, %rdi
callq 0x134e0
leaq 0xefae(%rip), %rdi      # 0x22458
addq $0x58, %rdi
callq 0x134e0
leaq 0xef9e(%rip), %rdi      # 0x22458
addq $0xa0, %rdi
callq 0x134e0
leaq 0xef8b(%rip), %rdi      # 0x22458
addq $0xe8, %rdi
callq 0x134e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xe170
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x6050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x13537
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x6600
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %edi
callq 0x139d0
movl %eax, %ecx
movl -0x28(%rbp), %eax
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x24(%rbp)
leaq 0x88a7(%rip), %rax      # 0x1c0f0
movq %rax, -0x20(%rbp)
leaq 0x889c(%rip), %rax      # 0x1c0f0
addq $0xa0, %rax
cmpq %rax, -0x20(%rbp)
jae 0x138db
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x138c8
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jne 0x138c8
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x24(%rbp), %esi
callq 0x13100
cmpl $0x0, %eax
jne 0x138ad
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x24(%rbp), %esi
movl 0x8842(%rip), %eax      # 0x1c0e0
xorl $-0x1, %eax
andl %eax, %esi
callq 0x13100
cmpl $0x0, %eax
je 0x138c8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x138e2
jmp 0x138ca
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x1384d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: buttonmask
uint
buttonmask(uint button)
{
	return button == Button1 ? Button1Mask
	     : button == Button2 ? Button2Mask
	     : button == Button3 ? Button3Mask
	     : button == Button4 ? Button4Mask
	     : button == Button5 ? Button5Mask
	     : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0x139e7
movl $0x100, %eax            # imm = 0x100
movl %eax, -0x8(%rbp)
jmp 0x13a3c
cmpl $0x2, -0x4(%rbp)
jne 0x139f7
movl $0x200, %eax            # imm = 0x200
movl %eax, -0xc(%rbp)
jmp 0x13a36
cmpl $0x3, -0x4(%rbp)
jne 0x13a07
movl $0x400, %eax            # imm = 0x400
movl %eax, -0x10(%rbp)
jmp 0x13a30
cmpl $0x4, -0x4(%rbp)
jne 0x13a17
movl $0x800, %eax            # imm = 0x800
movl %eax, -0x14(%rbp)
jmp 0x13a2a
movl -0x4(%rbp), %edx
xorl %eax, %eax
movl $0x1000, %ecx           # imm = 0x1000
cmpl $0x5, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl 0x862d(%rip), %ecx      # 0x1c0e0
orl $0x100, %ecx            # imm = 0x100
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x10(%rbp)
movslq -0x10(%rbp), %rax
cmpq $0x3, %rax
jae 0x13b02
movslq -0x10(%rbp), %rcx
leaq 0x86b3(%rip), %rax      # 0x1c190
movl (%rax,%rcx,4), %edi
movl -0x18(%rbp), %esi
callq 0x13100
cmpl $0x0, %eax
je 0x13af5
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x13b02
jmp 0x13af7
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13ac8
movq -0x8(%rbp), %rdi
callq 0x138f0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13960
movl -0x1c(%rbp), %edi
movl %eax, %esi
movl -0x14(%rbp), %edx
movl -0xc(%rbp), %ecx
callq 0x7260
cmpl $0x0, -0xc(%rbp)
je 0x13b42
callq 0x74a0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xdd20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/odknt[P]st/x.c
// Function: cleanup
void
cleanup()
{
	XColor *cp;
	xunloadfonts();
	XDestroyIC(xw.ime.xic);
	XCloseIM(xw.ime.xim);

	free(dc.col);
	free(xw.specbuf);
	free(frc);

	XFreePixmap(xw.dpy, xw.buf);
	XDestroyWindow(xw.dpy, xw.win);
	XrmDestroyDatabase(db);
	XCloseDisplay(xw.dpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x13440
movq 0xea84(%rip), %rdi      # 0x225e8
callq 0x66b0
movq 0xea70(%rip), %rdi      # 0x225e0
callq 0x69f0
movq 0xe8dc(%rip), %rdi      # 0x22458
callq 0x63d0
movq 0xea28(%rip), %rdi      # 0x225b0
callq 0x63d0
movq 0xeb0c(%rip), %rdi      # 0x226a0
callq 0x63d0
movq 0xe9f0(%rip), %rdi      # 0x22590
movq 0xea01(%rip), %rsi      # 0x225a8
callq 0x6910
movq 0xe9dd(%rip), %rdi      # 0x22590
movq 0xe9e6(%rip), %rsi      # 0x225a0
callq 0x6420
movq 0xebb2(%rip), %rdi      # 0x22778
callq 0x6290
movq 0xe9be(%rip), %rdi      # 0x22590
callq 0x6430
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1460
movl %eax, -0x14(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x1359
movq $0x0, -0x30(%rbp)
jmp 0x1390
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x1, %eax
jne 0x1376
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x138e
leaq 0x2c94(%rip), %rdi      # 0x4011
movb $0x0, %al
callq 0x1090
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11d0
jmp 0x1390
cmpq $0x0, -0x28(%rbp)
je 0x13ab
movq -0x28(%rbp), %rdi
leaq 0x3146(%rip), %rsi      # 0x44e8
callq 0x16d0
movq %rax, -0x30(%rbp)
callq 0x1bb0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x20b0
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1130
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
jne 0x13fa
movl -0x18(%rbp), %eax
movq -0x38(%rbp), %rcx
movl 0xc(%rcx), %ecx
movq -0x38(%rbp), %rdx
imull (%rdx), %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1403
jmp 0x1443
movq -0x30(%rbp), %rdi
movq 0x5bca(%rip), %rax      # 0x6fd8
movq (%rax), %rsi
movq -0x38(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x2071(%rip), %rcx      # 0x3490
callq 0x27e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
leaq 0x2d4c(%rip), %rdi      # 0x417d
movb $0x0, %al
callq 0x1090
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13cc
movq -0x30(%rbp), %rdi
callq 0x1070
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/rra/rradata.c
// Function: processOptions
static int
processOptions(int argc, char **argv)
{
    int argIndex;
    int argUsed;
    int separateArg;
    char *arg;

    argIndex = 1;

    while (argIndex < argc && *argv[argIndex] == '-') {

        separateArg = 0;
        argUsed = 0;

        if (argv[argIndex][2] == '\0')
            {
            arg = argv[argIndex+1];
            separateArg = 1;
            }
        else
            arg = argv[argIndex]+2;

        switch (argv[argIndex][1])
            {
            /*
             * when option has an argument, do this
             *
             *     examples are -m4096 or -m 4096
             *
             *     case 'm':
             *         MemorySize = atol(arg);
             *         argUsed = 1;
             *         break;
             *
             *
             * when option does not have an argument, do this
             *
             *     example is -a
             *
             *     case 'a':
             *         PrintActions = 1;
             *         break;
             */
            case 'v':
                printf("%s version %s\n", PROGRAM_NAME, PROGRAM_VERSION);
                exit(0);
                printf("%s\n",arg);
                break;
            default:
                Fatal("option %s not understood\n",argv[argIndex]);
            }

        if (separateArg && argUsed)
            ++argIndex;

        ++argIndex;
        }

    return argIndex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x149b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x14a7
jmp 0x1571
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x14e8
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x14fc
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb 0x1(%rax), %al
subb $0x76, %al
jne 0x1534
jmp 0x1511
movq 0x5c00(%rip), %rsi      # 0x7118
movq 0x5c01(%rip), %rdx      # 0x7120
leaq 0x2b23(%rip), %rdi      # 0x4049
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x11d0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x2b11(%rip), %rdi      # 0x4058
movb $0x0, %al
callq 0x1580
cmpl $0x0, -0x1c(%rbp)
je 0x1563
cmpl $0x0, -0x18(%rbp)
je 0x1563
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1476
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/util.c
// Function: Fatal
void
Fatal(const char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);

    exit(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x15b5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x59f1(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x11a0
leaq -0x20(%rbp), %rax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1190
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1786
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x61, %eax
je 0x173a
jmp 0x170c
movl -0x24(%rbp), %eax
subl $0x72, %eax
je 0x172d
jmp 0x1716
movl -0x24(%rbp), %eax
subl $0x77, %eax
jne 0x1747
jmp 0x1720
leaq 0x2969(%rip), %rax      # 0x4090
movq %rax, -0x20(%rbp)
jmp 0x174f
leaq 0x2964(%rip), %rax      # 0x4098
movq %rax, -0x20(%rbp)
jmp 0x174f
leaq 0x295f(%rip), %rax      # 0x40a0
movq %rax, -0x20(%rbp)
jmp 0x174f
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x176e
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x2945(%rip), %rdi      # 0x40aa
movb $0x0, %al
callq 0x1580
jmp 0x1784
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x2951(%rip), %rdi      # 0x40ce
movb $0x0, %al
callq 0x1580
jmp 0x1786
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
callq 0x1150
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1800
movl -0x4(%rbp), %esi
leaq 0x2907(%rip), %rdi      # 0x4100
movb $0x0, %al
callq 0x1580
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1180
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x19ae
cmpq $0x0, -0x18(%rbp)
jne 0x19ae
movl -0xc(%rbp), %esi
leaq 0x2757(%rip), %rdi      # 0x40fe
movb $0x0, %al
callq 0x1580
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl $0x40, %edi
callq 0x17d0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rdi
callq 0x1b30
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1b48
jmp 0x1ba8
movq -0x8(%rbp), %rax
movslq (%rax), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x17d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1ba8
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rax
shlq $0x2, %rax
movl %eax, %edi
callq 0x17d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1b6c
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/rra.c
// Function: newRRAHeader
RRA *
newRRAHeader()
    {
    RRA *w = (RRA *) New(sizeof(RRA));

    w->channels = DEFAULT_CHANNELS;
    w->sampleRate = DEFAULT_SAMPLE_RATE;
    w->bitsPerSample = DEFAULT_BPS;
    w->skip = 0;
    w->samples = DEFAULT_SAMPLES;

    w->data = 0;
    w->items = 0;

    return w;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x40, %edi
callq 0x17d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movl $0xac44, 0x4(%rax)      # imm = 0xAC44
movq -0x8(%rbp), %rax
movl $0x10, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x193bf60, 0xc(%rax)   # imm = 0x193BF60
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1c34
jmp 0x1c8c
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1c8c
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x1c7f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1c4d
jmp 0x1c81
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c3b
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x17d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1d72
leaq 0xb2(%rip), %rax        # 0x1e20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1dbc
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1daf
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d84
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1e03
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1dc8
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1e72
leaq 0x102(%rip), %rax       # 0x1f70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
callq 0x1aa0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1f0f
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x1f02
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1ebd
jmp 0x1f04
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1eab
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1f4e
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x1ce0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f1b
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x2187(%rip), %rdi      # 0x4150
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x2180(%rip), %rdi      # 0x415e
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x217b(%rip), %rdi      # 0x416e
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x2179(%rip), %rdi      # 0x4181
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x216e(%rip), %rdi      # 0x418b
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0x2166(%rip), %rdi      # 0x4198
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1bb0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x20b0
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0x20b8(%rip), %xmm0     # 0x4138
callq 0x1060
cvttsd2si %xmm0, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2350
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/rra.c
// Function: readData
static void
readData(FILE *in,RRA *w)
    {
    int amp;
    int spot;

    w->samples = w->sampleRate * 10;

    createRRAData(w);

    spot = 0;

    amp = readRRAAmplitude(in,0,w->bitsPerSample,discardComment);
    while (!feof(in))
        {
        if (spot / w->channels == w->samples) growRRA(w);
        w->data[spot % w->channels][spot / w->channels] = amp;
        amp = readRRAAmplitude(in,0,w->bitsPerSample,discardComment);
        ++spot;
        }

    if (spot % w->channels != 0) Warning("channel %d is short\n", spot % w->channels);

    /* remove the excess space in the arrays */

    shrinkRRA(w,spot / w->channels);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
imull $0xa, 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x1b30
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
xorl %eax, %eax
movl %eax, %esi
leaq 0x28b(%rip), %rcx       # 0x2620
callq 0x27e0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x23b7
jmp 0x2443
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cltd
idivl (%rcx)
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x23d3
movq -0x10(%rbp), %rdi
callq 0x2ed0
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cltd
idivl (%rcx)
movq -0x30(%rbp), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cltd
idivl (%rcx)
movl -0x24(%rbp), %edx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
xorl %eax, %eax
movl %eax, %esi
leaq 0x1f3(%rip), %rcx       # 0x2620
callq 0x27e0
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x239d
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cltd
idivl (%rcx)
cmpl $0x0, %edx
je 0x246c
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cltd
idivl (%rcx)
movl %edx, %esi
leaq 0x20c4(%rip), %rdi      # 0x4529
movb $0x0, %al
callq 0x1630
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cltd
idivl (%rcx)
movl %eax, %esi
callq 0x2f00
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x175(%rip), %rdx       # 0x2620
callq 0x2550
movq -0x10(%rbp), %rdi
callq 0x10c0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x24cc
movq $0x0, -0x20(%rbp)
jmp 0x2530
callq 0x1200
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x24ff
movl -0x14(%rbp), %eax
movb %al, -0x22(%rbp)
movb $0x0, -0x21(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x11e0
movq %rax, -0x8(%rbp)
jmp 0x2538
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3d50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x1f82(%rip), %rsi      # 0x449c
callq 0x10f0
cmpl $0x0, %eax
jne 0x252c
movq $0x0, -0x20(%rbp)
jmp 0x252e
jmp 0x2530
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10c0
movl %eax, %ecx
movl %ecx, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x25b7
xorl %eax, %eax
cmpl $-0x1, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0x25b7
callq 0x1200
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1e(%rbp)
jne 0x25b1
cmpl $0x21, -0x1c(%rbp)
sete %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x25c0
jmp 0x2601
cmpl $0xa, -0x1c(%rbp)
jne 0x25d7
movl 0x4b5c(%rip), %eax      # 0x7128
addl $0x1, %eax
movl %eax, 0x4b53(%rip)      # 0x7128
jmp 0x25fc
cmpl $0x21, -0x1c(%rbp)
jne 0x25fa
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl 0x4b37(%rip), %eax      # 0x7128
addl $0x1, %eax
movl %eax, 0x4b2e(%rip)      # 0x7128
jmp 0x25fc
jmp 0x2564
movl -0x1c(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x1160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/rra.c
// Function: readValue
static char *
readValue(FILE *in)
    {
    int ch;
    char *t;

    skipWhiteSpace(in,0,discardComment);

    ch = fgetc(in);

    if (ch == '"')
        {
        t = readString(in);
        }
    else
        {
        t = readToken(in,ch);
        if (strcmp(t,"%%") == 0)
            Fatal("missing value in attribute/value pair");
        }

    return t;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x6b(%rip), %rdx       # 0x2620
callq 0x2550
movq -0x8(%rbp), %rdi
callq 0x10c0
movl %eax, -0xc(%rbp)
cmpl $0x22, -0xc(%rbp)
jne 0x26b1
movq -0x8(%rbp), %rdi
callq 0x3e60
movq %rax, -0x18(%rbp)
jmp 0x26e6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3d50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1dd0(%rip), %rsi      # 0x449c
callq 0x10f0
cmpl $0x0, %eax
jne 0x26e4
leaq 0x1de7(%rip), %rdi      # 0x44c4
movb $0x0, %al
callq 0x1580
jmp 0x26e6
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2744
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x10f0
cmpl $0x0, %eax
jne 0x2736
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x274c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x270c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)