LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xdrawline
void
xdrawline(Line line, int x1, int y1, int x2)
{
	int i, x, ox, numspecs;
	Glyph base, new;
	GlyphFontSpec *specs = xw.specbuf;

	numspecs = xmakeglyphfontspecs(specs, &line[x1], x2 - x1, x1, y1);

	i = ox = 0;
	for (x = x1; x < x2 && i < numspecs; x++) {
		new = line[x];
		if (new.mode == ATTR_WDUMMY)
			continue;
		if (selected(x, y1))
			new.mode ^= ATTR_REVERSE;
		if (i > 0 && ATTRCMP(base, new)) {
			xdrawglyphfontspecs(specs, base, i, ox, y1);
			specs += i;
			numspecs -= i;
			i = 0;
		}
		if (i == 0) {
			ox = x;
			base = new;
		}
		i++;
	}
	if (i > 0)
		xdrawglyphfontspecs(specs, base, i, ox, y1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %r14d
movl %edx, %r8d
movq %rdi, %r12
movq 0x12afc(%rip), %rdi     # 0x1e820
movslq %esi, %r15
movl %ecx, %edx
subl %r15d, %edx
movq %r15, %rbx
shlq $0x4, %rbx
leaq (%rbx,%r12), %rsi
movq %rdi, 0x18(%rsp)
movl %r15d, %ecx
movl %r8d, 0x10(%rsp)
callq 0xbed5
movslq %r14d, %rcx
leaq (%rbx,%r12), %r13
addq $0xc, %r13
movl $0x0, 0xc(%rsp)
xorl %r12d, %r12d
movq %rcx, 0x20(%rsp)
cmpq %rcx, %r15
jge 0xbe94
movl %eax, %ebp
subl %r12d, %ebp
jle 0xbe94
movzwl -0x8(%r13), %ebx
cmpw $0x400, %bx             # imm = 0x400
je 0xbe88
movq %r8, 0x40(%rsp)
movl %eax, 0x14(%rsp)
movl -0xc(%r13), %eax
movq %rax, 0x48(%rsp)
movzwl -0x6(%r13), %eax
movq %rax, 0x50(%rsp)
movl -0x4(%r13), %eax
movq %rax, 0x38(%rsp)
movl (%r13), %eax
movq %rax, 0x30(%rsp)
movl %r15d, %edi
movl 0x10(%rsp), %esi
callq 0x707f
movl %ebx, %r14d
xorl $0x20, %r14d
testl %eax, %eax
cmovel %ebx, %r14d
testl %r12d, %r12d
jle 0xbe07
movq 0x28(%rsp), %rax
shrq $0x20, %rax
cmpw %ax, %r14w
movl 0x14(%rsp), %eax
movq 0x40(%rsp), %r8
jne 0xbe19
cmpl %r8d, 0x38(%rsp)
jne 0xbe19
movq %r8, %rcx
shrq $0x20, %rcx
cmpl %ecx, 0x30(%rsp)
jne 0xbe19
movq 0x20(%rsp), %rcx
jmp 0xbe85
movq 0x20(%rsp), %rcx
movl 0x14(%rsp), %eax
movq 0x40(%rsp), %r8
jne 0xbe85
jmp 0xbe51
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
movq %r8, %rdx
movl %r12d, %ecx
movl 0xc(%rsp), %r8d
movl 0x10(%rsp), %r9d
callq 0xc0b5
movl %r12d, %eax
shlq $0x5, %rax
addq %rax, %rbx
movq %rbx, 0x18(%rsp)
movl %ebp, %eax
movq 0x20(%rsp), %rcx
movzwl %r14w, %edx
shlq $0x20, %rdx
addq 0x48(%rsp), %rdx
movq 0x50(%rsp), %rsi
shlq $0x30, %rsi
orq %rdx, %rsi
movq 0x30(%rsp), %r8
shlq $0x20, %r8
addq 0x38(%rsp), %r8
xorl %r12d, %r12d
movq %rsi, 0x28(%rsp)
movl %r15d, 0xc(%rsp)
incl %r12d
incq %r15
addq $0x10, %r13
jmp 0xbd64
testl %r12d, %r12d
jle 0xbec6
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %r8, %rdx
movl %r12d, %ecx
movl 0xc(%rsp), %r8d
movl 0x10(%rsp), %r9d
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc0b5
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xfinishdraw
void
xfinishdraw(void)
{
	XCopyArea(xw.dpy, xw.buf, xw.win, dc.gc, 0, 0, win.w,
			win.h, 0, 0);
	XSetForeground(xw.dpy, dc.gc,
			dc.col[IS_SET(MODE_REVERSE)?
				defaultfg : defaultbg].pixel);
}

// Assembly:
subq $0x28, %rsp
movq 0x121bb(%rip), %rdi     # 0x1e800
movq 0x121cc(%rip), %rsi     # 0x1e818
movq 0x121bd(%rip), %rdx     # 0x1e810
movq 0x1219e(%rip), %rcx     # 0x1e7f8
movl 0x122d0(%rip), %eax     # 0x1e930
movl 0x122cd(%rip), %r8d     # 0x1e934
andl $0x0, 0x18(%rsp)
andl $0x0, 0x10(%rsp)
movl %r8d, 0x8(%rsp)
movl %eax, (%rsp)
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x63f0
movq 0x12175(%rip), %rdi     # 0x1e800
movq 0x12166(%rip), %rsi     # 0x1e7f8
movq 0x1202f(%rip), %rax     # 0x1e6c8
testb $0x20, 0x122a4(%rip)    # 0x1e944
leaq 0xaf15(%rip), %rcx      # 0x175bc
leaq 0xaf12(%rip), %rdx      # 0x175c0
cmovneq %rcx, %rdx
movl (%rdx), %ecx
shlq $0x4, %rcx
movq (%rax,%rcx), %rdx
addq $0x28, %rsp
jmp 0x6470
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xximspot
void
xximspot(int x, int y)
{
	if (xw.ime.xic == NULL)
		return;
	/* '-1' for underline. */
	XPoint spot = { borderpx + x * win.cw, (y + 1) * win.ch - 1 };
	XVaNestedList attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL);

	xw.ime.spot.x = borderpx + x * win.cw;
	xw.ime.spot.y = (y + 1) * win.ch - 1;

	XSetICValues(xw.ime.xic, XNPreeditAttributes, xw.ime.spotlist, NULL);
	XFree(attr);
}

// Assembly:
cmpq $0x0, 0x1218b(%rip)     # 0x1e858
je 0xc76e
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl %edi, %ebp
movl 0x12257(%rip), %eax     # 0x1e93c
imull %edi, %eax
addl 0xb71e(%rip), %eax      # 0x17e0c
leaq 0xc(%rsp), %rdx
movw %ax, (%rdx)
incl %ebx
movl 0x1223a(%rip), %eax     # 0x1e938
imull %ebx, %eax
decl %eax
movw %ax, 0x2(%rdx)
leaq 0x4792(%rip), %rsi      # 0x10ea0
xorl %edi, %edi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x67d0
imull 0x1221c(%rip), %ebp     # 0x1e93c
addl 0xb6e6(%rip), %ebp      # 0x17e0c
movq %rax, %r14
movw %bp, 0x12130(%rip)      # 0x1e860
imull 0x12201(%rip), %ebx     # 0x1e938
decl %ebx
movw %bx, 0x12122(%rip)      # 0x1e862
movq 0x12111(%rip), %rdi     # 0x1e858
movq 0x1211a(%rip), %rdx     # 0x1e868
leaq 0x4758(%rip), %rsi      # 0x10ead
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x62d0
movq %r14, %rdi
callq 0x6090
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xbell
void
xbell(void)
{
	if (!(IS_SET(MODE_FOCUSED)))
		xseturgency(1);
	if (bellvolume)
		XkbBell(xw.dpy, xw.win, bellvolume, (Atom)NULL);
}

// Assembly:
testb $0x2, 0x12158(%rip)     # 0x1e944
jne 0xc7fb
pushq %rax
pushq $0x1
popq %rdi
callq 0xc81b
addq $0x8, %rsp
movl 0x11ebb(%rip), %edx     # 0x1e6bc
testl %edx, %edx
je 0xc81a
movq 0x11ff4(%rip), %rdi     # 0x1e800
movq 0x11ffd(%rip), %rsi     # 0x1e810
xorl %ecx, %ecx
jmp 0x6a00
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xseturgency
void
xseturgency(int add)
{
	XWMHints *h = XGetWMHints(xw.dpy, xw.win);

	MODBIT(h->flags, add, XUrgencyHint);
	XSetWMHints(xw.dpy, xw.win, h);
	XFree(h);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
testl %edi, %edi
setne %r14b
movq 0x11fd1(%rip), %rdi     # 0x1e800
movq 0x11fda(%rip), %rsi     # 0x1e810
callq 0x6610
movq %rax, %rbx
movq $-0x101, %rax           # imm = 0xFEFF
andq (%rbx), %rax
shll $0x8, %r14d
orq %rax, %r14
movq %r14, (%rbx)
movq 0x11fa7(%rip), %rdi     # 0x1e800
movq 0x11fb0(%rip), %rsi     # 0x1e810
movq %rbx, %rdx
callq 0x6a70
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6090
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: resourceload
int
resourceload(XrmDatabase db, char *name, enum resource_type rtype, void *dst)
{
	char **sdst = dst;
	int *idst = dst;
	float *fdst = dst;

	char fullname[256];
	char fullclass[256];
	char *type;
	XrmValue ret;

	snprintf(fullname, sizeof(fullname), "%s.%s",
			opt_name ? opt_name : "st", name);
	snprintf(fullclass, sizeof(fullclass), "%s.%s",
			opt_class ? opt_class : "St", name);
	fullname[sizeof(fullname) - 1] = fullclass[sizeof(fullclass) - 1] = '\0';

	XrmGetResource(db, fullname, fullclass, &type, &ret);
	if (ret.addr == NULL || strncmp("String", type, 64))
		return 1;

	switch (rtype) {
	case STRING:
		*sdst = ret.addr;
		break;
	case INTEGER:
		*idst = strtoul(ret.addr, NULL, 10);
		break;
	case FLOAT:
		*fdst = strtof(ret.addr, NULL);
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rcx, 0x8(%rsp)
movl %edx, 0x14(%rsp)
movq %rsi, %r15
movq %rdi, %r14
movq 0x120ba(%rip), %rax     # 0x1e958
testq %rax, %rax
leaq 0x461d(%rip), %rcx      # 0x10ec5
cmovneq %rax, %rcx
leaq 0x460c(%rip), %r13      # 0x10ebf
xorl %ebp, %ebp
leaq 0x130(%rsp), %r12
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x60c0
movq 0x12087(%rip), %rax     # 0x1e960
testq %rax, %rax
leaq 0x45e5(%rip), %rcx      # 0x10ec8
cmovneq %rax, %rcx
leaq 0x30(%rsp), %rbx
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %r13, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x60c0
movb %bpl, 0xff(%rbx)
movb %bpl, 0xff(%r12)
leaq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %r8
callq 0x6930
movq 0x8(%r15), %r15
pushq $0x1
popq %r14
testq %r15, %r15
je 0xc950
movq 0x18(%rsp), %rsi
leaq 0x4587(%rip), %rdi      # 0x10ecb
pushq $0x40
popq %rdx
callq 0x6220
testl %eax, %eax
je 0xc965
movl %r14d, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x14(%rsp), %eax
xorl %r14d, %r14d
cmpl $0x2, %eax
je 0xc99a
cmpl $0x1, %eax
je 0xc984
testl %eax, %eax
jne 0xc950
movq 0x8(%rsp), %rax
movq %r15, (%rax)
jmp 0xc950
pushq $0xa
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x6a20
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
jmp 0xc950
movq %r15, %rdi
xorl %esi, %esi
callq 0x6580
movq 0x8(%rsp), %rax
movss %xmm0, (%rax)
jmp 0xc950
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: xhints
void
xhints(void)
{
	XClassHint class = {opt_name ? opt_name : "st",
	                    opt_class ? opt_class : "St"};
	XWMHints wm = {.flags = InputHint, .input = 1};
	XSizeHints *sizeh;

	sizeh = XAllocSizeHints();

	sizeh->flags = PSize | PResizeInc | PBaseSize | PMinSize;
	sizeh->height = win.h;
	sizeh->width = win.w;
	sizeh->height_inc = win.ch;
	sizeh->width_inc = win.cw;
	sizeh->base_height = 2 * borderpx;
	sizeh->base_width = 2 * borderpx;
	sizeh->min_height = win.ch + 2 * borderpx;
	sizeh->min_width = win.cw + 2 * borderpx;
	if (xw.isfixed) {
		sizeh->flags |= PMaxSize;
		sizeh->min_width = sizeh->max_width = win.w;
		sizeh->min_height = sizeh->max_height = win.h;
	}
	if (xw.gm & (XValue|YValue)) {
		sizeh->flags |= USPosition | PWinGravity;
		sizeh->x = xw.l;
		sizeh->y = xw.t;
		sizeh->win_gravity = xgeommasktogravity(xw.gm);
	}

	XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, sizeh, &wm,
			&class);
	XFree(sizeh);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq 0x10acf(%rip), %rax     # 0x1e958
testq %rax, %rax
leaq 0x3032(%rip), %rcx      # 0x10ec5
cmovneq %rax, %rcx
movq 0x10ac2(%rip), %rax     # 0x1e960
testq %rax, %rax
leaq 0x3020(%rip), %rdx      # 0x10ec8
cmovneq %rax, %rdx
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movq $0x1, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
callq 0x68f0
movq %rax, %rbx
movq $0x158, (%rax)          # imm = 0x158
movl 0x10a46(%rip), %eax     # 0x1e934
movl %eax, 0x14(%rbx)
movl 0x10a39(%rip), %ecx     # 0x1e930
movl %ecx, 0x10(%rbx)
movl 0x10a38(%rip), %edx     # 0x1e938
movl %edx, 0x2c(%rbx)
movl 0x10a33(%rip), %esi     # 0x1e93c
movl %esi, 0x28(%rbx)
movl 0x9efa(%rip), %edi      # 0x17e0c
leal (%rdi,%rdi), %r8d
movl %r8d, 0x44(%rbx)
movl %r8d, 0x40(%rbx)
leal (%rdx,%rdi,2), %edx
movl %edx, 0x1c(%rbx)
leal (%rsi,%rdi,2), %edx
movl %edx, 0x18(%rbx)
cmpl $0x0, 0x109c3(%rip)     # 0x1e8f4
je 0xdf4d
movq $0x178, (%rbx)          # imm = 0x178
movl %ecx, 0x20(%rbx)
movl %ecx, 0x18(%rbx)
movl %eax, 0x24(%rbx)
movl %eax, 0x1c(%rbx)
movl $0x379, %ecx            # imm = 0x379
jmp 0xdf52
movl $0x359, %ecx            # imm = 0x359
movl 0x109a8(%rip), %eax     # 0x1e900
testb $0x3, %al
je 0xdf7d
movq %rcx, (%rbx)
movq 0x10992(%rip), %rcx     # 0x1e8f8
movq %rcx, 0x8(%rbx)
shrl $0x2, %eax
andl $0xc, %eax
leaq 0x2d59(%rip), %rcx      # 0x10cd0
movl (%rax,%rcx), %eax
movl %eax, 0x48(%rbx)
movq 0x1087c(%rip), %rdi     # 0x1e800
movq 0x10885(%rip), %rsi     # 0x1e810
subq $0x8, %rsp
leaq 0x10(%rsp), %rax
leaq 0x20(%rsp), %r10
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %rbx
callq 0x6390
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x6090
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/odknt[P]st/x.c
// Function: cresize
void
cresize(int width, int height)
{
	int col, row;

	if (width != 0)
		win.w = width;
	if (height != 0)
		win.h = height;

	col = (win.w - 2 * borderpx) / win.cw;
	row = (win.h - 2 * borderpx) / win.ch;
	col = MAX(1, col);
	row = MAX(1, row);

	tresize(col, row);
	xresize(col, row);
	ttyresize(win.tw, win.th);
}

// Assembly:
testl %edi, %edi
je 0xe311
movl %edi, 0x1061f(%rip)     # 0x1e930
testl %esi, %esi
je 0xe31d
movl %esi, 0x10619(%rip)     # 0x1e934
jmp 0xe323
movl 0x10611(%rip), %esi     # 0x1e934
pushq %rbp
pushq %r14
pushq %rbx
movl 0x10603(%rip), %eax     # 0x1e930
movl 0x9ad9(%rip), %ecx      # 0x17e0c
addl %ecx, %ecx
subl %ecx, %eax
cltd
idivl 0x105fe(%rip)           # 0x1e93c
movl %eax, %ebx
subl %ecx, %esi
movl %esi, %eax
cltd
idivl 0x105ed(%rip)           # 0x1e938
cmpl $0x2, %ebx
pushq $0x1
popq %rbp
cmovll %ebp, %ebx
cmpl $0x2, %eax
cmovgel %eax, %ebp
movl %ebx, %edi
movl %ebp, %esi
callq 0x7f04
movl 0x105d3(%rip), %eax     # 0x1e93c
imull %ebx, %eax
imull 0x105c5(%rip), %ebp     # 0x1e938
movl %eax, 0x105af(%rip)     # 0x1e928
movl %ebp, 0x105ad(%rip)     # 0x1e92c
movq 0x1047a(%rip), %rdi     # 0x1e800
movq 0x1048b(%rip), %rsi     # 0x1e818
callq 0x6900
movq 0x104d7(%rip), %rdi     # 0x1e870
callq 0x6160
movq 0x1045b(%rip), %rdi     # 0x1e800
movq 0x10464(%rip), %rsi     # 0x1e810
movl 0x1057e(%rip), %edx     # 0x1e930
movl 0x1057c(%rip), %ecx     # 0x1e934
movq 0xe8(%rdi), %rax
movslq 0x1052a(%rip), %r8      # 0x1e8f0
shlq $0x7, %r8
movl 0x38(%rax,%r8), %r8d
callq 0x69b0
movq %rax, 0x1043d(%rip)     # 0x1e818
movq 0x1041e(%rip), %rdi     # 0x1e800
movq 0x1048f(%rip), %rdx     # 0x1e878
movl 0x10541(%rip), %ecx     # 0x1e930
movl 0x1053e(%rip), %r8d     # 0x1e934
movq %rax, %rsi
callq 0x6520
movq %rax, %r14
movq %rax, %rdi
callq 0x6500
movq %rax, 0x10460(%rip)     # 0x1e870
movq %r14, %rdi
callq 0x6890
movl 0x10512(%rip), %edx     # 0x1e930
movl 0x10510(%rip), %ecx     # 0x1e934
xorl %edi, %edi
xorl %esi, %esi
callq 0xd832
movq 0x103ec(%rip), %rdi     # 0x1e820
shlq $0x5, %rbx
movq %rbx, %rsi
callq 0x6c8e
movq %rax, 0x103d9(%rip)     # 0x1e820
movl 0x104db(%rip), %edi     # 0x1e928
movl 0x104d9(%rip), %esi     # 0x1e92c
popq %rbx
popq %r14
popq %rbp
jmp 0x7d3d
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x54(%rdi), %r14d
leal -0x1(%r14), %ecx
cmpl $0xa, %ecx
ja 0xe660
pushq $0x1
popq %rax
shll %cl, %eax
orl %eax, 0x10398(%rip)     # 0x1e9f8
movzwl 0x102dd(%rip), %eax     # 0x1e944
testw $0xc018, %ax            # imm = 0xC018
je 0xe683
testb $0x1, 0x50(%rbx)
jne 0xe683
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xeeb0
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf069
cmpl $0x1, %r14d
jne 0xe76d
testl %eax, %eax
jne 0xe76d
pushq $0x1
popq %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x6140
movq (%r14), %rax
movq %rax, %rcx
subq 0x10306(%rip), %rcx     # 0x1e9c0
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
cvtsi2sd %rcx, %xmm0
movq 0x8(%r14), %rcx
movq %rcx, %rdx
subq 0x102f4(%rip), %rdx     # 0x1e9c8
cvtsi2sd %rdx, %xmm1
divsd 0x2577(%rip), %xmm1     # 0x10c58
addsd %xmm0, %xmm1
movsd 0x2593(%rip), %xmm0     # 0x10c80
ucomisd %xmm1, %xmm0
jae 0xe732
subq 0x102b6(%rip), %rax     # 0x1e9b0
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
cvtsi2sd %rax, %xmm0
subq 0x102ab(%rip), %rcx     # 0x1e9b8
cvtsi2sd %rcx, %xmm1
divsd 0x253e(%rip), %xmm1     # 0x10c58
addsd %xmm0, %xmm1
movsd 0x2562(%rip), %xmm0     # 0x10c88
xorl %ebp, %ebp
ucomisd %xmm1, %xmm0
setae %bpl
jmp 0xe735
pushq $0x2
popq %rbp
movups 0x10274(%rip), %xmm0    # 0x1e9b0
movups %xmm0, 0x1027d(%rip)    # 0x1e9c0
movups (%rsp), %xmm0
movups %xmm0, 0x10262(%rip)    # 0x1e9b0
movq %rbx, %rdi
callq 0xf0f6
movl %eax, %r14d
movq %rbx, %rdi
callq 0xf11a
movl %r14d, %edi
movl %eax, %esi
movl %ebp, %edx
callq 0x6db6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe795
pushq $-0x2
popq %rax
roll %cl, %eax
andl %eax, 0x10263(%rip)     # 0x1e9f8
movzwl 0x101a8(%rip), %eax     # 0x1e944
testw $0xc018, %ax            # imm = 0xC018
je 0xe7b7
testb $0x1, 0x50(%rbx)
jne 0xe7b7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xeeb0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf069
cmpl $0x1, %r14d
jne 0xe7de
testl %eax, %eax
jne 0xe7de
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf159
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe80e
popq %rax
retq
cmpl $0x9, (%rdi)
movq 0x10040(%rip), %rdi     # 0x1e858
jne 0xe844
testq %rdi, %rdi
je 0xe824
callq 0x6760
orb $0x2, 0x10119(%rip)     # 0x1e944
xorl %edi, %edi
callq 0xc81b
testb $0x20, 0x1010c(%rip)    # 0x1e945
je 0xe80c
leaq 0x2e5d(%rip), %rdi      # 0x1169f
jmp 0xe86c
testq %rdi, %rdi
je 0xe84e
callq 0x6490
movl 0x100f0(%rip), %eax     # 0x1e944
movl %eax, %ecx
andl $-0x3, %ecx
movl %ecx, 0x100e5(%rip)     # 0x1e944
btl $0xd, %eax
jae 0xe80c
leaq 0x2e37(%rip), %rdi      # 0x116a3
pushq $0x3
popq %rsi
xorl %edx, %edx
popq %rax
jmp 0x7aae
// File: /workspace/github_c_makefile_star2_O2/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 0xff34(%rip), %rdi      # 0x1e800
leaq 0x26be(%rip), %rsi      # 0x10f91
xorl %edx, %edx
callq 0x6860
cmpl $0x0, 0x38(%rbx)
jne 0xe8ef
movq 0x28(%rbx), %rcx
cmpq $0x1, %rcx
je 0xe8f1
cmpq %rax, %rcx
je 0xe8f1
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0xea8d
// File: /workspace/github_c_makefile_star2_O2/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 0xfb41(%rip), %rax      # 0x1e828
jne 0xed0d
cmpl $0x20, 0x30(%rdi)
jne 0xed0d
movq 0x40(%rdi), %rax
cmpq $0x5, %rax
je 0xed1b
cmpq $0x4, %rax
jne 0xed1a
orb $0x2, 0xfc3e(%rip)      # 0x1e944
xorl %edi, %edi
jmp 0xc81b
movq 0x38(%rdi), %rax
cmpq 0xfb18(%rip), %rax      # 0x1e830
je 0xed23
retq
andb $-0x3, 0xfc22(%rip)     # 0x1e944
retq
pushq %rax
callq 0x7da8
xorl %edi, %edi
callq 0x61b0
// File: /workspace/github_c_makefile_star2_O2/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 0xfa81(%rip), %rdi      # 0x1e800
leaq 0x220b(%rip), %rsi      # 0x10f91
xorl %edx, %edx
callq 0x6860
movq 0xfa6c(%rip), %rdi      # 0x1e800
movq 0xfbfd(%rip), %rdx      # 0x1e998
movq 0xfa6e(%rip), %r8       # 0x1e810
movq %rax, %rsi
movq %rax, %rcx
xorl %r9d, %r9d
popq %rax
jmp 0x61f0
// File: /workspace/github_c_makefile_star2_O2/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 0xee09
movq 0xfbf4(%rip), %rdi      # 0x1e9e0
cvtss2sd (%rbx), %xmm0
callq 0xd876
xorl %edi, %edi
xorl %esi, %esi
callq 0xe307
callq 0x8c35
popq %rbx
jmp 0xde7d
// File: /workspace/github_c_makefile_star2_O2/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:
subq $0x18, %rsp
movl 0xfaf5(%rip), %eax      # 0x1e908
testl %eax, %eax
jle 0xee43
movq 0xfaf2(%rip), %rcx      # 0x1e910
decl %eax
movl %eax, 0xfae2(%rip)      # 0x1e908
shlq $0x5, %rax
movq 0x10(%rcx,%rax), %rdx
movq %rdx, 0x10(%rsp)
movups (%rcx,%rax), %xmm0
movups %xmm0, (%rsp)
callq 0xb5be
jmp 0xee0d
leaq 0xf88e(%rip), %rdi      # 0x1e6d8
callq 0xee74
leaq 0xf8ca(%rip), %rdi      # 0x1e720
callq 0xee74
leaq 0xf906(%rip), %rdi      # 0x1e768
callq 0xee74
leaq 0xf942(%rip), %rdi      # 0x1e7b0
addq $0x18, %rsp
jmp 0xee74
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rdi), %xmm0
movups %xmm0, (%rsp)
callq 0xb5be
movq 0x40(%rbx), %rdi
callq 0x6050
movq 0x38(%rbx), %rdi
addq $0x20, %rsp
testq %rdi, %rdi
je 0xeeae
popq %rbx
jmp 0x6600
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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), %eax
movl 0x54(%rdi), %ecx
leal -0x1(%rcx), %edx
cmpl $0x4, %edx
jae 0xf085
movl %edx, %edx
leaq 0x1c60(%rip), %rdi      # 0x10ce0
movl (%rdi,%rdx,4), %edx
jmp 0xf095
xorl %edx, %edx
cmpl $0x5, %ecx
setne %dl
negl %edx
orl $0xffffefff, %edx       # imm = 0xFFFFEFFF
andl %eax, %edx
movl %edx, %edi
andl $0xffff9fef, %edi       # imm = 0xFFFF9FEF
andl $0xffff9fee, %edx       # imm = 0xFFFF9FEE
xorl %eax, %eax
leaq 0x92c2(%rip), %r8       # 0x18370
xorl %r9d, %r9d
cmpq $0x9f, %r9
ja 0xf0f5
cmpl %esi, 0x18(%r9,%r8)
jne 0xf0dc
cmpl %ecx, 0x4(%r9,%r8)
jne 0xf0dc
movl (%r9,%r8), %r10d
cmpl $-0x1, %r10d
je 0xf0e2
cmpl %r10d, %edi
je 0xf0e2
cmpl %r10d, %edx
je 0xf0e2
addq $0x20, %r9
jmp 0xf0b1
pushq %rax
leaq (%r9,%r8), %rdi
addq $0x10, %rdi
callq *-0x8(%rdi)
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0xffff9eee, %eax       # imm = 0xFFFF9EEE
andl 0x50(%rdi), %eax
xorl %r14d, %r14d
cmpl $0x8, %eax
sete %r14b
incl %r14d
callq 0xf0f6
movl %eax, %r15d
movq %rbx, %rdi
callq 0xf11a
movl %r15d, %edi
movl %eax, %esi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x6f9f
testl %ebp, %ebp
je 0xf1b8
callq 0x710b
movq 0x38(%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb2df
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movslq %edi, %r13
cmpl $0x2, %r13d
pushq $0x1
popq %rax
cmovgel %edi, %eax
movl %eax, -0x2c(%rbp)
pushq $0x1
popq %r12
leaq 0x1ca5(%rip), %r15      # 0x3020
cmpq %r13, %r12
jge 0x13a2
movq (%rbx,%r12,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x13a7
cmpb $0x76, 0x1(%rsi)
je 0x1459
movq %r15, %rdi
xorl %eax, %eax
callq 0x1490
incq %r12
jmp 0x137b
movl -0x2c(%rbp), %eax
jmp 0x13aa
movl %r12d, %eax
subl %eax, %r14d
je 0x13d5
cmpl $0x1, %r14d
jne 0x147c
cltq
movq (%rbx,%rax,8), %rdi
testq %rdi, %rdi
je 0x13d5
leaq 0x213f(%rip), %rsi      # 0x350a
callq 0x15c0
movq %rax, %rbx
jmp 0x13d7
xorl %ebx, %ebx
callq 0x181c
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1b81
leaq 0x142a(%rip), %r15      # 0x281d
leaq 0x1db3(%rip), %r12      # 0x31ad
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x1160
testl %eax, %eax
jne 0x1440
movl (%r14), %eax
imull 0xc(%r14), %eax
cmpl %eax, %r13d
jge 0x1440
movq 0x4bbb(%rip), %rax      # 0x5fd8
movq (%rax), %rsi
movl 0x8(%r14), %edx
movq %rbx, %rdi
movq %r15, %rcx
callq 0x2056
movq %r12, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x10b0
incl %r13d
jmp 0x13fd
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 0x4cd8(%rip), %rsi      # 0x6138
movq 0x4cd9(%rip), %rdx      # 0x6140
leaq 0x1ba3(%rip), %rdi      # 0x3011
xorl %eax, %eax
callq 0x10b0
xorl %edi, %edi
callq 0x1200
leaq 0x1bb7(%rip), %rdi      # 0x303a
callq 0x1070
pushq $-0x1
popq %rdi
callq 0x1200
// File: /workspace/github_c_makefile_star2_O2/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 0x15dc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movzbl (%r14), %eax
cmpl $0x61, %eax
je 0x1601
cmpl $0x77, %eax
je 0x15f8
cmpl $0x72, %eax
jne 0x1614
leaq 0x1a9a(%rip), %rdx      # 0x3090
jmp 0x1608
leaq 0x1a89(%rip), %rdx      # 0x3088
jmp 0x1608
leaq 0x1a90(%rip), %rdx      # 0x3098
leaq 0x1a93(%rip), %rdi      # 0x30a2
movq %rbx, %rsi
jmp 0x1621
leaq 0x1aab(%rip), %rdi      # 0x30c6
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1490
// File: /workspace/github_c_makefile_star2_O2/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 0x1657
popq %rbx
retq
leaq 0x1a8f(%rip), %rdi      # 0x30ed
movl %ebx, %esi
xorl %eax, %eax
callq 0x1490
// File: /workspace/github_c_makefile_star2_O2/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 0x16ef
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x19f5(%rip), %rdi      # 0x30eb
movl %ebx, %esi
xorl %eax, %eax
callq 0x1490
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x40
popq %rdi
callq 0x1645
movq %rax, %r12
movl %r15d, 0x4(%rax)
movl %r14d, 0x8(%rax)
movl %ebp, (%rax)
andl $0x0, 0x10(%rax)
movl %ebx, 0xc(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
andq $0x0, 0x38(%rax)
movq %rax, %rdi
callq 0x17d6
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x181b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
shll $0x3, %edi
callq 0x1645
movq %rax, 0x18(%rbx)
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x1814
movl 0xc(%rbx), %edi
shll $0x2, %edi
callq 0x1645
movq 0x18(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
jmp 0x17f4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0xc(%rdi), %ecx
testl %ecx, %ecx
je 0x1873
xorl %eax, %eax
movslq (%rdi), %rdx
cmpq %rdx, %rax
jge 0x1873
xorl %edx, %edx
movslq %ecx, %rsi
cmpq %rsi, %rdx
jge 0x186e
movq 0x18(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
andl $0x0, (%rcx,%rdx,4)
incq %rdx
movl 0xc(%rdi), %ecx
jmp 0x1852
incq %rax
jmp 0x1848
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x1645
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x64(%rip), %r15        # 0x193d
cmovneq %rsi, %r15
cmpq $0x0, 0x18(%rdi)
je 0x1906
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x18(%rbx), %rdi
cmpq %rax, %r14
jge 0x1901
movq (%rdi,%r14,8), %rdi
callq 0x1040
incq %r14
jmp 0x18e7
callq 0x1040
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x192a
movq 0x10(%r14), %r12
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq *%r15
movq %r14, %rdi
callq 0x1040
movq %r12, %r14
jmp 0x190a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl (%rdi), %edx
movl 0x4(%rdi), %edi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %ecx
callq 0x1788
movq %rax, %r14
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
xorl %eax, %eax
movslq (%rbx), %rcx
cmpq %rcx, %rax
jge 0x19ac
xorl %ecx, %ecx
movslq 0xc(%rbx), %rdx
cmpq %rdx, %rcx
jge 0x19a7
movq 0x18(%rbx), %rdx
movq (%rdx,%rax,8), %rdx
movl (%rdx,%rcx,4), %edx
movq 0x18(%r14), %rsi
movq (%rsi,%rax,8), %rsi
movl %edx, (%rsi,%rcx,4)
incq %rcx
jmp 0x1983
incq %rax
jmp 0x1979
testq %r15, %r15
leaq 0x3e(%rip), %r12        # 0x19f4
cmovneq %r15, %r12
leaq 0x28(%rbx), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x19de
movq %r15, %rdi
callq *%r12
movq 0x28(%r14), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x28(%r14)
addq $0x10, %r15
jmp 0x19be
movl 0x20(%rbx), %eax
movl %eax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1750(%rip), %rdi      # 0x3180
xorl %eax, %eax
callq 0x10b0
movl 0x4(%rbx), %esi
leaq 0x174d(%rip), %rdi      # 0x318e
xorl %eax, %eax
callq 0x10b0
movl 0x8(%rbx), %esi
leaq 0x174c(%rip), %rdi      # 0x319e
xorl %eax, %eax
callq 0x10b0
movl 0x10(%rbx), %esi
leaq 0x174e(%rip), %rdi      # 0x31b1
xorl %eax, %eax
callq 0x10b0
movl 0xc(%rbx), %esi
leaq 0x1747(%rip), %rdi      # 0x31bb
xorl %eax, %eax
callq 0x10b0
movl 0x20(%rbx), %esi
leaq 0x1743(%rip), %rdi      # 0x31c8
xorl %eax, %eax
popq %rbx
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %r14
callq 0x181c
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1b81
movl 0x8(%rbx), %edi
decl %edi
movsd 0x1692(%rip), %xmm0     # 0x3150
callq 0x1050
cvttsd2si %xmm0, %eax
movl %eax, 0x20(%rbx)
imull $0xa, 0x4(%rbx), %eax
movl %eax, 0xc(%rbx)
movq %rbx, %rdi
callq 0x17d6
movl 0x8(%rbx), %edx
leaq 0x4c7(%rip), %r12       # 0x1faa
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x2056
movl %eax, %ebp
movq %r14, %rdi
callq 0x1160
movl %eax, %esi
movl (%rbx), %edi
movl %r15d, %eax
cltd
idivl %edi
testl %esi, %esi
jne 0x1b4f
movl %eax, %ecx
cmpl 0xc(%rbx), %eax
jne 0x1b24
movq %rbx, %rdi
callq 0x24b9
movl (%rbx), %edi
movl %r15d, %eax
cltd
idivl %edi
movl %eax, %ecx
movq 0x18(%rbx), %rsi
movl %r15d, %eax
cltd
idivl %edi
movq (%rsi,%rdx,8), %rax
movslq %ecx, %rcx
movl %ebp, (%rax,%rcx,4)
movl 0x8(%rbx), %edx
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x2056
movl %eax, %ebp
incl %r15d
jmp 0x1af5
testl %edx, %edx
je 0x1b65
leaq 0x19f1(%rip), %rdi      # 0x354b
movl %edx, %esi
xorl %eax, %eax
callq 0x1528
movl (%rbx), %edi
movl %r15d, %eax
cltd
idivl %edi
movq %rbx, %rdi
movl %eax, %esi
callq 0x24c3
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
leaq 0xe3(%rip), %rdx        # 0x1faa
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x1f35
movq %r14, %rdi
callq 0x10e0
cmpl $-0x1, %eax
je 0x1f29
movl %eax, %ebp
callq 0x1240
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x1f15
movq %r14, %rdi
movl %ebp, %esi
callq 0x2d55
movq %rax, %rbx
cmpb $0x25, (%rax)
jne 0x1f29
cmpb $0x25, 0x1(%rbx)
jne 0x1f29
xorl %eax, %eax
cmpb $0x0, 0x2(%rbx)
cmoveq %rax, %rbx
jmp 0x1f29
leaq 0xe(%rsp), %rdi
movb %bpl, (%rdi)
movb $0x0, 0x1(%rdi)
callq 0x1220
movq %rax, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x10e0
movl %eax, %r12d
leal -0x1(%r12), %eax
cmpl $-0x3, %eax
ja 0x1f94
callq 0x1240
cmpl $0x21, %r12d
je 0x1f77
movq (%rax), %rax
movslq %r12d, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
je 0x1f94
cmpl $0xa, %r12d
je 0x1f8c
cmpl $0x21, %r12d
jne 0x1f46
movq %rbx, %rdi
movq %r15, %rsi
callq *%r14
incl 0x41b6(%rip)            # 0x6148
jmp 0x1f46
movl %r12d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %r15
movq %rdi, %r14
addq $0x28, %r14
xorl %ebx, %ebx
movq (%r14), %r14
testq %r14, %r14
je 0x2002
movq (%r14), %rsi
movq %r15, %rdi
callq 0x1120
testl %eax, %eax
je 0x1ffe
addq $0x10, %r14
jmp 0x1fe1
movq 0x8(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
addq $0x28, %r15
xorl %ebx, %ebx
movq (%r15), %r15
testq %r15, %r15
je 0x2047
movq (%r15), %rsi
movq %r12, %rdi
callq 0x1120
testl %eax, %eax
je 0x203f
addq $0x10, %r15
jmp 0x2022
movq 0x8(%r15), %rbx
movq %r14, 0x8(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r13d, %r13d
leaq 0x7(%rsp), %r14
pushq $0x1
popq %r15
pushq $0x1
popq %rbp
pushq $-0x2
popq %r12
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1110
movzbl 0x7(%rsp), %eax
cmpl $0x21, %eax
je 0x2428
cmpl $0xa, %eax
jne 0x242b
jmp 0x2439
movl %ebp, %r13d
movl %ebx, %edi
movq %r12, %rsi
movl %ebp, %edx
callq 0x10c0
jmp 0x240a
testl %r13d, %r13d
je 0x2460
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
movl %ebx, %edi
callq 0x10c0
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x23ea
leaq 0x7(%rsp), %r14
pushq $0x1
popq %r15
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1110
callq 0x1240
movq %rax, %r12
movq (%r12), %rax
movsbq 0x7(%rsp), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x249e
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1110
jmp 0x247e
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0xc(%rdi)
shll $0x2, %ebx
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r15
jge 0x24fa
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rdi
movl %ebx, %esi
callq 0x16c6
movq 0x18(%r14), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x24d6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl 0xc(%rsi), %r13d
movl %r13d, %eax
subl 0x10(%rsi), %eax
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %eax
movl %eax, 0xc(%rsi)
callq 0x2590
testl %r13d, %r13d
cmovlel %r12d, %r13d
movq %r13, (%rsp)
leaq 0xc6c(%rip), %r12       # 0x31ad
xorl %ebp, %ebp
cmpq (%rsp), %rbp
je 0x2581
xorl %r13d, %r13d
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x257c
movslq 0x10(%r14), %rax
cmpq %rax, %rbp
jl 0x2577
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
jmp 0x254c
incq %rbp
jmp 0x2543
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rbx
leaq 0xe6d(%rip), %r15       # 0x3560
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2754
movq 0x8(%rbx), %r12
movq %r12, %rdi
callq 0x10a0
movq %rax, %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
jbe 0x2731
callq 0x1240
movq (%rax), %rax
movsbq (%r12,%rbp), %rcx
incq %rbp
testb $0x20, 0x1(%rax,%rcx,2)
je 0x270c
leaq 0xe3d(%rip), %rcx       # 0x356c
jmp 0x2738
leaq 0xd1a(%rip), %rcx       # 0x3452
movq (%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %r8
movq %rcx, %r9
xorl %eax, %eax
callq 0x1140
addq $0x10, %rbx
jmp 0x26f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq