LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: coverage
static int *coverage(void *cov, int *ncov)
{
	int fmt = U16(cov, 0);
	int n = U16(cov, 2);
	int beg, end;
	int i, j;
	int *out = malloc(glyph_n * sizeof(*out));
	int cnt = 0;
	if (fmt == 1) {
		for (i = 0; i < n; i++)
			out[cnt++] = U16(cov, 4 + 2 * i);
	}
	if (fmt == 2) {
		for (i = 0; i < n; i++) {
			beg = U16(cov, 4 + 6 * i);
			end = U16(cov, 4 + 6 * i + 2);
			for (j = beg; j <= end; j++)
				out[cnt++] = j;
		}
	}
	if (ncov)
		*ncov = cnt;
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x18(%rbp)
movslq 0x335f8(%rip), %rdi     # 0x76824
shlq $0x2, %rdi
callq 0x3d150
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x43292
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x43290
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
shll %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %edx
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x34(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4324d
jmp 0x43292
cmpl $0x2, -0x14(%rbp)
jne 0x4332b
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x43329
movq -0x8(%rbp), %rax
imull $0x6, -0x24(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
imull $0x6, -0x24(%rbp), %ecx
addl $0x4, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x43319
movl -0x28(%rbp), %edx
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x34(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x432ee
jmp 0x4331b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x432a3
jmp 0x4332b
cmpq $0x0, -0x10(%rbp)
je 0x4333b
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x433b5
jmp 0x4342a
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc0(%rcx), %eax
jge 0x433ef
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x147ff(%rip), %rdi     # 0x57bdc
movb $0x0, %al
callq 0x3d0b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x433bc
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xcc(%rcx), %eax
jge 0x4342a
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x40(%rax,%rcx,4), %esi
leaq 0x147c4(%rip), %rdi     # 0x57bdc
movb $0x0, %al
callq 0x3d0b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x433f6
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4344b
jmp 0x434cd
movq -0x8(%rbp), %rax
movl 0xcc(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc4(%rcx), %eax
jge 0x4348f
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x40(%rax,%rcx,4), %esi
leaq 0x1475f(%rip), %rdi     # 0x57bdc
movb $0x0, %al
callq 0x3d0b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4345b
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc8(%rcx), %eax
jge 0x434cd
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl 0x80(%rax,%rcx,4), %esi
leaq 0x14721(%rip), %rdi     # 0x57bdc
movb $0x0, %al
callq 0x3d0b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x43496
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x43670
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x4356f
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x43658
movl 0x5b32db(%rip), %eax    # 0x5f6850
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x5b32d0(%rip)    # 0x5f6850
movl %eax, -0x18(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0x3d150
movq %rax, %rdx
movslq -0x18(%rbp), %rcx
leaq 0x5b32c2(%rip), %rax    # 0x5f6860
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %edx
movslq -0x18(%rbp), %rcx
leaq 0x5b72b0(%rip), %rax    # 0x5fa860
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x435ee
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movslq -0x18(%rbp), %rcx
leaq 0x5b3288(%rip), %rax    # 0x5f6860
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x435ba
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0x145ec(%rip), %rdi     # 0x57be7
movb $0x0, %al
callq 0x3d0b0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x43644
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
leaq 0x3320c(%rip), %rsi     # 0x76830
shlq $0x6, %rax
addq %rax, %rsi
leaq 0x145f7(%rip), %rdi     # 0x57c29
movb $0x0, %al
callq 0x3d0b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x43609
leaq 0x312f(%rip), %rdi      # 0x4677a
movb $0x0, %al
callq 0x3d0b0
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: ggrp_find
static int ggrp_find(int *src, int n)
{
	int i, j;
	for (i = 0; i < ggrp_n; i++) {
		if (ggrp_len[i] == n) {
			for (j = 0; j < n; j++)
				if (src[j] != ggrp_g[i][j])
					break;
			if (j == n)
				return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x5b31c5(%rip), %eax    # 0x5f6850
jge 0x43700
movslq -0x18(%rbp), %rcx
leaq 0x5b71c8(%rip), %rax    # 0x5fa860
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x436f3
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x436e1
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movslq -0x18(%rbp), %rdx
leaq 0x5b319b(%rip), %rcx    # 0x5f6860
movq (%rcx,%rdx,8), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x436d4
jmp 0x436e1
jmp 0x436d6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x436a7
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x436f1
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x43707
jmp 0x436f3
jmp 0x436f5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x43682
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_gpostype1
static void otf_gpostype1(struct otf *otf, void *sub, char *feat)
{
	int fmt = U16(sub, 0);
	int vfmt = U16(sub, 4);
	int *cov;
	int ncov, nvals;
	int vlen = valuerecord_len(vfmt);
	int i;
	cov = coverage(sub + U16(sub, 2), &ncov);
	if (fmt == 1) {
		for (i = 0; i < ncov; i++) {
			if (valuerecord_small(vfmt, sub + 6))
				continue;
			printf("gpos %s 1 %s", feat, glyph_name[cov[i]]);
			valuerecord_print(vfmt, sub + 6);
			printf("\n");
		}
	}
	if (fmt == 2) {
		nvals = U16(sub, 6);
		for (i = 0; i < nvals; i++) {
			if (valuerecord_small(vfmt, sub + 6))
				continue;
			printf("gpos %s 1 %s", feat, glyph_name[cov[i]]);
			valuerecord_print(vfmt, sub + 8 + i * vlen);
			printf("\n");
		}
	}
	free(cov);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x44d40
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movq -0x40(%rbp), %rdi
movzwl %ax, %eax
cltq
addq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x431f0
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x43805
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x43803
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x6, %rsi
callq 0x44d90
cmpl $0x0, %eax
je 0x437ae
jmp 0x437f8
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
leaq 0x3306b(%rip), %rdx     # 0x76830
shlq $0x6, %rax
addq %rax, %rdx
leaq 0x1444d(%rip), %rdi     # 0x57c20
movb $0x0, %al
callq 0x3d0b0
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x6, %rsi
callq 0x44e60
leaq 0x2f89(%rip), %rdi      # 0x4677a
movb $0x0, %al
callq 0x3d0b0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4378f
jmp 0x43805
cmpl $0x2, -0x1c(%rbp)
jne 0x438ab
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x438a9
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x6, %rsi
callq 0x44d90
cmpl $0x0, %eax
je 0x43848
jmp 0x4389e
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
leaq 0x32fd1(%rip), %rdx     # 0x76830
shlq $0x6, %rax
addq %rax, %rdx
leaq 0x143b3(%rip), %rdi     # 0x57c20
movb $0x0, %al
callq 0x3d0b0
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movl -0x38(%rbp), %eax
imull -0x34(%rbp), %eax
cltq
addq %rax, %rsi
callq 0x44e60
leaq 0x2ee3(%rip), %rdi      # 0x4677a
movb $0x0, %al
callq 0x3d0b0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x43829
jmp 0x438ab
movq -0x28(%rbp), %rdi
callq 0x3d030
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: valuerecord_len
static int valuerecord_len(int fmt)
{
	int off = 0;
	int i;
	for (i = 0; i < 8; i++)
		if (fmt & (1 << i))
			off += 2;
	return off;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x44d87
movl -0x4(%rbp), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x44d7a
movl -0x8(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x8(%rbp)
jmp 0x44d7c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x44d55
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x44e44
movl -0x8(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x44e34
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movswl %ax, %edi
callq 0x40ca0
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl $0x1, %eax
leaq 0x2d9ec(%rip), %rcx     # 0x727e8
cmpl (%rcx), %eax
jge 0x44e0e
leaq 0x2d9e1(%rip), %rax     # 0x727e8
movl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x44e18
movl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x44e18
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jl 0x44e2b
movl $0x0, -0x4(%rbp)
jmp 0x44e4b
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x44e36
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x44dad
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3d0f0
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x8, -0x38(%rbp)
jge 0x44ee2
movl -0x4(%rbp), %eax
movl -0x38(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x44ed5
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movswl %ax, %edi
callq 0x40ca0
movl %eax, %ecx
movslq -0x38(%rbp), %rax
movl %ecx, -0x30(%rbp,%rax,4)
movl -0x34(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x34(%rbp)
jmp 0x44ed7
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x44e8d
cmpl $0x0, -0x4(%rbp)
je 0x44f03
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %r8d
leaq 0x12d31(%rip), %rdi     # 0x57c2d
movb $0x0, %al
callq 0x3d0b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x44fbc
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x44fba
movl -0x2c(%rbp), %edx
addl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
shll %ecx
addl $0x6, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %edx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x44f70
jmp 0x44fbc
cmpl $0x2, -0x1c(%rbp)
jne 0x45093
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x45091
movq -0x8(%rbp), %rax
imull $0x6, -0x24(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
imull $0x6, -0x24(%rbp), %ecx
addl $0x4, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x38(%rbp), %eax
jg 0x45081
movl -0x28(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
imull $0x6, -0x24(%rbp), %ecx
addl $0x4, %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4502f
jmp 0x45083
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x44fe0
jmp 0x45093
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0x3d150
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4511a
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x18(%rbp), %eax
jne 0x4510d
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x4510f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x450d5
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movl $0x4, %edx
leaq -0x1c0e(%rip), %rcx     # 0x43520
callq 0x3d060
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x43540
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3d030
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x12fe
jmp 0x1300
jmp 0x1300
movq 0x3cd1(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1ddf(%rip), %rdi      # 0x30f0
callq 0x10d0
cmpl $0x1, -0x8(%rbp)
jne 0x1337
movq 0x3cbd(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1e23(%rip), %rsi      # 0x3150
callq 0x1450
jmp 0x1424
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1422
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1df4(%rip), %rsi      # 0x3151
callq 0x1190
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x138b
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl $0x1, %edi
leaq 0x1dcf(%rip), %rsi      # 0x3153
movb $0x0, %al
callq 0x1180
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x2f, %esi
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x13b9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x13c9
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1450
movq -0x18(%rbp), %rdi
callq 0x1070
cmpl $0x0, %eax
je 0x140b
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movl $0x1, %edi
leaq 0x1d59(%rip), %rsi      # 0x315d
movb $0x0, %al
callq 0x1180
movq -0x18(%rbp), %rdi
callq 0x1080
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x133e
jmp 0x1424
movq 0x3bad(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1d33(%rip), %rdi      # 0x3168
callq 0x10d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_atom.c
// Function: printcontent
static void
printcontent(const char *s)
{
	for (; *s; ++s) {
		switch (*s) {
		case '<':  fputs("&lt;",   stdout); break;
		case '>':  fputs("&gt;",   stdout); break;
		case '\'': fputs("&#39;",  stdout); break;
		case '&':  fputs("&amp;",  stdout); break;
		case '"':  fputs("&quot;", stdout); break;
		case '\\':
			s++;
			switch (*s) {
			case 'n':  putchar('\n'); break;
			case '\\': putchar('\\'); break;
			case 't':  putchar('\t'); break;
			}
			break;
		default:  putchar(*s);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x189a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3a, %eax
ja 0x187b
movq -0x10(%rbp), %rax
leaq 0x1867(%rip), %rcx      # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x382b(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1ac9(%rip), %rdi      # 0x3280
callq 0x10d0
jmp 0x1887
movq 0x3810(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1ab3(%rip), %rdi      # 0x3285
callq 0x10d0
jmp 0x1887
movq 0x37f5(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1a9d(%rip), %rdi      # 0x328a
callq 0x10d0
jmp 0x1887
movq 0x37da(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1a88(%rip), %rdi      # 0x3290
callq 0x10d0
jmp 0x1887
movq 0x37c2(%rip), %rax      # 0x4fd8
movq (%rax), %rsi
leaq 0x1a76(%rip), %rdi      # 0x3296
callq 0x10d0
jmp 0x1887
movq -0x8(%rbp), %rax
incq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x5c, %eax
je 0x1863
jmp 0x1843
movl -0x14(%rbp), %eax
subl $0x6e, %eax
je 0x1857
jmp 0x184d
movl -0x14(%rbp), %eax
subl $0x74, %eax
je 0x186f
jmp 0x1879
movl $0xa, %edi
callq 0x1030
jmp 0x1879
movl $0x5c, %edi
callq 0x1030
jmp 0x1879
movl $0x9, %edi
callq 0x1030
jmp 0x1887
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x1030
jmp 0x1889
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x176c
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/trylock.c
// Function: counter_thread
void *counter_thread(void *arg)
{
	int spin;

	(void)arg;

	while (time(NULL) < end_time)
	{
		pthread_mutex_lock(&mutex);
		for (spin = 0; spin < SPIN; spin++)
			counter++;
		pthread_mutex_unlock(&mutex);
		sleep(1);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
cmpq 0x2ec4(%rip), %rax      # 0x40a0
jge 0x122f
leaq 0x2e93(%rip), %rdi      # 0x4078
callq 0x10b0
movl $0x0, -0xc(%rbp)
cmpl $0x989680, -0xc(%rbp)   # imm = 0x989680
jge 0x1217
movq 0x2ea7(%rip), %rax      # 0x40a8
addq $0x1, %rax
movq %rax, 0x2e9c(%rip)      # 0x40a8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11f1
leaq 0x2e5a(%rip), %rdi      # 0x4078
callq 0x1070
movl $0x1, %edi
callq 0x10a0
jmp 0x11cc
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/trylock.c
// Function: monitor_thread
void *monitor_thread(void *arg)
{
	int status;

	(void)arg;

	while (time(NULL) < end_time)
	{
		sleep(3);
		status = pthread_mutex_trylock(&mutex);
		if (status != EBUSY)
		{
			printf("Counter is %ld\n", counter/SPIN);
			pthread_mutex_unlock(&mutex);
		}
		else
			puts("(missed)");
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
cmpq 0x2e44(%rip), %rax      # 0x40a0
jge 0x12bb
movl $0x3, %edi
callq 0x10a0
leaq 0x2e09(%rip), %rdi      # 0x4078
callq 0x1050
movl %eax, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
je 0x12ad
movq 0x2e24(%rip), %rax      # 0x40a8
movl $0x989680, %ecx         # imm = 0x989680
cqto
idivq %rcx
movq %rax, %rsi
leaq 0xd6c(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
leaq 0x2dd2(%rip), %rdi      # 0x4078
callq 0x1070
jmp 0x12b9
leaq 0xd60(%rip), %rdi       # 0x2014
callq 0x1030
jmp 0x124c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/trylock.c
// Function: main
int main(void)
{
	pthread_t counter_thread_id, monitor_thread_id;

	end_time = time(NULL) + 60;
	pthread_create(&counter_thread_id, NULL, counter_thread, NULL);
	pthread_create(&monitor_thread_id, NULL, monitor_thread, NULL);

	pthread_join(counter_thread_id, NULL);
	pthread_join(monitor_thread_id, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
addq $0x3c, %rax
movq %rax, 0x2db4(%rip)      # 0x40a0
leaq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x13b(%rip), %rdx      # 0x11c0
movq %rcx, %rsi
callq 0x1080
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xd2(%rip), %rdx       # 0x1240
movq %rcx, %rsi
callq 0x1080
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/bof.c
// Function: main
int main(int argc, char *argv[]) {
  FILE *f;
  char line[64], *data;
  int size;

  if (argc < 3)
    return -1;

  if ((f = fopen(argv[1], "r")) == NULL)
    return -1;

  if (fgets(line, sizeof(line), f) == NULL)
    return -1;

  size = atoi(line);

  if ((data = malloc(size)) == NULL)
    return -1;

  fread(data, 1, 1024, f);
  data[1023] = 0;

  printf("Data: %s\n", data);

  fclose(f);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x11c8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x127f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe2d(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x11f2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x127f
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x40, %esi
callq 0x1060
cmpq $0x0, %rax
jne 0x1213
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x127f
leaq -0x60(%rbp), %rdi
callq 0x1090
movl %eax, -0x6c(%rbp)
movslq -0x6c(%rbp), %rdi
callq 0x1070
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
jne 0x123b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x127f
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1030
movq -0x68(%rbp), %rax
movb $0x0, 0x3ff(%rax)
movq -0x68(%rbp), %rsi
leaq 0xd9e(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/marcespie[P]unix-samples/chapter1/fork3.c
// Function: main
int
main()
{

	for (int i = 15; i < 35; i += 2) {
		int pid = fork();
		switch(pid) {
		case -1: 
			err(1, "fork");
		case 0:
			perform_computation(i);
			exit(0);
		}
	}

	// parent
	int rc = 0; // by default we succeed

	// XXX don't do that! this is example code.
	// Here we catch all children, remember that wait is a
	// "destructive" call, it gives you the status of one
	// deceased child, and removes all traces from the system.
	// If you have *other* children in other parts of your code
	// using wait means you *will* get any child that's dead.
	// (there's zero guarantee that you get the deceased in
	// any order at all).

	// there are several solutions
	// - have a central hub where you register all your children
	// and somehow demultiplex any status to the correct part of
	// the code (algorithmic)
	// - use waitpid NOHANG on each child you want (doesn't scale
	// with more than a few processes
	// - put processes into their own groups and use a pgrp
	int status, r;
	while ((r = wait(&status)) != -1)
		if (bad_status(status))
			rc = 1;
	// this normally exits with ECHILD, when we reaped every child
	if (errno != ECHILD)
		err(1, "wait");

	exit(rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0xf, -0x8(%rbp)
cmpl $0x23, -0x8(%rbp)
jge 0x1319
callq 0x10a0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $-0x1, %eax
je 0x12ea
jmp 0x12e1
movl -0x1c(%rbp), %eax
testl %eax, %eax
je 0x12fd
jmp 0x130c
movl $0x1, %edi
leaq 0xd7e(%rip), %rsi       # 0x2074
movb $0x0, %al
callq 0x1060
movl -0x8(%rbp), %edi
callq 0x11b0
xorl %edi, %edi
callq 0x1080
jmp 0x130e
movl -0x8(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x8(%rbp)
jmp 0x12c6
movl $0x0, -0x10(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x1090
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
je 0x1348
movl -0x14(%rbp), %edi
callq 0x11e0
testb $0x1, %al
jne 0x133f
jmp 0x1346
movl $0x1, -0x10(%rbp)
jmp 0x1320
callq 0x1030
cmpl $0xa, (%rax)
je 0x1365
movl $0x1, %edi
leaq 0xd1b(%rip), %rsi       # 0x2079
movb $0x0, %al
callq 0x1060
movl -0x10(%rbp), %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O0/lacework-dev[P]strace_lab_PUBLIC/./src/example_2.c
// Function: main
int main(int argc, char *argv[])
{
	
	char password[] = "secret123\n";

	for (int i = 0; i < 7; i+=1) {
		fork();

		char fout[10];
		strcpy(fout, &password[i]);

		char *fname = (char *)malloc(100);
		srand(31337);
		sprintf(fname, "/tmp/%d.log", ( getpid() ^ rand()));

		FILE *fd = fopen(fname, "a+");
		fputs(fout, fd);

		free(fname);
		fclose(fd);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xe07(%rip), %rax       # 0x2004
movq %rax, -0x1b(%rbp)
movw 0xe04(%rip), %ax        # 0x200c
movw %ax, -0x13(%rbp)
movb 0xdfc(%rip), %al        # 0x200e
movb %al, -0x11(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x7, -0x20(%rbp)
jge 0x12c4
callq 0x10c0
leaq -0x2a(%rbp), %rdi
movslq -0x20(%rbp), %rax
leaq -0x1b(%rbp), %rsi
addq %rax, %rsi
callq 0x1040
movl $0x64, %edi
callq 0x1090
movq %rax, -0x38(%rbp)
movl $0x7a69, %edi           # imm = 0x7A69
callq 0x1080
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x1050
movl %eax, -0x4c(%rbp)
callq 0x10d0
movl -0x4c(%rbp), %edx
movq -0x48(%rbp), %rdi
xorl %eax, %edx
leaq 0xd93(%rip), %rsi       # 0x200f
movb $0x0, %al
callq 0x10b0
movq -0x38(%rbp), %rdi
leaq 0xd8d(%rip), %rsi       # 0x201b
callq 0x10a0
movq %rax, -0x40(%rbp)
leaq -0x2a(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1070
movq -0x38(%rbp), %rdi
callq 0x1030
movq -0x40(%rbp), %rdi
callq 0x1060
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x121c
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.7/pipe.c
// Function: writer
void writer(const char *message, int count, FILE *stream)
{
    for (; count > 0; --count)
    {
        /* Write the message to the stream, and send it off immediately.  */
        fprintf(stream, "%s\n", message);
        fflush(stream);
        /* Snooze a while. */
        sleep(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x122d
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0xdfc(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rdi
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11f3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.7/pipe.c
// Function: reader
void reader(FILE *stream)
{
    char buffer[1024];
    /*Read until we hit the end of the stream. fgets reads until
  either a newline or the end-of-file.*/

    while (!feof(stream) && !ferror(stream) && fgets(buffer, sizeof(buffer), stream) != NULL)
        fputs(buffer, stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1090
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x411(%rbp)
jne 0x12a1
movq -0x8(%rbp), %rdi
callq 0x1030
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x411(%rbp)
jne 0x12a1
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x1070
cmpq $0x0, %rax
setne %al
movb %al, -0x411(%rbp)
movb -0x411(%rbp), %al
testb $0x1, %al
jne 0x12ad
jmp 0x12c5
leaq -0x410(%rbp), %rdi
movq 0x2d25(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1040
jmp 0x124f
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.7/pipe.c
// Function: main
int main()
{
    int fds[2];
    pid_t pid;
    /* Create a pipe. File descriptors for the two ends of the pipe are
  placed in fds. */
    pipe(fds);
    /* Fork a child process. */
    pid = fork();
    if (pid == (pid_t)0)
    {
        FILE *stream;
        /* This is the child process. Close our copy of the write end of
    the file descriptor. */
        close(fds[1]);
        /* Convert the read file descriptor to a FILE object, and read
    from it. */
        stream = fdopen(fds[0], "r");
        reader(stream);
        close(fds[0]);
    }
    else
    {
        /* This is the parent process. */
        FILE *stream;
        /* Close our copy of the read end of the file descriptor. */
        close(fds[0]);
        /* Convert the write file descriptor to a FILE object, and write to it */
        stream = fdopen(fds[1], "w");
        writer("Hello, world.", 5, stream);
        close(fds[1]);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1060
callq 0x10d0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x1324
movl -0x8(%rbp), %edi
callq 0x1050
movl -0xc(%rbp), %edi
leaq 0xd00(%rip), %rsi       # 0x2008
callq 0x10b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1240
movl -0xc(%rbp), %edi
callq 0x1050
jmp 0x135c
movl -0xc(%rbp), %edi
callq 0x1050
movl -0x8(%rbp), %edi
leaq 0xcd4(%rip), %rsi       # 0x200a
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
leaq 0xcc2(%rip), %rdi       # 0x200c
movl $0x5, %esi
callq 0x11e0
movl -0x8(%rbp), %edi
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/YanjieZe[P]CacheLab/test-trans.c
// Function: usage
void usage(char *argv[]){
    printf("Usage: %s [-h] -M <rows> -N <cols>\n", argv[0]);
    printf("Options:\n");
    printf("  -h          Print this help message.\n");
    printf("  -M <rows>   Number of matrix rows (max %d)\n", MAXN);
    printf("  -N <cols>   Number of  matrix columns (max %d)\n", MAXN);
    printf("Example: %s -M 8 -N 8\n", argv[0]);       
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x4b72(%rip), %rdi      # 0x628c
movb $0x0, %al
callq 0x1060
leaq 0x4b88(%rip), %rdi      # 0x62b0
movb $0x0, %al
callq 0x1060
leaq 0x4b84(%rip), %rdi      # 0x62ba
movb $0x0, %al
callq 0x1060
leaq 0x4b9e(%rip), %rdi      # 0x62e2
movl $0x100, %esi            # imm = 0x100
movb $0x0, %al
callq 0x1060
leaq 0x4bb9(%rip), %rdi      # 0x6310
movl $0x100, %esi            # imm = 0x100
movb $0x0, %al
callq 0x1060
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x4bd1(%rip), %rdi      # 0x6342
movb $0x0, %al
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/YanjieZe[P]CacheLab/test-trans.c
// Function: sigsegv_handler
void sigsegv_handler(int signum){
    printf("Error: Segmentation Fault.\n");
    printf("TEST_TRANS_RESULTS=0:0\n");
    fflush(stdout);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x4bc7(%rip), %rdi      # 0x6359
movb $0x0, %al
callq 0x1060
leaq 0x4ccf(%rip), %rdi      # 0x646f
movb $0x0, %al
callq 0x1060
movq 0x6822(%rip), %rax      # 0x7fd0
movq (%rax), %rdi
callq 0x1100
movl $0x1, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O0/YanjieZe[P]CacheLab/test-trans.c
// Function: sigalrm_handler
void sigalrm_handler(int signum){
    printf("Error: Program timed out.\n");
    printf("TEST_TRANS_RESULTS=0:0\n");
    fflush(stdout);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x4ba3(%rip), %rdi      # 0x6375
movb $0x0, %al
callq 0x1060
leaq 0x4c8f(%rip), %rdi      # 0x646f
movb $0x0, %al
callq 0x1060
movq 0x67e2(%rip), %rax      # 0x7fd0
movq (%rax), %rdi
callq 0x1100
movl $0x1, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/examples/sketch_parsed_with_ordering.c
// Function: rev_order_func
static int rev_order_func(const char *s1, const char *s2, void *data)
{
  int ret = 0;
  const char *str = (const char*) data;
  printf("string: %s\n", str);
  ret = strcmp(s1, s2) * -1;
  return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
leaq 0x151f6a(%rip), %rdi    # 0x15e069
movb $0x0, %al
callq 0xb070
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb850
imull $-0x1, %eax, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7ee8(%rip), %rax      # 0x91f8
movq %rax, -0x18(%rbp)
leaq 0x7f5d(%rip), %rax      # 0x9278
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x1344
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1110
movq %rax, -0xe0(%rbp)
jmp 0x1352
movl $0x20, %eax
movq %rax, -0xe0(%rbp)
jmp 0x1352
movq -0xe0(%rbp), %rax
shlq $0x14, %rax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1640
callq 0x1130
movl %eax, %edi
callq 0x1080
movl %eax, -0x28(%rbp)
callq 0x1130
cmpl $0xa, %eax
je 0x138f
movl $0x1, %edi
callq 0x1090
cmpl $0x54, -0x28(%rbp)
jne 0x1397
jmp 0x13f3
cmpl $0x44, -0x28(%rbp)
je 0x13a7
movl $0x1, %edi
callq 0x1090
jmp 0x13a9
jmp 0x13ab
movq -0x20(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movl $0x1e, %edx
callq 0x19e0
movq -0xe8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x58, %edx
callq 0x11b0
movq -0x20(%rbp), %rdi
callq 0x4640
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4410
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x1450
movq -0xf0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
movl $0x58, %edx
callq 0x11b0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3e70
testb $0x1, %al
jne 0x143d
movl $0x1, %edi
callq 0x1090
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4410
jmp 0x13ab
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2994
movq 0x3d4a(%rip), %rdi      # 0x66d0
leaq 0x1367(%rip), %rsi      # 0x3cf4
movb $0x0, %al
callq 0x22b0
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x2180
cmpl $0x0, %eax
je 0x29c9
movq 0x3d23(%rip), %rdi      # 0x66d0
movq -0x10(%rbp), %rdx
leaq 0x136a(%rip), %rsi      # 0x3d22
movb $0x0, %al
callq 0x22b0
movl $0x1, %edi
callq 0x21c0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x29e9
movq 0x3cf5(%rip), %rdi      # 0x66d0
leaq 0x1369(%rip), %rsi      # 0x3d4b
movb $0x0, %al
callq 0x22b0
callq 0x2060
movq %rax, %rdi
callq 0x2260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2a1d
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x6c, %esi
movl $0x3, %edx
callq 0x2050
cmpl $0x0, %eax
jg 0x2a32
movq 0x3cac(%rip), %rdi      # 0x66d0
leaq 0x134c(%rip), %rsi      # 0x3d77
movb $0x0, %al
callq 0x22b0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x2070
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2a64
movq 0x3c7a(%rip), %rdi      # 0x66d0
leaq 0x1347(%rip), %rsi      # 0x3da4
movb $0x0, %al
callq 0x22b0
movq -0x18(%rbp), %rdi
callq 0x2e70
movq %rax, %rdi
callq 0x20a0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x8(%rbp)
jbe 0x2a8e
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movl $0x1, %edi
callq 0x21c0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x21b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x2e10
movq 0x38ce(%rip), %rdi      # 0x66d0
leaq 0xea0(%rip), %rsi       # 0x3ca9
movb $0x0, %al
callq 0x22b0
callq 0x2160
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x22a0
cmpl $0x1, %eax
je 0x2e44
movq 0x389a(%rip), %rdi      # 0x66d0
leaq 0xe92(%rip), %rsi       # 0x3ccf
movb $0x0, %al
callq 0x22b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x388d(%rip), %rdx      # 0x66e0
xorl %eax, %eax
movl %eax, %ecx
callq 0x20d0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1309(%rip), %rax      # 0x42e0
movq %rax, -0x30(%rbp)
movq 0x1306(%rip), %rax      # 0x42e8
movq %rax, -0x28(%rbp)
movq 0x1303(%rip), %rax      # 0x42f0
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x21d0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x3005
jmp 0x3024
leaq 0x1274(%rip), %rdi      # 0x4280
leaq 0x1275(%rip), %rsi      # 0x4288
movl $0xc, %edx
leaq 0x1276(%rip), %rcx      # 0x4295
callq 0x2120
leaq -0x30(%rbp), %rdi
callq 0x2080
movl -0x34(%rbp), %edi
callq 0x2110
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jl 0x3040
jmp 0x305f
leaq 0x1281(%rip), %rdi      # 0x42c8
leaq 0x123a(%rip), %rsi      # 0x4288
movl $0x12, %edx
leaq 0x123b(%rip), %rcx      # 0x4295
callq 0x2120
movl -0x38(%rbp), %edi
callq 0x2140
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x302d