LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/aligrudi[P]neatmkfn/otf.c
// Function: gctx_backtrack
static void gctx_backtrack(struct gctx *ctx)
{
	int i;
	if (!ctx)
		return;
	for (i = 0; i < ctx->bn; i++)
		printf(" =@%d", ctx->bgrp[i]);
	for (i = 0; i < ctx->seqidx; i++)
		printf(" =@%d", ctx->igrp[i]);
}

// Assembly:
testq %rdi, %rdi
je 0x4289b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc0(%rdi)
jle 0x42865
leaq 0x12567(%rip), %r14     # 0x54dac
xorl %r15d, %r15d
movl (%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %r15
movslq 0xc0(%rbx), %rax
cmpq %rax, %r15
jl 0x42848
cmpl $0x0, 0xcc(%rbx)
jle 0x42896
leaq 0x12537(%rip), %r14     # 0x54dac
xorl %r15d, %r15d
movl 0x40(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %r15
movslq 0xcc(%rbx), %rax
cmpq %rax, %r15
jl 0x42878
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/aligrudi[P]neatmkfn/otf.c
// Function: gctx_lookahead
static void gctx_lookahead(struct gctx *ctx, int patlen)
{
	int i;
	if (!ctx)
		return;
	for (i = ctx->seqidx + patlen; i < ctx->in; i++)
		printf(" =@%d", ctx->igrp[i]);
	for (i = 0; i < ctx->ln; i++)
		printf(" =@%d", ctx->lgrp[i]);
}

// Assembly:
testq %rdi, %rdi
je 0x42920
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0xcc(%rdi), %r15
leal (%r15,%rsi), %eax
cmpl 0xc4(%rdi), %eax
jge 0x428e7
movslq %esi, %rax
addq %rax, %r15
leaq 0x124e3(%rip), %r14     # 0x54dac
movl 0x40(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %r15
movslq 0xc4(%rbx), %rax
cmpq %rax, %r15
jl 0x428c9
cmpl $0x0, 0xc8(%rbx)
jle 0x4291b
leaq 0x124b5(%rip), %r14     # 0x54dac
xorl %r15d, %r15d
movl 0x80(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %r15
movslq 0xc8(%rbx), %rax
cmpq %rax, %r15
jl 0x428fa
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/aligrudi[P]neatmkfn/otf.c
// Function: ggrp_make
static int ggrp_make(int *src, int n)
{
	int id = ggrp_find(src, n);
	int i;
	if (id >= 0)
		return id;
	id = ggrp_n++;
	ggrp_g[id] = malloc(n * sizeof(ggrp_g[id][0]));
	ggrp_len[id] = n;
	for (i = 0; i < n; i++)
		ggrp_g[id][i] = src[i];
	printf("ggrp %d %d", id, n);
	for (i = 0; i < n; i++)
		printf(" %s", glyph_name[src[i]]);
	printf("\n");
	return id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movslq 0x5b12c3(%rip), %rbx    # 0x5f3c00
movl %esi, %r12d
testq %rbx, %rbx
jle 0x42990
xorl %eax, %eax
leaq 0x5b52c2(%rip), %rcx    # 0x5f7c10
leaq 0x5b12bb(%rip), %rdx    # 0x5f3c10
cmpl %ebp, (%rcx,%rax,4)
jne 0x4297e
testl %ebp, %ebp
jle 0x42978
movq (%rdx,%rax,8), %rdi
xorl %esi, %esi
movl (%r14,%rsi,4), %r8d
cmpl (%rdi,%rsi,4), %r8d
jne 0x4297a
incq %rsi
cmpq %rsi, %r12
jne 0x42964
jmp 0x42988
xorl %esi, %esi
cmpl %ebp, %esi
je 0x42988
incq %rax
cmpq %rbx, %rax
jne 0x42955
jmp 0x42990
testl %eax, %eax
jns 0x42a30
leal 0x1(%rbx), %eax
movl %eax, 0x5b1267(%rip)    # 0x5f3c00
movslq %ebp, %rdi
shlq $0x2, %rdi
callq 0x3d180
leaq 0x5b1264(%rip), %rcx    # 0x5f3c10
movq %rax, (%rcx,%rbx,8)
leaq 0x5b5259(%rip), %rcx    # 0x5f7c10
movl %ebp, (%rcx,%rbx,4)
testl %ebp, %ebp
jle 0x42a12
leaq (,%r12,4), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3d170
leaq 0x123df(%rip), %rdi     # 0x54db7
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3d0c0
leaq 0x311f6(%rip), %r13     # 0x73be0
leaq 0x12408(%rip), %r15     # 0x54df9
xorl %ebp, %ebp
movslq (%r14,%rbp,4), %rsi
shlq $0x6, %rsi
addq %r13, %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %rbp
cmpq %rbp, %r12
jne 0x429f3
jmp 0x42a24
leaq 0x1239e(%rip), %rdi     # 0x54db7
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3d0c0
movl $0xa, %edi
callq 0x3d040
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aligrudi[P]neatmkfn/otf.c
// Function: valuerecord_small
static int valuerecord_small(int fmt, void *rec)
{
	int off = 0;
	int i;
	for (i = 0; i < 8; i++) {
		if (fmt & (1 << i)) {
			if (abs(uwid(S16(rec, off))) >= MAX(1, mkfn_kmin))
				return 0;
			off += 2;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x276c0(%rip), %rax     # 0x6a110
movl 0x31179(%rip), %r10d    # 0x73bd0
movl %r10d, %r11d
shrl %r11d
movl %r11d, %ebx
negl %ebx
leaq 0x2d12f(%rip), %rcx     # 0x6fb98
movl (%rcx), %ecx
cmpl $0x2, %ecx
movl $0x1, %ebp
cmovgel %ecx, %ebp
movl (%rax), %r14d
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %ecx, %ecx
btl %r15d, %edi
jae 0x42aef
movslq %r13d, %rax
movzwl (%rsi,%rax), %eax
rolw $0x8, %ax
movswl %ax, %r9d
movl $0x11940, %eax          # imm = 0x11940
xorl %edx, %edx
idivl %r14d
movl %eax, %r8d
imull $0x3e8, %r9d, %edx      # imm = 0x3E8
testw %r9w, %r9w
movl %r11d, %eax
cmovsl %ebx, %eax
movl $0x14, %r12d
movl $0xffffffec, %r9d       # imm = 0xFFFFFFEC
cmovsl %r9d, %r12d
addl %edx, %eax
cltd
idivl %r10d
movl %eax, %r9d
movl %r8d, %eax
cltd
idivl %r12d
addl %r9d, %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
cltd
idivl %r8d
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
cmpl %ebp, %edx
jae 0x42afd
addl $0x2, %r13d
incl %r15d
cmpl $0x8, %r15d
jne 0x42a81
movl $0x1, %ecx
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aligrudi[P]neatmkfn/otf.c
// Function: valuerecord_print
static void valuerecord_print(int fmt, void *rec)
{
	int vals[8] = {0};
	int off = 0;
	int i;
	for (i = 0; i < 8; i++) {
		if (fmt & (1 << i)) {
			vals[i] = uwid(S16(rec, off));
			off += 2;
		}
	}
	if (fmt)
		printf(":%+d%+d%+d%+d", vals[0], vals[1], vals[2], vals[3]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rsp)
movaps %xmm0, -0x20(%rsp)
leaq 0x275ea(%rip), %rax     # 0x6a110
movl (%rax), %r9d
movl 0x310a0(%rip), %r10d    # 0x73bd0
movl %r10d, %r11d
shrl %r11d
movl %r11d, %ebx
negl %ebx
xorl %r14d, %r14d
movl $0xffffffec, %ebp       # imm = 0xFFFFFFEC
xorl %r15d, %r15d
btl %r14d, %edi
jae 0x42ba6
movslq %r15d, %r15
movzwl (%rsi,%r15), %eax
rolw $0x8, %ax
movswl %ax, %r8d
movl $0x11940, %eax          # imm = 0x11940
xorl %edx, %edx
idivl %r9d
movl %eax, %ecx
imull $0x3e8, %r8d, %edx      # imm = 0x3E8
testw %r8w, %r8w
movl %r11d, %eax
cmovsl %ebx, %eax
movl $0x14, %r12d
cmovsl %ebp, %r12d
addl %edx, %eax
cltd
idivl %r10d
movl %eax, %r8d
movl %ecx, %eax
cltd
idivl %r12d
addl %r8d, %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
cltd
idivl %ecx
movl %eax, -0x20(%rsp,%r14,4)
addl $0x2, %r15d
incq %r14
cmpq $0x8, %r14
jne 0x42b46
testl %edi, %edi
je 0x42bda
movl -0x20(%rsp), %esi
movl -0x1c(%rsp), %edx
movl -0x18(%rsp), %ecx
movl -0x14(%rsp), %r8d
leaq 0x12232(%rip), %rdi     # 0x54dfd
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3d0c0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aligrudi[P]neatmkfn/otf.c
// Function: classdef
static int classdef(void *tab, int *gl, int *cls)
{
	int fmt = U16(tab, 0);
	int ngl = 0;
	int i, j;
	if (fmt == 1) {
		int beg = U16(tab, 2);
		ngl = U16(tab, 4);
		for (i = 0; i < ngl; i++) {
			gl[i] = beg + i;
			cls[i] = U16(tab, 6 + 2 * i);
		}
	}
	if (fmt == 2) {
		int n = U16(tab, 2);
		for (i = 0; i < n; i++) {
			int beg = U16(tab, 4 + 6 * i);
			int end = U16(tab, 4 + 6 * i + 2);
			for (j = beg; j <= end; j++) {
				gl[ngl] = j;
				cls[ngl] = U16(tab, 4 + 6 * i + 4);
				ngl++;
			}
		}
	}
	return ngl;
}

// Assembly:
movzwl (%rdi), %ecx
xorl %eax, %eax
cmpl $0x100, %ecx            # imm = 0x100
jne 0x42c47
movzwl 0x4(%rdi), %r8d
movl %r8d, %eax
rolw $0x8, %ax
movzwl %ax, %eax
testw %r8w, %r8w
je 0x42cf6
movzwl 0x2(%rdi), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
cmpl $0x1, %eax
movl %eax, %r9d
adcl $0x0, %r9d
xorl %r10d, %r10d
leal (%r8,%r10), %r11d
movl %r11d, (%rsi,%r10,4)
movzwl 0x6(%rdi,%r10,2), %r11d
rolw $0x8, %r11w
movzwl %r11w, %r11d
movl %r11d, (%rdx,%r10,4)
incq %r10
cmpq %r10, %r9
jne 0x42c24
movzwl %cx, %ecx
cmpl $0x200, %ecx            # imm = 0x200
jne 0x42cf6
movzwl 0x2(%rdi), %ecx
testw %cx, %cx
je 0x42cf6
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
rolw $0x8, %cx
cmpw $0x2, %cx
movl $0x1, %r8d
cmovael %ecx, %r8d
movzwl %r8w, %ecx
xorl %r8d, %r8d
leaq (%r8,%r8), %r9
leaq (%r9,%r9,2), %r11
movzwl 0x4(%rdi,%r11), %r10d
rolw $0x8, %r10w
movzwl 0x6(%rdi,%r11), %r9d
rolw $0x8, %r9w
cmpw %r9w, %r10w
ja 0x42ce8
movzwl %r9w, %r9d
movzwl 0x8(%rdi,%r11), %r11d
rolw $0x8, %r11w
movzwl %r10w, %r10d
movzwl %r11w, %r11d
movslq %eax, %r14
leaq (%rsi,%r14,4), %rbx
leaq (%rdx,%r14,4), %r14
subl %r10d, %r9d
incl %r9d
xorl %r15d, %r15d
leal (%r10,%r15), %ebp
movl %ebp, (%rbx,%r15,4)
movl %r11d, (%r14,%r15,4)
incq %r15
cmpl %r15d, %r9d
jne 0x42cd1
addl %r15d, %eax
incq %r8
cmpq %rcx, %r8
jne 0x42c82
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aligrudi[P]neatmkfn/otf.c
// Function: ggrp_class
static int ggrp_class(int *src, int *cls, int nsrc, int id)
{
	int *g = malloc(nsrc * sizeof(g[0]));
	int n = 0;
	int i;
	int grp;
	for (i = 0; i < nsrc; i++)
		if (cls[i] == id)
			g[n++] = src[i];
	qsort(g, n, sizeof(g[0]), (void *) intcmp);
	grp = ggrp_make(g, n);
	free(g);
	return grp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %r13
leaq (,%r13,4), %rdi
callq 0x3d180
movq %rax, %rbx
testl %r13d, %r13d
jle 0x42d48
movl %r12d, %eax
xorl %edx, %edx
xorl %ecx, %ecx
cmpl %ebp, (%r14,%rdx,4)
jne 0x42d3e
movl (%r15,%rdx,4), %esi
movslq %ecx, %rdi
incl %ecx
movl %esi, (%rbx,%rdi,4)
incq %rdx
cmpq %rdx, %rax
jne 0x42d2c
jmp 0x42d4a
xorl %ecx, %ecx
movslq %ecx, %r14
leaq -0x433(%rip), %rcx      # 0x42921
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d080
movq %rbx, %rdi
movl %r14d, %esi
callq 0x42926
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3d030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/dxwc[P]sfeed/sfeed_atom.c
// Function: main
int
main(int argc, char *argv[])
{
	FILE *fp;
	char *name;
	int i;

	if (argc == 1) {
		if (pledge("stdio", NULL) == -1)
			err(1, "pledge");
	} else {
		if (pledge("stdio rpath", NULL) == -1)
			err(1, "pledge");
	}

	fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
	      "<feed xmlns=\"http://www.w3.org/2005/Atom\" xml:lang=\"en\">\n",
	      stdout);

	if (argc == 1) {
		printfeed(stdin, "");
	} else {
		for (i = 1; i < argc; i++) {
			if (!(fp = fopen(argv[i], "r")))
				err(1, "fopen: %s", argv[i]);
			name = ((name = strrchr(argv[i], '/'))) ? name + 1 : argv[i];
			printfeed(fp, name);
			if (ferror(fp))
				err(1, "ferror: %s", argv[i]);
			fclose(fp);
		}
	}

	fputs("</feed>\n", stdout);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq 0x2cf5(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
leaq 0xd17(%rip), %rdi       # 0x2004
callq 0x10c0
cmpl $0x1, %ebp
jne 0x130f
movq 0x2ce2(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xd5c(%rip), %rsi       # 0x2064
callq 0x13c3
jmp 0x1374
jle 0x1374
movl %ebp, %ebp
movl $0x1, %r13d
leaq 0xd45(%rip), %r14       # 0x2065
movq (%rbx,%r13,8), %rdi
movq %r14, %rsi
callq 0x1180
movq (%rbx,%r13,8), %r12
testq %rax, %rax
je 0x139b
movq %rax, %r15
movq %r12, %rdi
movl $0x2f, %esi
callq 0x10b0
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %r12, %rsi
movq %r15, %rdi
callq 0x13c3
movq %r15, %rdi
callq 0x1060
testl %eax, %eax
jne 0x13ac
movq %r15, %rdi
callq 0x1070
incq %r13
cmpq %r13, %rbp
jne 0x1320
movq 0x2c5d(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
leaq 0xcf7(%rip), %rdi       # 0x207c
callq 0x10c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcc5(%rip), %rsi       # 0x2067
movl $0x1, %edi
movq %r12, %rdx
jmp 0x13bc
movq (%rbx,%r13,8), %rdx
leaq 0xcba(%rip), %rsi       # 0x2071
movl $0x1, %edi
xorl %eax, %eax
callq 0x1170
// File: /workspace/github_c_makefile_star2_O3/icarroll[P]clunk/playthud.c
// Function: main
int main(int numargs, char * args[])
{
    struct thudboard * board = & board_data;
    struct move * move = & move_data;

    int memuse = 1024 * 1024 * (numargs > 1 ? strtol(args[1], NULL, 10)
                                            : sizeof(struct tableentry));

    setupgame(board, memuse);

    int c = toupper(getchar());

    if (getchar() != '\n') exit(EXIT_FAILURE);

    if (c == 'T') goto troll;
    else if (c != 'D') exit(EXIT_FAILURE);

    while (true)
    {
        * move = iterdeepen(board, SEARCHSECS);
        showmove(move);
        domoveupdatecapts(board, move);

troll:
        * move = getmove();
        if (! legalmove(board, move)) exit(EXIT_FAILURE);
        domoveupdatecapts(board, move);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rax
movl $0x2000000, %esi        # imm = 0x2000000
cmpl $0x2, %edi
jl 0x1348
movq 0x8(%rax), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x1110
movq %rax, %rsi
shll $0x14, %esi
leaq 0x6e99(%rip), %rdi      # 0x81e8
callq 0x1574
callq 0x1130
movl %eax, %edi
callq 0x1070
movl %eax, %ebx
callq 0x1130
cmpl $0xa, %eax
jne 0x1376
cmpl $0x44, %ebx
je 0x1380
cmpl $0x54, %ebx
je 0x13c3
movl $0x1, %edi
callq 0x1080
leaq 0x6e61(%rip), %rbx      # 0x81e8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1e, %edx
callq 0x1832
leaq 0x6ec5(%rip), %r15      # 0x8268
movl $0x16, %ecx
movq %r15, %rdi
movq %r14, %rsi
rep  movsl (%rsi), %es:(%rdi)
movq %r15, %rdi
callq 0x3842
movq %rbx, %rdi
movq %r15, %rsi
callq 0x36a5
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1413
leaq 0x6e91(%rip), %rax      # 0x8268
movl $0x16, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsl (%rsi), %es:(%rdi)
leaq 0x6dfd(%rip), %rdi      # 0x81e8
movq %rax, %rsi
callq 0x32a0
testb %al, %al
je 0x1376
leaq 0x6de6(%rip), %rdi      # 0x81e8
leaq 0x6e5f(%rip), %rsi      # 0x8268
callq 0x36a5
jmp 0x1380
// File: /workspace/github_c_makefile_star2_O3/icarroll[P]clunk/playthud.c
// Function: getmove
struct move getmove(void)
{
    struct move move;

    char * line = NULL;
    size_t size = 0;
    int _ = getline(& line, & size, stdin);

    char * cur = line;

    skipspace(& cur);
    if (toupper(* cur) == 'D') move.isdwarfmove = true;
    else if (toupper(* cur) == 'T') move.isdwarfmove = false;
    else exit(EXIT_FAILURE);
    cur += 1;

    bool valid;

    skipspace(& cur);
    valid = getpos(& cur, & move.from);
    if (! valid) exit(EXIT_FAILURE);

    skipspace(& cur);
    if (* cur++ != '-') exit(EXIT_FAILURE);

    skipspace(& cur);
    valid = getpos(& cur, & move.to);
    if (! valid) exit(EXIT_FAILURE);

    move.numcapts = 0;
    while (move.numcapts <= NUMDIRS)
    {
        skipspace(& cur);
        if (* cur == '\0' || * cur == '\n') break;

        skipspace(& cur);
        if (toupper(* cur++) != 'X') exit(EXIT_FAILURE);

        skipspace(& cur);
        valid = getpos(& cur, & move.capts[move.numcapts++]);
        if (! valid) exit(EXIT_FAILURE);
    }

    free(line);
    return move;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x6ba6(%rip), %rax      # 0x7fe0
movq (%rax), %rdx
movq %r14, %rdi
callq 0x1150
movq (%r14), %rax
movq %rsp, %r15
movq %rax, (%r15)
movq %r15, %rdi
callq 0x36e2
callq 0x10d0
movq %rax, %r14
movq (%rax), %rcx
movq (%r15), %rax
movsbq (%rax), %rdx
movl (%rcx,%rdx,4), %edx
movb $0x1, %cl
cmpl $0x44, %edx
je 0x147d
cmpl $0x54, %edx
jne 0x1569
xorl %ecx, %ecx
movb %cl, (%rbx)
incq %rax
movq %rsp, %r15
movq %rax, (%r15)
movq %r15, %rdi
callq 0x36e2
leaq 0x4(%rbx), %rsi
movq %r15, %rdi
callq 0x373b
testb %al, %al
je 0x1569
movq %rsp, %r15
movq %r15, %rdi
callq 0x36e2
movq (%r15), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
cmpb $0x2d, (%rax)
jne 0x1569
movq %rsp, %r15
movq %r15, %rdi
callq 0x36e2
leaq 0xc(%rbx), %rsi
movq %r15, %rdi
callq 0x373b
testb %al, %al
je 0x1569
movl $0x0, 0x14(%rbx)
leaq 0x18(%rbx), %r12
movq %rsp, %r15
movq %r15, %rdi
callq 0x36e2
movq (%rsp), %rax
movzbl (%rax), %eax
testl %eax, %eax
je 0x1550
cmpl $0xa, %eax
je 0x1550
movq %r15, %rdi
callq 0x36e2
movq (%r14), %rax
movq (%rsp), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rsp)
movsbq (%rcx), %rcx
cmpl $0x58, (%rax,%rcx,4)
jne 0x1569
movq %r15, %rdi
callq 0x36e2
movslq 0x14(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
leaq (%r12,%rax,8), %rsi
movq %r15, %rdi
callq 0x373b
testb %al, %al
je 0x1569
cmpl $0x8, 0x14(%rbx)
jle 0x14ef
movq 0x8(%rsp), %rdi
callq 0x10f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x1080
nop
// File: /workspace/github_c_makefile_star2_O3/fm4dd[P]learn-ssl/certverify-adv.c
// Function: X509_load_ca_file
STACK_OF(X509_INFO) *X509_load_ca_file(int *cert_count, 
                                       struct stat fstat, const char *file) {
  STACK_OF(X509_INFO) *st = NULL;
  BIO *inbio=NULL;

  /* complain if we got an empty filename */
  if (file == NULL)
    BIO_printf(outbio, "Error receiving a valid CA bundle file name.\n");

  /* get file status data */
  if (stat(file, &fstat) != 0) {
    BIO_printf(outbio, "Error cannot stat cert bundle file: %s.\n", file);
    exit(1);
  }

  /* complain if the file is empty (0 bytes) */
  if(fstat.st_size == 0)
    BIO_printf(outbio, "Error cert bundle file size is zero bytes.\n");

  inbio=BIO_new(BIO_s_file());

  /* check if we can open the file for reading */
  if ((inbio == NULL) || (BIO_read_filename(inbio, file) <= 0))
    BIO_printf(outbio, "Error loading cert bundle file into memory.\n");

  /* read all certificates from file */
  if (! (st = PEM_X509_INFO_read_bio(inbio, NULL, NULL, NULL)))
    BIO_printf(outbio, "Error reading certs from BIO.\n");

  /* get the number of certs that are now on the stack */
  *cert_count = sk_X509_INFO_num(st);

  /* return the STACK_OF(X509_INFO) pointer, or exit */
  if (cert_count > 0) return st;
  else exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
testq %rsi, %rsi
jne 0x2831
movq 0x2ead(%rip), %rdi      # 0x56d0
leaq 0xb7e(%rip), %rsi       # 0x33a8
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
testl %eax, %eax
jne 0x28e1
cmpq $0x0, 0x30(%r15)
jne 0x2860
movq 0x2e7e(%rip), %rdi      # 0x56d0
leaq 0xba6(%rip), %rsi       # 0x33ff
xorl %eax, %eax
callq 0x22b0
callq 0x2060
movq %rax, %rdi
callq 0x2260
movq %rax, %r15
testq %rax, %rax
je 0x288e
movl $0x3, %edx
movq %r15, %rdi
movl $0x6c, %esi
movq %r14, %rcx
callq 0x2050
testl %eax, %eax
jg 0x28a3
movq 0x2e3b(%rip), %rdi      # 0x56d0
leaq 0xb8f(%rip), %rsi       # 0x342b
xorl %eax, %eax
callq 0x22b0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2070
movq %rax, %r14
testq %rax, %rax
jne 0x28ce
movq 0x2e10(%rip), %rdi      # 0x56d0
leaq 0xb91(%rip), %rsi       # 0x3458
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
callq 0x20a0
movl %eax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2de8(%rip), %rdi      # 0x56d0
leaq 0xae7(%rip), %rsi       # 0x33d6
movq %r14, %rdx
xorl %eax, %eax
callq 0x22b0
movl $0x1, %edi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/fm4dd[P]learn-ssl/certverify-adv.c
// Function: verify_mem_store
X509_STORE_CTX  *verify_mem_store(STACK_OF(X509_INFO) *st) {
  X509_STORE         *store = NULL;
  X509_STORE_CTX       *ctx = NULL;
  //STACK_OF(X509)  *ca_stack = NULL;
  X509_INFO      *list_item = NULL;
  int cert_count            = 0;
  int i                     = 0;

  /* ---------------------------------------------------------- *
   * Initialize the global certificate validation store object. *
   * ---------------------------------------------------------- */
  if (!(store=X509_STORE_new()))
     BIO_printf(outbio, "Error creating X509_STORE_CTX object\n");

  /* ---------------------------------------------------------- *
   * Create the context structure for the validation operation. *
   * ---------------------------------------------------------- */
  ctx = X509_STORE_CTX_new();

  /* ---------------------------------------------------------- *
   * Get the number of certs on the stack                       *
   * ---------------------------------------------------------- */
  cert_count = sk_X509_INFO_num(st);

  /* ---------------------------------------------------------- *
   * Complain if there is no cert                               *
   * ---------------------------------------------------------- */
  if (! (cert_count > 0)) {
    BIO_printf(outbio, "Error no certs on stack.\n");
    exit(1);
  }

  /* ---------------------------------------------------------- *
   * Cycle through all info stack items, extract the X509 cert  *
   * and put it into the X509_STORE called store.               *
   * ---------------------------------------------------------- */
  for (i = 0; i < cert_count; i++) {
    list_item = sk_X509_INFO_value(st, i);
    X509_STORE_add_cert(store, list_item->x509);
  }

  /* ---------------------------------------------------------- *
   * Initialize the ctx structure for a verification operation: *
   * Set the trusted cert store, the unvalidated cert, and any  *
   * potential certs that could be needed (here we set it NULL) *
   * ---------------------------------------------------------- */
  X509_STORE_CTX_init(ctx, store, cert, NULL);

  return ctx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x21b0
movq %rax, %rbx
testq %rax, %rax
jne 0x2930
movq 0x2dae(%rip), %rdi      # 0x56d0
leaq 0xa34(%rip), %rsi       # 0x335d
xorl %eax, %eax
callq 0x22b0
callq 0x2160
movq %rax, %r15
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
jle 0x2987
movl %eax, %ebp
xorl %r12d, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x21e0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x20c0
incl %r12d
cmpl %r12d, %ebp
jne 0x2949
movq 0x2d72(%rip), %rdx      # 0x56e0
movq %r15, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x20d0
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d42(%rip), %rdi      # 0x56d0
leaq 0xae2(%rip), %rsi       # 0x3477
xorl %eax, %eax
callq 0x22b0
movl $0x1, %edi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/fm4dd[P]learn-ssl/certverify-adv.c
// Function: verify_file_direct
X509_STORE_CTX  *verify_file_direct(const char *file) {
  X509_STORE         *store = NULL;
  X509_STORE_CTX  *vrfy_ctx = NULL;

  /* ---------------------------------------------------------- *
   * Initialize the global certificate validation store object. *
   * ---------------------------------------------------------- */
  if (!(store=X509_STORE_new()))
     BIO_printf(outbio, "Error creating X509_STORE_CTX object\n");

  /* ---------------------------------------------------------- *
   * Create the context structure for the validation operation. *
   * ---------------------------------------------------------- */
  vrfy_ctx = X509_STORE_CTX_new();

  /* ---------------------------------------------------------- *
   * Load the certificate and cacert chain from file (PEM).     *
   * ---------------------------------------------------------- */
  if ((X509_STORE_load_locations(store, file, NULL)) != 1)
    BIO_printf(outbio, "Error loading CA cert or chain file\n");

  /* ---------------------------------------------------------- *
   * Initialize the ctx structure for a verification operation: *
   * Set the trusted cert store, the unvalidated cert, and any  *
   * potential certs that could be needed (here we set it NULL) *
   * ---------------------------------------------------------- */
  X509_STORE_CTX_init(vrfy_ctx, store, cert, NULL);

  return vrfy_ctx; 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
callq 0x21b0
movq %rax, %rbx
testq %rax, %rax
jne 0x2b57
movq 0x2b87(%rip), %rdi      # 0x56d0
leaq 0x80d(%rip), %rsi       # 0x335d
xorl %eax, %eax
callq 0x22b0
callq 0x2160
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x22a0
cmpl $0x1, %eax
je 0x2b86
movq 0x2b58(%rip), %rdi      # 0x56d0
leaq 0x804(%rip), %rsi       # 0x3383
xorl %eax, %eax
callq 0x22b0
movq 0x2b53(%rip), %rdx      # 0x56e0
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x20d0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/dup1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	assert(fd >= 0);
	unlink(tmpfile);

	while (1) {
		int fd2 = dup(fd);

		assert(fd2 >= 0);
		close(fd2);

		(*iterations)++;
	}

	close(fd);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movaps 0x68c(%rip), %xmm0      # 0x3320
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movabsq $0x5858585858582e, %rax # imm = 0x5858585858582E
movq %rax, 0x10(%rdi)
callq 0x21e0
testl %eax, %eax
js 0x2cf1
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2080
movl %ebp, %edi
callq 0x2120
testl %eax, %eax
js 0x2cd2
movl %eax, %edi
callq 0x2150
incq (%rbx)
jmp 0x2cbb
leaq 0x62f(%rip), %rdi       # 0x3308
leaq 0x5e8(%rip), %rsi       # 0x32c8
leaq 0x5ee(%rip), %rcx       # 0x32d5
movl $0x12, %edx
callq 0x2130
leaq 0x5c8(%rip), %rdi       # 0x32c0
leaq 0x5c9(%rip), %rsi       # 0x32c8
leaq 0x5cf(%rip), %rcx       # 0x32d5
movl $0xc, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O3/eric-lo[P]3150/8-Synchronization/pthread_producer_consumer.c
// Function: producer
void *producer(void *nothing) {
	int item;
	unsigned int s;		// needed by thread-safe rand_r()

	while(1) {
		pthread_mutex_lock(&mutex);	// start of mutual exclusion.

			if(IS_FULL(head, tail, N))
				pthread_cond_wait(&full, &mutex);	// wait and unlock mutual exclusion.

			if(IS_EMPTY(head, tail, N))
				pthread_cond_signal(&empty);		// wake up the consumer.

			item = (rand_r(&s) % 26) + 'A';	// produce an item.
			buffer[tail] = item;		// insert an item.
			tail = NEXT_SLOT(tail, N);	// occupy one empty slot.
			drawing(PRODUCER_TURN, item);	// draw the change inside mutex.

		pthread_mutex_unlock(&mutex);	// end of mutual exclusion.

		if(rand_r(&s) % SLEEP_CHANCE == 0)
			sleep(1);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x2cd1(%rip), %rbx      # 0x40a0
leaq 0x2cf2(%rip), %r14      # 0x40c8
leaq 0x2d1b(%rip), %r15      # 0x40f8
leaq 0xc(%rsp), %r12
leaq 0x2d47(%rip), %r13      # 0x4130
movq %rbx, %rdi
callq 0x10f0
movl 0x2d35(%rip), %eax      # 0x412c
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
imulq $0x66666667, %rcx, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
negl %ecx
leal (%rax,%rcx), %edx
incl %edx
movl 0x2d05(%rip), %ecx      # 0x4128
cmpl %ecx, %edx
jne 0x143e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1030
movl 0x2cf4(%rip), %eax      # 0x412c
movl 0x2cea(%rip), %ecx      # 0x4128
cmpl %ecx, %eax
jne 0x144a
movq %r15, %rdi
callq 0x1060
movq %r12, %rdi
callq 0x1040
cltq
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x23, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %edx
leal (%rdx,%rdx,4), %edx
addl %ecx, %edx
negl %edx
leal (%rax,%rdx), %esi
addl $0x41, %esi
movslq 0x2cad(%rip), %rax      # 0x412c
movl %esi, (%r13,%rax,4)
incl %eax
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movl %eax, 0x2c83(%rip)      # 0x412c
xorl %edi, %edi
callq 0x11fc
movq %rbx, %rdi
callq 0x1090
movq %r12, %rdi
callq 0x1040
testb $0x3, %al
jne 0x13e9
movl $0x1, %edi
callq 0x10e0
jmp 0x13e9
// File: /workspace/github_c_makefile_star2_O3/eric-lo[P]3150/8-Synchronization/pthread_producer_consumer.c
// Function: consumer
void *consumer(void *nothing) {
	int item;
	unsigned int s;

	while(1) {
		pthread_mutex_lock(&mutex);	// start of mutual exclusion.

			if(IS_EMPTY(head, tail, N))
				pthread_cond_wait(&empty, &mutex);	// wait and unlock mutual exclusion.

			if(IS_FULL(head, tail, N))
				pthread_cond_signal(&full);		// wakeup the producer.

			item = buffer[head];		// consume an item.
			head = NEXT_SLOT(head, N);	// free one slot.
			drawing(CONSUMER_TURN, item);	// draw the change inside mutex.

		pthread_mutex_unlock(&mutex);	// end of mutual exclusion.

		if(rand_r(&s) % SLEEP_CHANCE == 0)
			sleep(1);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x2bb5(%rip), %rbx      # 0x40a0
leaq 0x2c06(%rip), %r14      # 0x40f8
leaq 0x2bcf(%rip), %r15      # 0x40c8
leaq 0x2c30(%rip), %r13      # 0x4130
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
callq 0x10f0
movl 0x2c19(%rip), %ecx      # 0x412c
movl 0x2c0f(%rip), %eax      # 0x4128
cmpl %eax, %ecx
jne 0x1534
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1030
movl 0x2bfe(%rip), %ecx      # 0x412c
movl 0x2bf4(%rip), %eax      # 0x4128
incl %ecx
movslq %ecx, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x22, %rdx
addl %esi, %edx
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
cmpl %eax, %ecx
jne 0x1566
movq %r15, %rdi
callq 0x1060
movl 0x2bc2(%rip), %eax      # 0x4128
cltq
movl (%r13,%rax,4), %esi
movl %eax, %ecx
incl %ecx
movslq %ecx, %rcx
imulq $0x66666667, %rcx, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
negl %ecx
addl %ecx, %eax
incl %eax
movl %eax, 0x2b8f(%rip)      # 0x4128
movl $0x1, %edi
callq 0x11fc
movq %rbx, %rdi
callq 0x1090
movq %r12, %rdi
callq 0x1040
testb $0x3, %al
jne 0x1505
movl $0x1, %edi
callq 0x10e0
jmp 0x1505
// File: /workspace/github_c_makefile_star2_O3/eric-lo[P]3150/8-Synchronization/pthread_producer_consumer.c
// Function: main
int main(void) {
	pthread_t tid1, tid2;

	srand(time(NULL));
	pthread_create(&tid1, NULL, producer, NULL);	// create producer
	pthread_create(&tid2, NULL, consumer, NULL);	// create consumer

	// The join statements are just used for suspending the main threads.
	pthread_join(tid1, NULL);	// never reached.
	pthread_join(tid2, NULL);	// never reached.

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorl %edi, %edi
callq 0x1080
movl %eax, %edi
callq 0x1050
leaq -0x22b(%rip), %rdx      # 0x13bb
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x10b0
leaq -0x127(%rip), %rdx      # 0x14d7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x10b0
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x10d0
movq (%r14), %rdi
xorl %esi, %esi
callq 0x10d0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/asg.c
// Function: asg_arc_del_short
int asg_arc_del_short(asg_t *g, float drop_ratio)
{
	uint32_t v, n_vtx = g->n_seq * 2, n_short = 0;
	for (v = 0; v < n_vtx; ++v) {
		asg_arc_t *av = asg_arc_a(g, v);
		uint32_t i, thres, nv = asg_arc_n(g, v);
		if (nv < 2) continue;
		thres = (uint32_t)(av[0].ol * drop_ratio + .499);
		for (i = nv - 1; i >= 1 && av[i].ol < thres; --i);
		for (i = i + 1; i < nv; ++i)
			av[i].del = 1, ++n_short;
	}
	if (n_short) {
		asg_cleanup(g);
		asg_symm(g);
	}
	fprintf(stderr, "[M::%s] removed %d short overlaps\n", __func__, n_short);
	return n_short;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x14(%rdi), %eax
addl %eax, %eax
je 0x1341
movq %rdi, %r14
movl %eax, %eax
xorl %ecx, %ecx
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movsd 0x8dd6(%rip), %xmm1     # 0xa060
pushq $0x1
popq %rsi
xorl %ebx, %ebx
movq 0x20(%r14), %rdi
movq (%rdi,%rcx,8), %r9
cmpl $0x2, %r9d
jb 0x1331
movq 0x8(%r14), %rdi
movq %r9, %r8
shrq $0x20, %r8
shlq $0x4, %r8
leaq (%rdi,%r8), %r10
movl 0xc(%r10), %r10d
andl %edx, %r10d
cvtsi2ss %r10d, %xmm2
mulss %xmm0, %xmm2
cvtss2sd %xmm2, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %r15
movl %r9d, %r10d
leal 0x1(%r9), %r11d
movq %r10, %r12
shlq $0x4, %r12
leaq (%rdi,%r8), %r13
addq $-0x4, %r13
cmpq $0x10, %r12
je 0x1302
movl (%r13,%r12), %ebp
andl %edx, %ebp
decl %r11d
addq $-0x10, %r12
cmpl %r15d, %ebp
jb 0x12e7
jmp 0x1305
movl %esi, %r11d
cmpl %r9d, %r11d
jae 0x1331
movl %r11d, %r15d
addl %r9d, %ebx
subq %r15, %r10
shlq $0x4, %r15
addq %r15, %r8
addq %r8, %rdi
addq $0xc, %rdi
orb $-0x80, 0x3(%rdi)
addq $0x10, %rdi
decq %r10
jne 0x1321
subl %r11d, %ebx
incq %rcx
cmpq %rax, %rcx
jne 0x128f
testl %ebx, %ebx
jne 0x1345
xorl %ebx, %ebx
jmp 0x1362
movq %r14, %rdi
callq 0x40c7
movq %r14, %rdi
callq 0x1394
movq %r14, %rdi
callq 0x1480
orb $-0x80, 0x17(%r14)
movq 0xcc8f(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x8cf5(%rip), %rsi      # 0xa068
leaq 0x8d11(%rip), %rdx      # 0xa08b
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1120
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/asg.c
// Function: asg_arc_del_multi
int asg_arc_del_multi(asg_t *g)
{
	uint32_t *cnt, n_vtx = g->n_seq * 2, n_multi = 0, v;
	cnt = (uint32_t*)calloc(n_vtx, 4);
	for (v = 0; v < n_vtx; ++v) {
		asg_arc_t *av = asg_arc_a(g, v);
		int32_t i, nv = asg_arc_n(g, v);
		if (nv < 2) continue;
		for (i = nv - 1; i >= 0; --i) ++cnt[av[i].v];
		for (i = nv - 1; i >= 0; --i)
			if (--cnt[av[i].v] != 0)
				av[i].del = 1, ++n_multi;
	}
	free(cnt);
	if (n_multi) asg_cleanup(g);
	fprintf(stderr, "[M::%s] removed %d multi-arcs\n", __func__, n_multi);
	return n_multi;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %r14d
addl %r14d, %r14d
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x10f0
testl %r14d, %r14d
jne 0x13c4
movq %rax, %rdi
callq 0x1040
xorl %ebp, %ebp
jmp 0x1452
xorl %ecx, %ecx
xorl %r15d, %r15d
movq 0x20(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
cmpl $0x2, %edx
jl 0x1430
movq 0x8(%rbx), %rsi
movq %rdx, %rdi
shrq $0x20, %rdi
decl %edx
movq %rdx, %r8
shlq $0x4, %r8
shlq $0x4, %rdi
leaq (%rsi,%rdi), %r9
addq $0x8, %r9
movq %r8, %r10
movl (%r9,%r10), %r11d
incl (%rax,%r11,4)
addq $-0x10, %r10
cmpq $-0x10, %r10
jne 0x13f9
incq %rdx
addq %r8, %rdi
addq %rdi, %rsi
addq $0xc, %rsi
movl -0x4(%rsi), %edi
decl (%rax,%rdi,4)
je 0x1427
orb $-0x80, 0x3(%rsi)
incl %r15d
addq $-0x10, %rsi
decq %rdx
jg 0x1418
incq %rcx
cmpq %r14, %rcx
jne 0x13c9
movq %rax, %rdi
callq 0x1040
xorl %ebp, %ebp
testl %r15d, %r15d
je 0x1452
movq %rbx, %rdi
callq 0x40c7
movl %r15d, %ebp
movq 0xcb9f(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x8c3a(%rip), %rsi      # 0xa09d
leaq 0x8c52(%rip), %rdx      # 0xa0bc
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1120
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/asg.c
// Function: asg_arc_del_asymm
int asg_arc_del_asymm(asg_t *g)
{
	uint32_t e, n_asymm = 0;
	for (e = 0; e < g->n_arc; ++e) {
		uint32_t v = g->arc[e].v^1, u = g->arc[e].ul>>32^1;
		uint32_t i, nv = asg_arc_n(g, v);
		asg_arc_t *av = asg_arc_a(g, v);
		for (i = 0; i < nv; ++i)
			if (av[i].v == u) break;
		if (i == nv) g->arc[e].del = 1, ++n_asymm;
	}
	if (n_asymm) asg_cleanup(g);
	fprintf(stderr, "[M::%s] removed %d asymmetric arcs\n", __func__, n_asymm);
	return n_asymm;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x4(%rdi), %ecx
testl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
je 0x1518
xorl %eax, %eax
xorl %ebx, %ebx
movq 0x8(%rdi), %rdx
movq 0x20(%rdi), %r8
movq %rax, %rsi
shlq $0x4, %rsi
movl 0x8(%rdx,%rsi), %r9d
xorq $0x1, %r9
movq (%r8,%r9,8), %r8
movl $0x0, %r10d
testl %r8d, %r8d
je 0x14f5
movl 0x4(%rdx,%rsi), %r9d
movq %r8, %r10
shrq $0x20, %r10
movl %r8d, %r11d
shlq $0x4, %r10
leaq (%rdx,%r10), %r14
addq $0x8, %r14
xorl %r10d, %r10d
movl (%r14), %ebp
xorl %r9d, %ebp
cmpl $0x1, %ebp
je 0x14f5
incq %r10
addq $0x10, %r14
cmpq %r10, %r11
jne 0x14dc
jmp 0x14fa
cmpl %r8d, %r10d
jne 0x1504
orb $-0x80, 0xf(%rdx,%rsi)
incl %ebx
movl 0x4(%rdi), %ecx
incq %rax
movl %ecx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
cmpq %rdx, %rax
jb 0x1497
testl %ebx, %ebx
jne 0x151c
xorl %ebx, %ebx
jmp 0x1521
callq 0x40c7
movq 0xcad0(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x8b9c(%rip), %rsi      # 0xa0ce
leaq 0x8bb9(%rip), %rdx      # 0xa0f2
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1120
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/sys.c
// Function: sys_timestamp
const char *sys_timestamp()
{
	static char buf[256];
	double rt, ct;
	rt = sys_realtime();
	ct = sys_cputime();
	snprintf(buf, 255, "%.3f*%.2f", rt, ct/rt);
	return buf;
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x10b0
cvtsi2sdq (%rbx), %xmm0
cvtsi2sdq 0x8(%rbx), %xmm1
mulsd 0x7097(%rip), %xmm1     # 0xa008
addsd %xmm0, %xmm1
subsd 0xb1d3(%rip), %xmm1     # 0xe150
movsd %xmm1, (%rsp)
leaq 0x10(%rsp), %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x11b0
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
addq (%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
addq 0x8(%rbx), %rcx
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
mulsd 0x7050(%rip), %xmm1     # 0xa008
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm0, %xmm1
leaq 0xb194(%rip), %rbx      # 0xe160
leaq 0x703d(%rip), %rdx      # 0xa010
movl $0xff, %esi
movq %rbx, %rdi
movb $0x2, %al
callq 0x10a0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/sdict.c
// Function: kh_put_str
sdict_t *sd_init(void)
{
	sdict_t *d;
	d = (sdict_t*)calloc(1, sizeof(sdict_t));
	d->h = kh_init(str);
	return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jb 0x3198
movl (%r14), %esi
movl 0x4(%r14), %eax
addl %eax, %eax
cmpl %eax, %esi
jbe 0x3186
decl %esi
jmp 0x3188
incl %esi
movq %r14, %rdi
callq 0x35b4
testl %eax, %eax
js 0x3292
movl (%r14), %r13d
leal -0x1(%r13), %esi
movsbl (%r15), %r12d
testl %r12d, %r12d
je 0x31cf
movb 0x1(%r15), %al
testb %al, %al
je 0x31d2
leaq 0x2(%r15), %rcx
movl %r12d, %edx
shll $0x5, %edx
subl %r12d, %edx
movsbl %al, %r12d
addl %edx, %r12d
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x31b4
jmp 0x31d2
xorl %r12d, %r12d
andl %esi, %r12d
movq 0x10(%r14), %rdi
movl %r12d, %eax
shrl $0x4, %eax
movl (%rdi,%rax,4), %eax
leal (%r12,%r12), %ecx
shrl %cl, %eax
testb $0x2, %al
je 0x31f4
movl %r12d, %r13d
jmp 0x32d5
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x28(%rsp)
movl $0x1, %r14d
movl %r12d, %ebx
movq %r13, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdi, 0x30(%rsp)
movl %ebx, %eax
shrl $0x4, %eax
movl (%rdi,%rax,4), %r15d
leal (%rbx,%rbx), %ebp
andl $0x1e, %ebp
movl %r15d, %eax
movl %ebp, %ecx
shrl %cl, %eax
testb $0x2, %al
jne 0x32a0
testb $0x1, %al
jne 0x325e
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl %ebx, %ecx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rsi
callq 0x1100
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
testl %eax, %eax
je 0x32a0
btl %ebp, %r15d
cmovbl %ebx, %r13d
addl %r14d, %ebx
andl %esi, %ebx
incl %r14d
cmpl %r12d, %ebx
jne 0x321a
movb $0x1, %al
movq 0x20(%rsp), %rdx
movl %edx, %ecx
cmpl %edx, %r13d
movq 0x28(%rsp), %rbx
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r15
je 0x32c6
jmp 0x32d5
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
movl (%r14), %r13d
jmp 0x3359
movl %ebp, %ecx
shrl %cl, %r15d
testb $0x2, %r15b
sete %al
movl %r13d, %ecx
movl %ebx, %r12d
movq 0x28(%rsp), %rbx
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r15
movq 0x20(%rsp), %rdx
cmpl %edx, %ecx
cmovel %r12d, %ecx
testb %al, %al
cmovnel %r12d, %ecx
movl %ecx, %r13d
movl %r13d, %eax
shrl $0x4, %eax
movl (%rdi,%rax,4), %edx
leal (,%r13,2), %ecx
andl $0x1e, %ecx
shrl %cl, %edx
testb $0x2, %dl
jne 0x32fd
testb $0x1, %dl
jne 0x3334
movl $0x0, (%rbx)
jmp 0x3359
movq 0x18(%r14), %rdx
movl $0x3, %esi
shll %cl, %esi
movl %r13d, %ecx
movq %r15, (%rdx,%rcx,8)
notl %esi
movq 0x10(%r14), %rcx
andl %esi, (%rcx,%rax,4)
movq 0x4(%r14), %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
movq %xmm0, 0x4(%r14)
movl $0x1, (%rbx)
jmp 0x3359
movq 0x18(%r14), %rdx
movl %r13d, %esi
movq %r15, (%rdx,%rsi,8)
movl $0x3, %edx
shll %cl, %edx
notl %edx
movq 0x10(%r14), %rcx
andl %edx, (%rcx,%rax,4)
incl 0x4(%r14)
movl $0x2, (%rbx)
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/sdict.c
// Function: sd_destroy
void sd_destroy(sdict_t *d)
{
	uint32_t i;
	if (d == 0) return;
	if (d->h) kh_destroy(str, (shash_t*)d->h);
	for (i = 0; i < d->n_seq; ++i)
		free(d->seq[i].name);
	free(d->seq);
	free(d);
}

// Assembly:
testq %rdi, %rdi
je 0x3090
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x3054
movq 0x18(%r14), %rdi
callq 0x1040
movq 0x10(%r14), %rdi
callq 0x1040
movq 0x20(%r14), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
cmpl $0x0, (%rbx)
je 0x307a
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x1040
incq %r15
movl (%rbx), %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x305f
movq 0x8(%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/sdict.c
// Function: sd_put
int32_t sd_put(sdict_t *d, const char *name, uint32_t len)
{
	shash_t *h = (shash_t*)d->h;
	khint_t k;
	int absent;
	k = kh_put(str, h, name, &absent);
	if (absent) {
		sd_seq_t *s;
		if (d->n_seq == d->m_seq) {
			d->m_seq = d->m_seq? d->m_seq<<1 : 16;
			d->seq = (sd_seq_t*)realloc(d->seq, d->m_seq * sizeof(sd_seq_t));
		}
		s = &d->seq[d->n_seq];
		s->len = len, s->aux = 0, s->del = 0;
		kh_key(h, k) = s->name = strdup(name);
		kh_val(h, k) = d->n_seq++;
	} // TODO: test if len is the same;
	return kh_val(h, k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %rbx
leaq 0x4(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3156
movl %eax, %ebp
cmpl $0x0, (%r13)
je 0x30f9
movl (%r14), %eax
cmpl 0x4(%r14), %eax
movl %r12d, (%rsp)
jne 0x3104
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x10, %esi
cmovnel %ecx, %esi
movl %esi, 0x4(%r14)
movq 0x8(%r14), %rdi
shlq $0x4, %rsi
callq 0x1180
movq %rax, %r13
movq %rax, 0x8(%r14)
movl (%r14), %eax
jmp 0x3108
movq 0x20(%rbx), %rax
movl %ebp, %ecx
movl (%rax,%rcx,4), %eax
jmp 0x3147
movq 0x8(%r14), %r13
movl %eax, %r12d
shlq $0x4, %r12
movl (%rsp), %eax
movl %eax, 0x8(%r13,%r12)
movl $0x0, 0xc(%r13,%r12)
movq %r15, %rdi
callq 0x1230
movq %rax, (%r13,%r12)
movq 0x18(%rbx), %rcx
movl %ebp, %edx
movq %rax, (%rcx,%rdx,8)
movl (%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%r14)
movq 0x20(%rbx), %rcx
movl %eax, (%rcx,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/sdict.c
// Function: sd_get
int32_t sd_get(const sdict_t *d, const char *name)
{
	shash_t *h = (shash_t*)d->h;
	khint_t k;
	k = kh_get(str, h, name);
	return k == kh_end(h)? -1 : kh_val(h, k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %ecx
testl %ecx, %ecx
je 0x33c3
movq %rsi, %r14
leal -0x1(%rcx), %edi
movsbl (%rsi), %r13d
testl %r13d, %r13d
movq %rcx, 0x18(%rsp)
je 0x33cb
movb 0x1(%r14), %al
testb %al, %al
je 0x33ce
leaq 0x2(%r14), %rcx
movl %r13d, %edx
shll $0x5, %edx
subl %r13d, %edx
movsbl %al, %r13d
addl %edx, %r13d
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x33a8
jmp 0x33ce
xorl %r15d, %r15d
jmp 0x3456
xorl %r13d, %r13d
andl %edi, %r13d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
movl $0x1, %ebx
movl %r13d, %r15d
movl %edi, 0x14(%rsp)
movq %rdx, 0x20(%rsp)
movl %r15d, %eax
shrl $0x4, %eax
movl (%rdx,%rax,4), %r12d
leal (%r15,%r15), %ebp
andl $0x1e, %ebp
movl %r12d, %eax
movl %ebp, %ecx
shrl %cl, %eax
testb $0x2, %al
jne 0x3444
testb $0x1, %al
jne 0x3430
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl %r15d, %ecx
movq (%rax,%rcx,8), %rdi
movq %r14, %rsi
callq 0x1100
movq 0x20(%rsp), %rdx
movl 0x14(%rsp), %edi
testl %eax, %eax
je 0x3444
addl %ebx, %r15d
andl %edi, %r15d
incl %ebx
cmpl %r13d, %r15d
jne 0x33eb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x346f
movl %ebp, %ecx
shrl %cl, %r12d
testb $0x3, %r12b
movq 0x18(%rsp), %rcx
cmovnel %ecx, %r15d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %r15d
je 0x346f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movl %r15d, %ecx
movl (%rax,%rcx,4), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/sdict.c
// Function: sd_hash
void sd_hash(sdict_t *d)
{
	uint32_t i;
	shash_t *h;
	if (d->h) return;
	d->h = h = kh_init(str);
	for (i = 0; i < d->n_seq; ++i) {
		int absent;
		khint_t k;
		k = kh_put(str, h, d->seq[i].name, &absent);
		kh_val(h, k) = i;
	}
}

// Assembly:
cmpq $0x0, 0x10(%rdi)
je 0x3486
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x10f0
movq %rax, 0x10(%rbx)
cmpl $0x0, (%rbx)
je 0x34e7
movq %rax, %r14
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3156
movq 0x20(%r14), %rcx
movl %eax, %eax
movl %r13d, (%rcx,%rax,4)
incq %r13
movl (%rbx), %eax
addq $0x10, %r12
cmpq %rax, %r13
jb 0x34bc
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/sdict.c
// Function: sd_squeeze
int32_t *sd_squeeze(sdict_t *d)
{
	int32_t *map, i, j;
	if (d->h) {
		kh_destroy(str, (shash_t*)d->h);
		d->h = 0;
	}
	map = (int32_t*)calloc(d->n_seq, 4);
	for (i = j = 0; i < d->n_seq; ++i) {
		if (d->seq[i].del) {
			free(d->seq[i].name);
			map[i] = -1;
		} else d->seq[j] = d->seq[i], map[i] = j++;
	}
	d->n_seq = j;
	sd_hash(d);
	return map;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x3534
movq 0x18(%r14), %rdi
callq 0x1040
movq 0x10(%r14), %rdi
callq 0x1040
movq 0x20(%r14), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq $0x0, 0x10(%rbx)
movl (%rbx), %r15d
movl $0x4, %esi
movq %r15, %rdi
callq 0x10f0
movq %rax, %r14
testq %r15, %r15
je 0x359c
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
leaq (%rax,%r15,4), %rcx
cmpl $0x0, 0xc(%rcx)
js 0x357b
movl %ebp, %edx
movslq %ebp, %rsi
movq %rsi, %rdi
shlq $0x4, %rdi
movups (%rcx), %xmm0
movups %xmm0, (%rax,%rdi)
incl %esi
movl %esi, %ebp
jmp 0x3588
movq (%rcx), %rdi
callq 0x1040
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %edx, (%r14,%r15)
incq %r12
movl (%rbx), %eax
addq $0x4, %r15
cmpq %rax, %r12
jb 0x3554
jmp 0x359e
xorl %ebp, %ebp
movl %ebp, (%rbx)
movq %rbx, %rdi
callq 0x347e
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/rikuu[P]kermit/miniasm/paf.c
// Function: paf_open
paf_file_t *paf_open(const char *fn)
{
	kstream_t *ks;
	gzFile fp;
	paf_file_t *pf;
	fp = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
	if (fp == 0) return 0;
	ks = ks_init(fp);
	pf = (paf_file_t*)calloc(1, sizeof(paf_file_t));
	pf->fp = ks;
	return pf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3872
cmpb $0x2d, (%rdi)
jne 0x3864
cmpb $0x0, 0x1(%rdi)
je 0x3872
leaq 0x67f1(%rip), %rsi      # 0xa05c
callq 0x11a0
jmp 0x388f
movq 0xa74f(%rip), %rax      # 0xdfc8
movq (%rax), %rdi
callq 0x1150
leaq 0x67d4(%rip), %rsi      # 0xa05c
movl %eax, %edi
callq 0x1080
movq %rax, %rbx
testq %rax, %rax
je 0x38d6
movl $0x1, %edi
movl $0x20, %esi
callq 0x10f0
movq %rax, %r14
movq %rbx, 0x10(%rax)
movl $0x40000, 0x8(%rax)     # imm = 0x40000
movl $0x10000, %edi          # imm = 0x10000
callq 0x1160
movq %rax, 0x18(%r14)
movl $0x1, %edi
movl $0x20, %esi
callq 0x10f0
movq %r14, (%rax)
jmp 0x38d8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq