LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: xgetcolor
int
xgetcolor(int x, unsigned char *r, unsigned char *g, unsigned char *b)
{
	if (!BETWEEN(x, 0, dc.collen - 1))
		return 1;

	*r = dc.col[x].color.red >> 8;
	*g = dc.col[x].color.green >> 8;
	*b = dc.col[x].color.blue >> 8;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jg 0xf1ee
movslq -0x8(%rbp), %rax
movq 0x125db(%rip), %rcx     # 0x217c0
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0xf1f7
movl $0x1, -0x4(%rbp)
jmp 0xf261
movq 0x125ba(%rip), %rax     # 0x217b8
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x8(%rax), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq 0x12599(%rip), %rax     # 0x217b8
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0xa(%rax), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq 0x12578(%rip), %rax     # 0x217b8
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0xc(%rax), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: xsetcolorname
int
xsetcolorname(int x, const char *name)
{
	Color ncolor;

	if (!BETWEEN(x, 0, dc.collen - 1))
		return 1;

	if (!xloadcolor(x, name, &ncolor))
		return 1;

	XftColorFree(xw.dpy, xw.vis, xw.cmap, &dc.col[x]);
	dc.col[x] = ncolor;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jg 0xf29a
movslq -0x8(%rbp), %rax
movq 0x1252f(%rip), %rcx     # 0x217c0
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0xf2a3
movl $0x1, -0x4(%rbp)
jmp 0xf315
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xf080
cmpl $0x0, %eax
jne 0xf2c1
movl $0x1, -0x4(%rbp)
jmp 0xf315
movq 0x125e8(%rip), %rdi     # 0x218b0
movq 0x12659(%rip), %rsi     # 0x21928
movq 0x125e2(%rip), %rdx     # 0x218b8
movq 0x124db(%rip), %rcx     # 0x217b8
movslq -0x8(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
callq 0x6610
movq 0x124c4(%rip), %rax     # 0x217b8
movslq -0x8(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: xseticontitle
void
xseticontitle(char *p)
{
	XTextProperty prop;
	DEFAULT(p, opt_title);

	if (p[0] == '\0')
		p = opt_title;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf71d
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xf728
movq 0x122bc(%rip), %rax     # 0x219e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xf747
movq 0x1229d(%rip), %rax     # 0x219e0
movq %rax, -0x8(%rbp)
movq 0x12162(%rip), %rdi     # 0x218b0
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0x28(%rbp), %r8
callq 0x6440
cmpl $0x0, %eax
je 0xf76c
jmp 0xf7aa
movq 0x1213d(%rip), %rdi     # 0x218b0
movq 0x12146(%rip), %rsi     # 0x218c0
leaq -0x28(%rbp), %rdx
callq 0x6340
movq 0x12126(%rip), %rdi     # 0x218b0
movq 0x1212f(%rip), %rsi     # 0x218c0
movq 0x12158(%rip), %rcx     # 0x218f0
leaq -0x28(%rbp), %rdx
callq 0x6460
movq -0x28(%rbp), %rdi
callq 0x6090
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: xsettitle
void
xsettitle(char *p)
{
	XTextProperty prop;
	DEFAULT(p, opt_title);

	if (p[0] == '\0')
		p = opt_title;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf7cd
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xf7d8
movq 0x1220c(%rip), %rax     # 0x219e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xf7f7
movq 0x121ed(%rip), %rax     # 0x219e0
movq %rax, -0x8(%rbp)
movq 0x120b2(%rip), %rdi     # 0x218b0
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0x28(%rbp), %r8
callq 0x6440
cmpl $0x0, %eax
je 0xf81c
jmp 0xf85a
movq 0x1208d(%rip), %rdi     # 0x218b0
movq 0x12096(%rip), %rsi     # 0x218c0
leaq -0x28(%rbp), %rdx
callq 0x6400
movq 0x12076(%rip), %rdi     # 0x218b0
movq 0x1207f(%rip), %rsi     # 0x218c0
movq 0x120a0(%rip), %rcx     # 0x218e8
leaq -0x28(%rbp), %rdx
callq 0x6460
movq -0x28(%rbp), %rdi
callq 0x6090
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: xximspot
void
xximspot(int x, int y)
{
	if (xw.ime.xic == NULL)
		return;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpq $0x0, 0x10fd2(%rip)     # 0x21908
jne 0x1093a
jmp 0x1098f
movl 0xb6f4(%rip), %eax      # 0x1c034
movl -0x4(%rbp), %ecx
imull 0x1108a(%rip), %ecx     # 0x219d4
addl %ecx, %eax
movw %ax, 0x10fbd(%rip)      # 0x21910
movl 0xb6db(%rip), %eax      # 0x1c034
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
imull 0x1106a(%rip), %ecx     # 0x219d0
addl %ecx, %eax
movw %ax, 0x10fa3(%rip)      # 0x21912
movq 0x10f92(%rip), %rdi     # 0x21908
movq 0x10f9b(%rip), %rdx     # 0x21918
leaq 0x67bd(%rip), %rsi      # 0x17141
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x6290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: config_init
void
config_init(void)
{
	char *resm;
	XrmDatabase db;
	ResourcePref *p;

	XrmInitialize();
	resm = XResourceManagerString(xw.dpy);
	if (!resm)
		return;

	db = XrmGetStringDatabase(resm);
	for (p = resources; p < resources + LEN(resources); p++)
		resource_load(db, p->name, p->type, p->dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x6580
movq 0x10b4c(%rip), %rdi     # 0x218b0
callq 0x6180
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10d76
jmp 0x10dce
movq -0x8(%rbp), %rdi
callq 0x66e0
movq %rax, -0x10(%rbp)
leaq 0xb2b6(%rip), %rax      # 0x1c040
movq %rax, -0x18(%rbp)
leaq 0xb2ab(%rip), %rax      # 0x1c040
addq $0x330, %rax            # imm = 0x330
cmpq %rax, -0x18(%rbp)
jae 0x10dce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0x10b80
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x10d8e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: opencopied
void
opencopied(const Arg *arg)
{
	size_t const max_cmd = 2048;
	char * const clip = xsel.clipboard;
	if(!clip) {
		fprintf(stderr, "Warning: nothing copied to clipboard\n");
		return;
	}

	/* account for space/quote (3) and \0 (1) and & (1) */
	/* e.g.: xdg-open "https://st.suckless.org"& */
	size_t const cmd_size = max_cmd + strlen(clip) + 5;
	char cmd[cmd_size];

	snprintf(cmd, cmd_size, "%s \"%s\"&", (char *)arg->v, clip);
	system(cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x800, -0x10(%rbp)     # imm = 0x800
movq 0xf4ed(%rip), %rax      # 0x21a38
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12570
movq 0x8a93(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
leaq 0x4c1d(%rip), %rsi      # 0x17184
movb $0x0, %al
callq 0x68e0
jmp 0x125d7
movq -0x18(%rbp), %rdi
callq 0x6390
addq $0x805, %rax            # imm = 0x805
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rsp
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %r8
leaq 0x4bea(%rip), %rdx      # 0x171aa
movb $0x0, %al
callq 0x60b0
movq -0x38(%rbp), %rdi
callq 0x6220
movq -0x28(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: ximopen
int
ximopen(Display *dpy)
{
	XIMCallback imdestroy = { .client_data = NULL, .callback = ximdestroy };
	XICCallback icdestroy = { .client_data = NULL, .callback = xicdestroy };

	xw.ime.xim = XOpenIM(xw.dpy, NULL, NULL, NULL);
	if (xw.ime.xim == NULL)
		return 0;

	if (XSetIMValues(xw.ime.xim, XNDestroyCallback, &imdestroy, NULL))
		fprintf(stderr, "XSetIMValues: "
		                "Could not set XNDestroyCallback.\n");

	xw.ime.spotlist = XVaCreateNestedList(0, XNSpotLocation, &xw.ime.spot,
	                                      NULL);

	if (xw.ime.xic == NULL) {
		xw.ime.xic = XCreateIC(xw.ime.xim, XNInputStyle,
		                       XIMPreeditNothing | XIMStatusNothing,
		                       XNClientWindow, xw.win,
		                       XNDestroyCallback, &icdestroy,
		                       NULL);
	}
	if (xw.ime.xic == NULL)
		fprintf(stderr, "XCreateIC: Could not create input context.\n");

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq 0x80ad(%rip), %rax      # 0x1ad70
movq %rax, -0x20(%rbp)
movq 0x80aa(%rip), %rax      # 0x1ad78
movq %rax, -0x18(%rbp)
movq 0x80a7(%rip), %rax      # 0x1ad80
movq %rax, -0x30(%rbp)
movq 0x80a4(%rip), %rax      # 0x1ad88
movq %rax, -0x28(%rbp)
movq 0xebc1(%rip), %rdi      # 0x218b0
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x6700
movq %rax, 0xebfb(%rip)      # 0x21900
cmpq $0x0, 0xebf3(%rip)      # 0x21900
jne 0x12d1b
movl $0x0, -0x4(%rbp)
jmp 0x12dfd
movq 0xebde(%rip), %rdi      # 0x21900
leaq 0x480c(%rip), %rsi      # 0x17535
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x6600
cmpq $0x0, %rax
je 0x12d56
movq 0x82ab(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
leaq 0x47f6(%rip), %rsi      # 0x17545
movb $0x0, %al
callq 0x68e0
xorl %edi, %edi
leaq 0x4816(%rip), %rsi      # 0x17575
leaq 0xeb4a(%rip), %rdx      # 0x218b0
addq $0x50, %rdx
addq $0x10, %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x6730
movq %rax, 0xeb98(%rip)      # 0x21918
cmpq $0x0, 0xeb80(%rip)      # 0x21908
jne 0x12dd4
movq 0xeb6f(%rip), %rdi      # 0x21900
movq 0xeb28(%rip), %r8       # 0x218c0
leaq 0x47e3(%rip), %rsi      # 0x17582
movl $0x408, %edx            # imm = 0x408
leaq 0x47e2(%rip), %rcx      # 0x1758d
leaq 0x4783(%rip), %r9       # 0x17535
leaq -0x30(%rbp), %rax
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, %al
callq 0x6030
movq %rax, 0xeb34(%rip)      # 0x21908
cmpq $0x0, 0xeb2c(%rip)      # 0x21908
jne 0x12df6
movq 0x820b(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
leaq 0x47ab(%rip), %rsi      # 0x1759a
movb $0x0, %al
callq 0x68e0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: xloadsparefont
int
xloadsparefont(FcPattern *pattern, int flags)
{
	FcPattern *match;
	FcResult result;
	
	match = FcFontMatch(NULL, pattern, &result);
	if (!match) {
		return 1;
	}

	if (!(frc[frclen].font = XftFontOpenPattern(xw.dpy, match))) {
		FcPatternDestroy(match);
		return 1;
	}

	frc[frclen].flags = flags;
	/* Believe U+0000 glyph will present in each default font */
	frc[frclen].unicodep = 0;
	frclen++;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq -0x24(%rbp), %rdx
callq 0x61b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13347
movl $0x1, -0x4(%rbp)
jmp 0x133d4
movq 0xe562(%rip), %rdi      # 0x218b0
movq -0x20(%rbp), %rsi
callq 0x67d0
movq 0xe70a(%rip), %rcx      # 0x21a68
movslq 0xe6fb(%rip), %rdx      # 0x21a60
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x13387
movq -0x20(%rbp), %rdi
callq 0x6050
movl $0x1, -0x4(%rbp)
jmp 0x133d4
movl -0x14(%rbp), %ecx
movq 0xe6d7(%rip), %rax      # 0x21a68
movslq 0xe6c8(%rip), %rdx      # 0x21a60
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0xe6bf(%rip), %rax      # 0x21a68
movslq 0xe6b0(%rip), %rcx      # 0x21a60
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movl 0xe69c(%rip), %eax      # 0x21a60
addl $0x1, %eax
movl %eax, 0xe693(%rip)      # 0x21a60
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: xresize
void
xresize(int col, int row)
{
	win.tw = col * win.cw;
	win.th = row * win.ch;

	XFreePixmap(xw.dpy, xw.buf);
	xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h,
			xw.depth);
	XftDrawChange(xw.draw, xw.buf);
	xclear(0, 0, win.w, win.h);

	/* resize to new width */
	xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
imull 0xe41c(%rip), %eax      # 0x219d4
movl %eax, 0xe402(%rip)      # 0x219c0
movl -0x8(%rbp), %eax
imull 0xe408(%rip), %eax      # 0x219d0
movl %eax, 0xe3f6(%rip)      # 0x219c4
movq 0xe2db(%rip), %rdi      # 0x218b0
movq 0xe2ec(%rip), %rsi      # 0x218c8
callq 0x6840
movq 0xe2c8(%rip), %rdi      # 0x218b0
movq 0xe2d1(%rip), %rsi      # 0x218c0
movl 0xe3d3(%rip), %edx      # 0x219c8
movl 0xe3d1(%rip), %ecx      # 0x219cc
movl 0xe3a6(%rip), %r8d      # 0x219a8
callq 0x68d0
movq %rax, 0xe2ba(%rip)      # 0x218c8
movq 0xe30b(%rip), %rdi      # 0x21920
movq 0xe2ac(%rip), %rsi      # 0x218c8
callq 0x6710
movl 0xe3a1(%rip), %edx      # 0x219c8
movl 0xe39f(%rip), %ecx      # 0x219cc
xorl %esi, %esi
movl %esi, %edi
callq 0x12610
movq 0xe293(%rip), %rdi      # 0x218d0
movslq -0x4(%rbp), %rsi
shlq $0x4, %rsi
callq 0x6c60
movq %rax, 0xe27f(%rip)      # 0x218d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: zoomabs
void
zoomabs(const Arg *arg)
{
	xunloadfonts();
	xloadfonts(usedfont, arg->f);
	xloadsparefonts();
	cresize(0, 0);
	redraw();
	xhints();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x14620
movq 0xd490(%rip), %rdi      # 0x21a78
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x126a0
callq 0x129b0
xorl %esi, %esi
movl %esi, %edi
callq 0x134c0
callq 0xa4c0
callq 0x12e60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: xunloadfonts
void
xunloadfonts(void)
{
	/* Free the loaded fonts in the font cache.  */
	while (frclen > 0)
		XftFontClose(xw.dpy, frc[--frclen].font);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x14626
cmpl $0x0, 0xd433(%rip)      # 0x21a60
jle 0x14660
movq 0xd27a(%rip), %rdi      # 0x218b0
movq 0xd42b(%rip), %rax      # 0x21a68
movl 0xd41d(%rip), %ecx      # 0x21a60
addl $-0x1, %ecx
movl %ecx, 0xd414(%rip)      # 0x21a60
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x60d0
jmp 0x14626
leaq 0xd151(%rip), %rdi      # 0x217b8
addq $0x10, %rdi
callq 0x146b0
leaq 0xd141(%rip), %rdi      # 0x217b8
addq $0x48, %rdi
callq 0x146b0
leaq 0xd131(%rip), %rdi      # 0x217b8
addq $0x80, %rdi
callq 0x146b0
leaq 0xd11e(%rip), %rdi      # 0x217b8
addq $0xb8, %rdi
callq 0x146b0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: xunloadfont
void
xunloadfont(Font *f)
{
	XftFontClose(xw.dpy, f->match);
	FcPatternDestroy(f->pattern);
	if (f->set)
		FcFontSetDestroy(f->set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xd1ed(%rip), %rdi      # 0x218b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x60d0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x6050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x146f5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x6500
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/x.c
// Function: mouseaction
int
mouseaction(XEvent *e, uint release)
{
	MouseShortcut *ms;

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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %edi
callq 0x14bd0
movl %eax, %ecx
movl -0x28(%rbp), %eax
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x24(%rbp)
leaq 0x9777(%rip), %rax      # 0x1e180
movq %rax, -0x20(%rbp)
leaq 0x976c(%rip), %rax      # 0x1e180
addq $0xe0, %rax
cmpq %rax, -0x20(%rbp)
jae 0x14ad5
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x14ac2
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jne 0x14ac2
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x14a76
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x9060
movl %eax, %esi
movl -0x2c(%rbp), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jne 0x14ac2
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x24(%rbp), %esi
callq 0x142e0
cmpl $0x0, %eax
jne 0x14aa7
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl -0x24(%rbp), %esi
movl 0x96d8(%rip), %eax      # 0x1e170
xorl $-0x1, %eax
andl %eax, %esi
callq 0x142e0
cmpl $0x0, %eax
je 0x14ac2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x14adc
jmp 0x14ac4
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x14a0d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrdotx[P]st/boxdraw.c
// Function: boxdrawindex
ushort
boxdrawindex(const Glyph *g)
{
	if (boxdraw_braille && (g->u & ~0xff) == 0x2800)
		return BRL | (uint8_t)g->u;
	if (boxdraw_bold && (g->mode & ATTR_BOLD))
		return BDB | boxdata[(uint8_t)g->u];
	return boxdata[(uint8_t)g->u];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0x2139(%rip), %rax      # 0x16f68
cmpl $0x0, (%rax)
je 0x14e5a
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
cmpl $0x2800, %eax           # imm = 0x2800
jne 0x14e5a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movzbl %al, %eax
orl $0x1800, %eax           # imm = 0x1800
movw %ax, -0x2(%rbp)
jmp 0x14eb1
leaq 0x2103(%rip), %rax      # 0x16f64
cmpl $0x0, (%rax)
je 0x14e97
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x14e97
movq -0x10(%rbp), %rax
movl (%rax), %eax
movzbl %al, %eax
movl %eax, %ecx
leaq 0x2b98(%rip), %rax      # 0x17a20
movzwl (%rax,%rcx,2), %eax
orl $0x8000, %eax           # imm = 0x8000
movw %ax, -0x2(%rbp)
jmp 0x14eb1
movq -0x10(%rbp), %rax
movl (%rax), %eax
movzbl %al, %eax
movl %eax, %ecx
leaq 0x2b77(%rip), %rax      # 0x17a20
movw (%rax,%rcx,2), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/dynamodb_kv/main.c
// Function: callback_status
static int
callback_status(void * cookie, int status)
{
	struct status * C = cookie;

	C->done = 1;
	C->status = status;

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/dynamodb_kv/main.c
// Function: callback_get
static int
callback_get(void * cookie, int status, const uint8_t * buf, size_t buflen)
{
	struct status * C = cookie;

	C->done = 1;
	C->status = status;
	if (status == 0) {
		fprintf(stderr, "value returned: \"");
		fwrite(buf, buflen, 1, stderr);
		fprintf(stderr, "\"\n");
	} else if (status == 2) {
		fprintf(stderr, "no value associated\n");
	}

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x36d7
movq 0x10968(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xabe6(%rip), %rsi      # 0xe280
movb $0x0, %al
callq 0x21c0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x10948(%rip), %rax     # 0x13ff8
movq (%rax), %rcx
movl $0x1, %edx
callq 0x22d0
movq 0x10934(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xab55(%rip), %rsi      # 0xe223
movb $0x0, %al
callq 0x21c0
jmp 0x36f7
cmpl $0x2, -0xc(%rbp)
jne 0x36f5
movq 0x10914(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xaba4(%rip), %rsi      # 0xe292
movb $0x0, %al
callq 0x21c0
jmp 0x36f7
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_dynamodb_kv/proto_dynamodb_kv_client.c
// Function: callback_status
static int
callback_status(void * cookie, uint8_t * buf, size_t buflen)
{
	struct status_cookie * C = cookie;
	int failed = 1;
	uint32_t status;
	int rc;

	/* If we have a packet, parse it. */
	if (buf != NULL) {
		/* Do we have the right packet length? */
		if (buflen != 4)
			BAD("status", "bogus length");

		/* Parse the status. */
		status = be32dec(&buf[0]);

		/* Did the operation succeed? */
		switch (status) {
		case 0:
			failed = 0;
			break;
		case 1:
			break;
		case 2:
			failed = 2;
			break;
		default:
			BAD("status", "invalid status");
		}
	}

failed:
	/* Invoke the upstream callback. */
	rc = (C->callback)(C->cookie, failed);

	/* Free the cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7c91
cmpq $0x4, -0x18(%rbp)
je 0x7c22
jmp 0x7bf7
jmp 0x7bf9
leaq 0x7199(%rip), %rdi      # 0xed99
leaq 0x71c4(%rip), %rsi      # 0xedcb
leaq 0x71a8(%rip), %rdx      # 0xedb6
movb $0x0, %al
callq 0x7770
callq 0x20a0
movl $0x0, (%rax)
jmp 0x7c93
movq -0x10(%rbp), %rdi
callq 0x8860
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
testl %eax, %eax
je 0x7c4e
jmp 0x7c3a
movl -0x30(%rbp), %eax
subl $0x1, %eax
je 0x7c57
jmp 0x7c44
movl -0x30(%rbp), %eax
subl $0x2, %eax
je 0x7c59
jmp 0x7c62
movl $0x0, -0x24(%rbp)
jmp 0x7c8f
jmp 0x7c8f
movl $0x2, -0x24(%rbp)
jmp 0x7c8f
jmp 0x7c64
jmp 0x7c66
leaq 0x712c(%rip), %rdi      # 0xed99
leaq 0x7157(%rip), %rsi      # 0xedcb
leaq 0x7148(%rip), %rdx      # 0xedc3
movb $0x0, %al
callq 0x7770
callq 0x20a0
movl $0x0, (%rax)
jmp 0x7c93
jmp 0x7c91
jmp 0x7c93
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0x24(%rbp), %esi
callq *%rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2040
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_dynamodb_kv/proto_dynamodb_kv_client.c
// Function: proto_dynamodb_kv_request_get
int
proto_dynamodb_kv_request_get(struct wire_requestqueue * Q, const char * key,
    int (* callback)(void *, int, const uint8_t *, size_t), void * cookie)
{
	struct data_cookie * C;
	uint8_t *rbuf, *p;
	size_t rlen;

	/* Validate key length. */
	if (strlen(key) > 255) {
		warn0("Key is too long");
		goto err0;
	}

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct data_cookie))) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;

	/* Compute request packet size. */
	rlen = 4 + 1 + strlen(key);

	/* Start writing a request. */
	if ((p = rbuf = wire_requestqueue_add_getbuf(Q,
	    rlen, callback_data, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(p, PROTO_DDBKV_GET);
	p += 4;
	*p++ = (uint8_t)strlen(key);
	memcpy(p, key, strlen(key));
	p += strlen(key);

	/* Sanity check. */
	assert(p == &rbuf[rlen]);

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, rbuf, rlen))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(C);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
cmpq $0xff, %rax
jbe 0x81e9
jmp 0x81cb
leaq 0x6846(%rip), %rdi      # 0xea18
movb $0x0, %al
callq 0x7770
callq 0x20a0
movl $0x0, (%rax)
jmp 0x8321
movl $0x10, %edi
callq 0x21f0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x8202
jmp 0x8321
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x2100
addq $0x5, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rcx
leaq 0x103(%rip), %rdx       # 0x8340
callq 0x8c00
movq %rax, -0x38(%rbp)
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x8255
jmp 0x8318
movq -0x40(%rbp), %rdi
movl $0x10110, %esi          # imm = 0x10110
callq 0x7cc0
movq -0x40(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movb %al, %cl
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x40(%rbp)
movb %cl, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x21d0
movq -0x18(%rbp), %rdi
callq 0x2100
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x48(%rbp), %rcx
cmpq %rcx, %rax
jne 0x82d8
jmp 0x82f7
leaq 0x675b(%rip), %rdi      # 0xea3a
leaq 0x6765(%rip), %rsi      # 0xea4b
movl $0x18b, %edx            # imm = 0x18B
leaq 0x6933(%rip), %rcx      # 0xec25
callq 0x2160
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x8d90
cmpl $0x0, %eax
je 0x830f
jmp 0x8318
movl $0x0, -0x4(%rbp)
jmp 0x8328
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_dynamodb_kv/proto_dynamodb_kv_client.c
// Function: proto_dynamodb_kv_request_getc
int
proto_dynamodb_kv_request_getc(struct wire_requestqueue * Q, const char * key,
    int (* callback)(void *, int, const uint8_t *, size_t), void * cookie)
{
	struct data_cookie * C;
	uint8_t *rbuf, *p;
	size_t rlen;

	/* Validate key length. */
	if (strlen(key) > 255) {
		warn0("Key is too long");
		goto err0;
	}

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct data_cookie))) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;

	/* Compute request packet size. */
	rlen = 4 + 1 + strlen(key);

	/* Start writing a request. */
	if ((p = rbuf = wire_requestqueue_add_getbuf(Q,
	    rlen, callback_data, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(p, PROTO_DDBKV_GETC);
	p += 4;
	*p++ = (uint8_t)strlen(key);
	memcpy(p, key, strlen(key));
	p += strlen(key);

	/* Sanity check. */
	assert(p == &rbuf[rlen]);

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, rbuf, rlen))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(C);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
cmpq $0xff, %rax
jbe 0x8569
jmp 0x854b
leaq 0x64c6(%rip), %rdi      # 0xea18
movb $0x0, %al
callq 0x7770
callq 0x20a0
movl $0x0, (%rax)
jmp 0x86a1
movl $0x10, %edi
callq 0x21f0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x8582
jmp 0x86a1
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x2100
addq $0x5, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rcx
leaq -0x27d(%rip), %rdx      # 0x8340
callq 0x8c00
movq %rax, -0x38(%rbp)
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x85d5
jmp 0x8698
movq -0x40(%rbp), %rdi
movl $0x10111, %esi          # imm = 0x10111
callq 0x7cc0
movq -0x40(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movb %al, %cl
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x40(%rbp)
movb %cl, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x21d0
movq -0x18(%rbp), %rdi
callq 0x2100
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x48(%rbp), %rcx
cmpq %rcx, %rax
jne 0x8658
jmp 0x8677
leaq 0x63db(%rip), %rdi      # 0xea3a
leaq 0x63e5(%rip), %rsi      # 0xea4b
movl $0x1c4, %edx            # imm = 0x1C4
leaq 0x6636(%rip), %rcx      # 0xeca8
callq 0x2160
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x8d90
cmpl $0x0, %eax
je 0x868f
jmp 0x8698
movl $0x0, -0x4(%rbp)
jmp 0x86a8
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/proto_dynamodb_kv/proto_dynamodb_kv_client.c
// Function: proto_dynamodb_kv_request_delete
int
proto_dynamodb_kv_request_delete(struct wire_requestqueue * Q,
    const char * key, int (* callback)(void *, int), void * cookie)
{
	struct status_cookie * C;
	uint8_t *rbuf, *p;
	size_t rlen;

	/* Validate key length. */
	if (strlen(key) > 255) {
		warn0("Key is too long");
		goto err0;
	}

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct status_cookie))) == NULL)
		goto err0;
	C->callback = callback;
	C->cookie = cookie;

	/* Compute request packet size. */
	rlen = 4 + 1 + strlen(key);

	/* Start writing a request. */
	if ((p = rbuf = wire_requestqueue_add_getbuf(Q,
	    rlen, callback_status, C)) == NULL)
		goto err1;

	/* Construct request. */
	be32enc(p, PROTO_DDBKV_DELETE);
	p += 4;
	*p++ = (uint8_t)strlen(key);
	memcpy(p, key, strlen(key));
	p += strlen(key);

	/* Sanity check. */
	assert(p == &rbuf[rlen]);

	/* Finish writing request. */
	if (wire_requestqueue_add_done(Q, rbuf, rlen))
		goto err1;

	/* Success! */
	return (0);

err1:
	free(C);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
cmpq $0xff, %rax
jbe 0x8709
jmp 0x86eb
leaq 0x6326(%rip), %rdi      # 0xea18
movb $0x0, %al
callq 0x7770
callq 0x20a0
movl $0x0, (%rax)
jmp 0x8841
movl $0x10, %edi
callq 0x21f0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x8722
jmp 0x8841
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x2100
addq $0x5, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rcx
leaq -0xb9d(%rip), %rdx      # 0x7bc0
callq 0x8c00
movq %rax, -0x38(%rbp)
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x8775
jmp 0x8838
movq -0x40(%rbp), %rdi
movl $0x10120, %esi          # imm = 0x10120
callq 0x7cc0
movq -0x40(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movb %al, %cl
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x40(%rbp)
movb %cl, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x21d0
movq -0x18(%rbp), %rdi
callq 0x2100
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
addq -0x48(%rbp), %rcx
cmpq %rcx, %rax
jne 0x87f8
jmp 0x8817
leaq 0x623b(%rip), %rdi      # 0xea3a
leaq 0x6245(%rip), %rsi      # 0xea4b
movl $0x1ff, %edx            # imm = 0x1FF
leaq 0x651a(%rip), %rcx      # 0xed2c
callq 0x2160
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x8d90
cmpl $0x0, %eax
je 0x882f
jmp 0x8838
movl $0x0, -0x4(%rbp)
jmp 0x8848
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: double_block
void
double_block (hashblock res, const hashblock in)
{
    unsigned int i;
    /* create bitmask from msb using signed shift */
    unsigned char carry = in[0] & 0x80;

    for (i = 0; i < OMD_n-1; i++)
       {
	  /* shift with carry from next block */
	  res[i] = (in[i] << 1) | (in[i+1] >> 7);
       }
	
	res[OMD_n -1] = (in[OMD_n -1] << 1);

    /* xor P(x) if msb */
	if(carry) {
	    res[OMD_n -2] = res[OMD_n -2] ^ 0x01;
	    res[OMD_n -1] = res[OMD_n -1] ^ 0x25;
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
movb %al, -0x15(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x3f, -0x14(%rsp)
jae 0x140b
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movzbl (%rax,%rcx), %eax
shll %eax
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %edx
addl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
sarl $0x7, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x13c3
movq -0x10(%rsp), %rax
movzbl 0x3f(%rax), %eax
shll %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3f(%rax)
cmpb $0x0, -0x15(%rsp)
je 0x1453
movq -0x8(%rsp), %rax
movzbl 0x3e(%rax), %eax
xorl $0x1, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3e(%rax)
movq -0x8(%rsp), %rax
movzbl 0x3f(%rax), %eax
xorl $0x25, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3f(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: triple_block
void
triple_block (hashblock res, const hashblock in)
{
    unsigned int i;
    /* create bitmask from msb using signed shift */
    unsigned char carry = in[0] & 0x80;

    for (i = 0; i < OMD_n -1; i++)
       {
	  /* shift and xor */
	  res[i] = in[i] ^ ((in[i] << 1) | (in[i+1] >> 7));
       }

	res[OMD_n -1] = in[OMD_n -1] ^ (in[OMD_n -1] << 1);

    /* xor P(x) if msb */
	if(carry) {
	    res[OMD_n -2] = res[OMD_n -2] ^ 0x01;
	    res[OMD_n -1] = res[OMD_n -1] ^ 0x25;
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
movb %al, -0x15(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x3f, -0x14(%rsp)
jae 0x14da
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
shll %ecx
movq -0x10(%rsp), %rdx
movl -0x14(%rsp), %esi
addl $0x1, %esi
movl %esi, %esi
movzbl (%rdx,%rsi), %edx
sarl $0x7, %edx
orl %edx, %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x1483
movq -0x10(%rsp), %rax
movzbl 0x3f(%rax), %eax
movq -0x10(%rsp), %rcx
movzbl 0x3f(%rcx), %ecx
shll %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3f(%rax)
cmpb $0x0, -0x15(%rsp)
je 0x152d
movq -0x8(%rsp), %rax
movzbl 0x3e(%rax), %eax
xorl $0x1, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3e(%rax)
movq -0x8(%rsp), %rax
movzbl 0x3f(%rax), %eax
xorl $0x25, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3f(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: l2b
void
l2b (hashblock bit_string, int value)
{
   int ptr = value*8;
   unsigned int i = OMD_n;

   memset(bit_string, 0x00, OMD_n);

   while (i--)
      {   /* write the bytes of value into tau */
	 bit_string[i] = ptr & 0xff;
	 ptr >>= 8;
      }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
shll $0x3, %eax
movl %eax, 0x8(%rsp)
movl $0x40, 0x4(%rsp)
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1040
movl 0x4(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rsp)
cmpl $0x0, %eax
je 0x1597
movl 0x8(%rsp), %eax
andl $0xff, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x8(%rsp), %eax
sarl $0x8, %eax
movl %eax, 0x8(%rsp)
jmp 0x1561
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: calc_L_i
void
calc_L_i (hashblock l, const hashblock lzero, unsigned int i)
{
   /* i==0 => l=lzero */
   if (i == 0)
      {
	 memcpy (l, lzero, OMD_n );
	 return;
      }

   double_block (l,lzero);

   /* L[i]=2.L[i-1] */
   while (--i)
      {
	 double_block (l,l);
      }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x164f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x40, %edx
callq 0x1150
jmp 0x167f
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1070
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
je 0x167f
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1070
jmp 0x165e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: ntz
int
ntz (int v)
{
   int c;

   /* Set v's trailing 0s to 1s and zero rest */
   v = (v ^ (v - 1)) >> 1;

   for (c = 0; v; c++)
      {
	 v >>= 1;
      }

   return c;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
movl -0x4(%rsp), %ecx
subl $0x1, %ecx
xorl %ecx, %eax
sarl %eax
movl %eax, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0x0, -0x4(%rsp)
je 0x16cd
movl -0x4(%rsp), %eax
sarl %eax
movl %eax, -0x4(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x16af
movl -0x8(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: increment_masking_message
void
increment_masking_message (hashblock delta_n, const hashblock delta_o,
			   const hashblock lzero, int i)
{
   hashblock l;

   if (i < 1)
      {
	 return;
      }

   /* \delta_{N, i, 0} = \delta_{N, i-1, 0} ^ L[ntz(i)]  */
   calc_L_i (l, lzero, ntz(i));
   xor_block (delta_n, delta_o, l);

}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
cmpl $0x1, 0x5c(%rsp)
jge 0x1700
jmp 0x1740
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x5c(%rsp), %edi
callq 0x1120
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %eax, %edx
callq 0x10e0
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1130
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/omdsha512k128n128tau128v2/ref/omdsha512.c
// Function: final_masking_message
void
final_masking_message (hashblock delta_n, const hashblock delta_o,
		       const hashblock lstar, int j)
{
   hashblock l;

   switch (j)
      {
	 /* \delta_{N, i, 1} = \delta_{N, i, 0} ^ 2*L_*  */
	 case 1: double_block (l, lstar); break;

	 /* \delta_{N, i, 2} = \delta_{N, i, 0} ^ 3*L_*  */
	 case 2: triple_block (l, lstar); break;
      }

	xor_block (delta_n, delta_o, l);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x1781
jmp 0x1776
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x1792
jmp 0x17a1
leaq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x1070
jmp 0x17a1
leaq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x10f0
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1130
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/ps3dm.c
// Function: main
int
main(int argc, char **argv)
{
	int ret;

	ret = parse_opts(argc, argv, &opts);
	if (ret)
		exit(255);

	if (opts.do_help)
		usage();
	else if (opts.do_version)
		version();

	ret = dev_open(opts.device);
	if (ret) {
		perror("open device");
		exit(254);
	}

	ret = cmd_exec(sizeof(cmdv) / sizeof(cmdv[0]), cmdv,
	    argc - optind, &argv[optind]);
	switch (ret) {
	case CMD_EOK:
	break;
	case CMD_EBADCMD:
		fprintf(stderr, "invalid command specified\n");
	break;
	case CMD_EINVAL:
		fprintf(stderr, "invalid command argument(s) specified\n");
	break;
	case CMD_EIO:
		fprintf(stderr, "device error\n");
	break;
	case CMD_EUNKNOWN:
		fprintf(stderr, "unknown command error\n");
	break;
	}

	dev_close();

	exit(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x6e4c(%rip), %rdx      # 0x90c0
callq 0x23a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x228c
movl $0xff, %edi
callq 0x2120
cmpl $0x0, 0x6e2d(%rip)      # 0x90c0
je 0x229c
callq 0x2580
jmp 0x22ac
cmpl $0x0, 0x6e21(%rip)      # 0x90c4
je 0x22aa
callq 0x2590
jmp 0x22ac
movq 0x6e1d(%rip), %rdi      # 0x90d0
callq 0x25a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x22d7
leaq 0x3e41(%rip), %rdi      # 0x6109
callq 0x2100
movl $0xfe, %edi
callq 0x2120
movl -0x8(%rbp), %edx
movq 0x6cef(%rip), %rax      # 0x8fd0
movslq (%rax), %rcx
movl %ecx, %eax
subl %eax, %edx
movq -0x10(%rbp), %rax
leaq (%rax,%rcx,8), %rcx
leaq 0x6e09(%rip), %rsi      # 0x9100
movl $0x9, %edi
callq 0x5300
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x238d
movq -0x20(%rbp), %rax
leaq 0x3ce8(%rip), %rcx      # 0x6004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x238d
movq 0x6cca(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x3ddd(%rip), %rsi      # 0x6115
movb $0x0, %al
callq 0x20c0
jmp 0x238d
movq 0x6cb0(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x3dde(%rip), %rsi      # 0x6130
movb $0x0, %al
callq 0x20c0
jmp 0x238d
movq 0x6c96(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x3deb(%rip), %rsi      # 0x6157
movb $0x0, %al
callq 0x20c0
jmp 0x238d
movq 0x6c7c(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x3ddf(%rip), %rsi      # 0x6165
movb $0x0, %al
callq 0x20c0
callq 0x2600
movl -0x14(%rbp), %edi
callq 0x2120
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/dev.c
// Function: dev_open
int
dev_open(const char *device)
{
	if (fd >= 0)
		close(fd);

	fd = open(device, O_RDWR);
	if (fd < 0)
		return (-1);

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x6c7d(%rip)      # 0x9230
jl 0x25c0
movl 0x6c75(%rip), %edi      # 0x9230
callq 0x2080
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x20f0
movl %eax, 0x6c5a(%rip)      # 0x9230
cmpl $0x0, 0x6c53(%rip)      # 0x9230
jge 0x25e8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x25ef
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sguerrini97[P]ps3linux-ps3vuart-tools/ps3dm/dev.c
// Function: dev_read
int
dev_read(void *buf, size_t len)
{
	char tmp[4096];
	struct ps3dm_header *hdr;
	int ret;

	if (fd < 0)
		return (-1);

	hdr = (struct ps3dm_header *) tmp;

	while (1) {
		ret = read(fd, hdr, sizeof(*hdr));
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	while (1) {
		ret = read(fd, hdr + 1, hdr->reply_length);
		if (ret < 0) {
			if (errno != EAGAIN)
				return (-1);
		} else if (ret > 0) {
			break;
		}
	}

	if (len > (sizeof(*hdr) + hdr->reply_length))
		len = sizeof(*hdr) + hdr->reply_length;

	memcpy(buf, tmp, len);

	return (len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, 0x6ba6(%rip)      # 0x9230
jge 0x2698
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x278e
leaq -0x1020(%rbp), %rax
movq %rax, -0x1028(%rbp)
movl 0x6b84(%rip), %edi      # 0x9230
movq -0x1028(%rbp), %rsi
movl $0x10, %edx
callq 0x2090
movl %eax, -0x102c(%rbp)
cmpl $0x0, -0x102c(%rbp)
jge 0x26e4
callq 0x2030
cmpl $0xb, (%rax)
je 0x26e2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x278e
jmp 0x26f1
cmpl $0x0, -0x102c(%rbp)
jle 0x26ef
jmp 0x26f3
jmp 0x26f1
jmp 0x26a6
jmp 0x26f5
movl 0x6b35(%rip), %edi      # 0x9230
movq -0x1028(%rbp), %rsi
addq $0x10, %rsi
movq -0x1028(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
callq 0x2090
movl %eax, -0x102c(%rbp)
cmpl $0x0, -0x102c(%rbp)
jge 0x273b
callq 0x2030
cmpl $0xb, (%rax)
je 0x2739
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x278e
jmp 0x2748
cmpl $0x0, -0x102c(%rbp)
jle 0x2746
jmp 0x274a
jmp 0x2748
jmp 0x26f5
movq -0x18(%rbp), %rax
movq -0x1028(%rbp), %rcx
movl 0xc(%rcx), %ecx
addq $0x10, %rcx
cmpq %rcx, %rax
jbe 0x2773
movq -0x1028(%rbp), %rax
movl 0xc(%rax), %eax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x20d0
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw (%rax,%rax)