LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_fatal
static void
dbug_fatal(char *fmt, ...)
{
	va_list va;
	FILE *f;
	char *p;

	f = stderr;
	p = "";
	if (dbug_cfg) {
		if (dbug_cfg->output) {
			f = dbug_cfg->output;
		}
		if (dbug_cfg->process) {
			p = dbug_cfg->process;
		}
	}
	fprintf(f, "\n%s(DBUG) FATAL: ", p);
	fflush(f);
	va_start(va, fmt);
	vfprintf(f, fmt, va);
	va_end(va);
	fputc('\n', f);
	fflush(f);
	abort();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r14
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1afdc
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x9015(%rip), %rax      # 0x23ff8
movq (%rax), %rbx
movq 0x9343(%rip), %rax      # 0x24330
testq %rax, %rax
jne 0x1affb
leaq 0x1351(%rip), %rdx      # 0x1c34a
jmp 0x1b018
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rax
testq %rax, %rax
cmovneq %rax, %rbx
testq %rcx, %rcx
leaq 0x1336(%rip), %rdx      # 0x1c34a
cmovneq %rcx, %rdx
leaq 0x3858(%rip), %rsi      # 0x1e877
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
movq %rbx, %rdi
callq 0x21c0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21c0
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_enter
void
dbug_enter(struct dbug_ctx_t *ctx)
{
	dbug_cfg->ctx = ctx;
	if (selected() && (dbug_on & DBUG_TRACE_ON)) {
		prefix();
		fprintf(dbug_cfg->output, ">%.31s\n", ctx->name);
		if (fflush(dbug_cfg->output) == EOF) {
			io_error();
		}
	}
	++ctx->depth;
	return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x92ac(%rip), %rax      # 0x24330
movq %rdi, 0x50(%rax)
callq 0x1a816
testl %eax, %eax
je 0x1b0d0
testb $0x2, 0x9898(%rip)      # 0x24930
je 0x1b0d0
callq 0x1ac8b
movq 0x928a(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
movq (%rbx), %rdx
leaq 0x36c2(%rip), %rsi      # 0x1e776
xorl %eax, %eax
callq 0x2180
movq 0x926e(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x1b0d5
incl 0x8(%rbx)
popq %rbx
retq
callq 0x1b0da
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_print
void
dbug_print(char *fmt, ...)
{
	va_list va;

	prefix();
	fprintf(dbug_cfg->output, "%.31s: ", dbug_cfg->ctx->keyword);
	fflush(dbug_cfg->output);
	va_start(va, fmt);
	vfprintf(dbug_cfg->output, fmt, va);
	va_end(va);
	fputc('\n', dbug_cfg->output);
	if (fflush(dbug_cfg->output) == EOF) {
		io_error();
	}
	return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1b151
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x1ac8b
movq 0x91d3(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
movq 0x50(%rax), %rax
movq 0x10(%rax), %rdx
leaq 0x360e(%rip), %rsi      # 0x1e77e
xorl %eax, %eax
callq 0x2180
movq 0x91b2(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
callq 0x21c0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq 0x9182(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0x2210
movq 0x916f(%rip), %rax      # 0x24330
movq 0x18(%rax), %rsi
pushq $0xa
popq %rdi
callq 0x2130
movq 0x915c(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x1b1ed
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
callq 0x1b0da
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_return
void
dbug_return(struct dbug_ctx_t *ctx)
{
	if (ctx != dbug_cfg->ctx) {
		dbug_fatal("missing DBUG_RETURN detected in '%s' (%s:%d)",
			dbug_cfg->ctx->name,
			dbug_cfg->ctx->unit->name,
			dbug_cfg->ctx->line);
	}
	--ctx->depth;
	if (selected() && (dbug_on & DBUG_TRACE_ON)) {
		prefix();
		fprintf(dbug_cfg->output, "<%.31s\n", ctx->name);
		if (fflush(dbug_cfg->output) == EOF) {
			io_error();
		}
	}
	dbug_cfg->ctx = ctx->caller;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x9133(%rip), %r14      # 0x24330
movq 0x50(%r14), %rax
cmpq %rdi, %rax
jne 0x1b26b
movq %rdi, %rbx
decl 0x8(%rdi)
callq 0x1a816
testl %eax, %eax
je 0x1b25b
testb $0x2, 0x9714(%rip)      # 0x24930
je 0x1b25b
callq 0x1ac8b
movq 0x9106(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
movq (%rbx), %rdx
leaq 0x357b(%rip), %rsi      # 0x1e7b3
xorl %eax, %eax
callq 0x2180
movq 0x90ea(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x1b286
movq 0x90d5(%rip), %r14      # 0x24330
movq 0x20(%rbx), %rax
movq %rax, 0x50(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rax), %rsi
movq 0x18(%rax), %rcx
movq (%rcx), %rdx
movl 0xc(%rax), %ecx
leaq 0x3507(%rip), %rdi      # 0x1e786
xorl %eax, %eax
callq 0x1af7b
callq 0x1b0da
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/dbug.c
// Function: dbug_hexdump
void
dbug_hexdump(void *p, int n)
{
	unsigned char *bp = p;
	char asc[16 + 1];
	int i;
	int c;

	while (n > 0) {
		fprintf(dbug_cfg->output, "%p  ", bp);
		for (i = 0; i < 16; ++i) {
			if (i < n) {
				c = bp[i];
				if ((c >= ' ') && (c < 0x7F)) {
					asc[i] = c;
				} else {
					asc[i] = '.';
				}
				fprintf(dbug_cfg->output, " %02x", c);
			} else {
				asc[i] = ' ';
				fprintf(dbug_cfg->output, "   ");
			}
		}
		asc[16] = '\0';
		fprintf(dbug_cfg->output, "  |%16.16s|\n", asc);
		bp += 16;
		n -= 16;
	}
	fflush(dbug_cfg->output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq %esi, %r12
leaq 0x3520(%rip), %rbp      # 0x1e7c6
pushq $0x3
popq %r14
pushq $0x1
popq %r15
movq 0x907b(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
testq %r12, %r12
jle 0x1b361
leaq 0x34f2(%rip), %rsi      # 0x1e7bb
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x1b333
cmpq %r12, %r13
jge 0x1b310
movzbl (%rbx,%r13), %edx
leal -0x20(%rdx), %eax
cmpb $0x5f, %al
pushq $0x2e
popq %rax
cmovbl %edx, %eax
movb %al, (%rsp,%r13)
movq 0x9034(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
leaq 0x34b9(%rip), %rsi      # 0x1e7c0
xorl %eax, %eax
callq 0x2180
jmp 0x1b32e
movb $0x20, (%rsp,%r13)
movq 0x9014(%rip), %rax      # 0x24330
movq 0x18(%rax), %rcx
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2250
incq %r13
jmp 0x1b2d6
movb $0x0, 0x10(%rsp)
movq 0x8ff1(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
leaq 0x3480(%rip), %rsi      # 0x1e7ca
movq %rsp, %rdx
xorl %eax, %eax
callq 0x2180
addq $0x10, %rbx
addq $-0x10, %r12
jmp 0x1b2ae
callq 0x21c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/dbug.c
// Function: mk_string
static char *
mk_string(char *p)
{
	static char buf[256];
	char *q;
	int n;

	if (*p == ',') {			/* skip leading comma, if any */
		++p;
	}
	for (q = p; *q && (*q != ':'); ++q)	/* find the end of the token */
		;
	n = (int)(q - p);
	if (n > (sizeof(buf) - 1)) {		/* safegaurd the copy size */
		n = (sizeof(buf) - 1);
	}
	memset(buf, '\0', sizeof(buf));
	strncpy(buf, p, n);
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpb $0x2c, (%rdi)
sete %bl
addq %rdi, %rbx
xorl %r15d, %r15d
movabsq $0x100000000, %rax      # imm = 0x100000000
xorl %r12d, %r12d
movzbl (%rbx,%r15), %ecx
testl %ecx, %ecx
je 0x1b3ae
cmpl $0x3a, %ecx
je 0x1b3ae
addq %rax, %r12
incq %r15
jmp 0x1b398
sarq $0x20, %r12
leaq 0x9587(%rip), %r14      # 0x24940
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x2110
testl $0xffffff00, %r15d      # imm = 0xFFFFFF00
movl $0xff, %edx
cmoveq %r12, %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/dbug.c
// Function: call_trace
static void
call_trace(struct dbug_ctx_t *ctx)
{
	if (ctx && (ctx != &base_ctx)) {
		if (ctx->caller && (ctx->caller != &base_ctx)) {
			call_trace(ctx->caller);
			fprintf(dbug_cfg->output, ",%.31s", ctx->name);
		} else {
			fprintf(dbug_cfg->output, "%.31s", ctx->name);
		}
	}
	return;
}

// Assembly:
testq %rdi, %rdi
sete %cl
leaq 0x8f3d(%rip), %rax      # 0x24338
cmpq %rax, %rdi
sete %dl
orb %cl, %dl
jne 0x1b426
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
setne %cl
cmpq %rax, %rdi
setne %al
testb %al, %cl
jne 0x1b427
leaq 0x344d(%rip), %rsi      # 0x1e871
jmp 0x1b433
retq
callq 0x1b3ee
leaq 0x343d(%rip), %rsi      # 0x1e870
movq 0x8ef6(%rip), %rax      # 0x24330
movq 0x18(%rax), %rdi
movq (%rbx), %rdx
xorl %eax, %eax
popq %rbx
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O2/wtakuo[P]SVM/cbench.c
// Function: tak
int tak (int x, int y, int z) {
    if (x <= y)
        return y;
    else
        return tak(tak(x - 1, y, z),
                   tak(y - 1, z, x),
                   tak(z - 1, x, y));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %r15d
cmpl %r14d, %r15d
jle 0x11ab
leal -0x1(%r15), %edi
movl %r14d, %esi
movl %ebx, %edx
callq 0x115c
movl %eax, %ebp
leal -0x1(%r14), %edi
movl %ebx, %esi
movl %r15d, %edx
callq 0x115c
movl %eax, %r12d
decl %ebx
movl %ebx, %edi
movl %r15d, %esi
movl %r14d, %edx
callq 0x115c
movl %eax, %ebx
movl %ebp, %r15d
movl %r12d, %r14d
jmp 0x116c
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wtakuo[P]SVM/cbench.c
// Function: main
int main (int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "usage: %s x y z\n", argv[0]);
        return EXIT_FAILURE;
    }
    int x = atoi(argv[1]);
    int y = atoi(argv[2]);
    int z = atoi(argv[3]);

    printf(">>> %d\n", tak(x, y, z));

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x4, %edi
jne 0x1208
movq 0x8(%rbx), %rdi
callq 0x1050
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x1050
movl %eax, %r14d
movq 0x18(%rbx), %rdi
callq 0x1050
movl %ebp, %edi
movl %r14d, %esi
movl %eax, %edx
callq 0x115c
leaq 0xe1f(%rip), %rdi       # 0x2015
xorl %ebx, %ebx
movl %eax, %esi
xorl %eax, %eax
callq 0x1030
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2de9(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0xde8(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1040
pushq $0x1
popq %rbx
jmp 0x1201
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_create
struct rb_table *
rb_create (rb_comparison_func *compare, void *param,
            struct libavl_allocator *allocator)
{
  struct rb_table *tree;

  assert (compare != NULL);

  if (allocator == NULL)
    allocator = &rb_allocator_default;

  tree = allocator->libavl_malloc (allocator, sizeof *tree);
  if (tree == NULL)
    return NULL;

  tree->rb_root = NULL;
  tree->rb_compare = compare;
  tree->rb_param = param;
  tree->rb_alloc = allocator;
  tree->rb_count = 0;
  tree->rb_generation = 0;

  return tree;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x11d5
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
leaq 0x3eb2(%rip), %r15      # 0x5058
cmovneq %rdx, %r15
pushq $0x30
popq %rsi
movq %r15, %rdi
callq *(%r15)
testq %rax, %rax
je 0x11cf
andq $0x0, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1e44(%rip), %rdi      # 0x3020
leaq 0x1e4d(%rip), %rsi      # 0x3030
leaq 0x1e4b(%rip), %rcx      # 0x3035
pushq $0x2a
popq %rdx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_find
void *
rb_find (const struct rb_table *tree, const void *item)
{
  const struct rb_node *p;

  assert (tree != NULL && item != NULL);
  for (p = tree->rb_root; p != NULL; )
    {
      int cmp = tree->rb_compare (item, p->rb_data, tree->rb_param);

      if (cmp < 0)
        p = p->rb_link[0];
      else if (cmp > 0)
        p = p->rb_link[1];
      else /* |cmp == 0| */
        return p->rb_data;
    }

  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1249
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1249
movq %rdi, %r14
xorl %r15d, %r15d
movq %rdi, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x123a
movq 0x10(%r12), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq *0x8(%r14)
testl %eax, %eax
js 0x1210
je 0x1235
addq $0x8, %r12
jmp 0x1210
movq 0x10(%r12), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1f8c(%rip), %rdi      # 0x31dc
leaq 0x1dd9(%rip), %rsi      # 0x3030
leaq 0x1e2b(%rip), %rcx      # 0x3089
pushq $0x44
popq %rdx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_replace
void *
rb_replace (struct rb_table *table, void *item)
{
  void **p = rb_probe (table, item);
  if (p == NULL || *p == item)
    return NULL;
  else
    {
      void *r = *p;
      *p = item;
      return r;
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x1266
testq %rax, %rax
je 0x148b
movq %rax, %rcx
movq (%rax), %rax
cmpq %rbx, %rax
je 0x148b
movq %rbx, (%rcx)
jmp 0x148d
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_first
void *
rb_t_first (struct rb_traverser *trav, struct rb_table *tree)
{
  struct rb_node *x;

  assert (tree != NULL && trav != NULL);

  trav->rb_table = tree;
  trav->rb_height = 0;
  trav->rb_generation = tree->rb_generation;

  x = tree->rb_root;
  if (x != NULL)
    while (x->rb_link[0] != NULL)
      {
        assert (trav->rb_height < RB_MAX_HEIGHT);
        trav->rb_stack[trav->rb_height++] = x;
        x = x->rb_link[0];
      }
  trav->rb_node = x;

  return x != NULL ? x->rb_data : NULL;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x18d5
testq %rsi, %rsi
je 0x18d5
movq %rsi, (%rdi)
andq $0x0, 0x190(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x198(%rdi)
movq (%rsi), %rax
testq %rax, %rax
je 0x18ad
xorl %ecx, %ecx
cmpq $0x0, (%rax)
je 0x18a3
cmpq $0x30, %rcx
jae 0x18b6
leaq 0x1(%rcx), %rdx
movq %rdx, 0x190(%rdi)
movq %rax, 0x10(%rdi,%rcx,8)
movq (%rax), %rax
movq %rdx, %rcx
jmp 0x187f
movq %rax, 0x8(%rdi)
movq 0x10(%rax), %rax
jmp 0x18b4
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
popq %rcx
retq
leaq 0x18b5(%rip), %rdi      # 0x3172
leaq 0x176c(%rip), %rsi      # 0x3030
leaq 0x186c(%rip), %rcx      # 0x3137
movl $0x1e7, %edx            # imm = 0x1E7
callq 0x1040
leaq 0x183e(%rip), %rdi      # 0x311a
leaq 0x174d(%rip), %rsi      # 0x3030
leaq 0x184d(%rip), %rcx      # 0x3137
movl $0x1dd, %edx            # imm = 0x1DD
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_last
void *
rb_t_last (struct rb_traverser *trav, struct rb_table *tree)
{
  struct rb_node *x;

  assert (tree != NULL && trav != NULL);

  trav->rb_table = tree;
  trav->rb_height = 0;
  trav->rb_generation = tree->rb_generation;

  x = tree->rb_root;
  if (x != NULL)
    while (x->rb_link[1] != NULL)
      {
        assert (trav->rb_height < RB_MAX_HEIGHT);
        trav->rb_stack[trav->rb_height++] = x;
        x = x->rb_link[1];
      }
  trav->rb_node = x;

  return x != NULL ? x->rb_data : NULL;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1977
testq %rsi, %rsi
je 0x1977
movq %rsi, (%rdi)
andq $0x0, 0x190(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x198(%rdi)
movq (%rsi), %rax
testq %rax, %rax
je 0x194f
xorl %ecx, %ecx
cmpq $0x0, 0x8(%rax)
je 0x1945
cmpq $0x30, %rcx
jae 0x1958
leaq 0x1(%rcx), %rdx
movq %rdx, 0x190(%rdi)
movq %rax, 0x10(%rdi,%rcx,8)
movq 0x8(%rax), %rax
movq %rdx, %rcx
jmp 0x191f
movq %rax, 0x8(%rdi)
movq 0x10(%rax), %rax
jmp 0x1956
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
popq %rcx
retq
leaq 0x1813(%rip), %rdi      # 0x3172
leaq 0x16ca(%rip), %rsi      # 0x3030
leaq 0x1825(%rip), %rcx      # 0x3192
movl $0x202, %edx            # imm = 0x202
callq 0x1040
leaq 0x179c(%rip), %rdi      # 0x311a
leaq 0x16ab(%rip), %rsi      # 0x3030
leaq 0x1806(%rip), %rcx      # 0x3192
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_find
void *
rb_t_find (struct rb_traverser *trav, struct rb_table *tree, void *item)
{
  struct rb_node *p, *q;

  assert (trav != NULL && tree != NULL && item != NULL);
  trav->rb_table = tree;
  trav->rb_height = 0;
  trav->rb_generation = tree->rb_generation;
  for (p = tree->rb_root; p != NULL; p = q)
    {
      int cmp = tree->rb_compare (item, p->rb_data, tree->rb_param);

      if (cmp < 0)
        q = p->rb_link[0];
      else if (cmp > 0)
        q = p->rb_link[1];
      else /* |cmp == 0| */
        {
          trav->rb_node = p;
          return p->rb_data;
        }

      assert (trav->rb_height < RB_MAX_HEIGHT);
      trav->rb_stack[trav->rb_height++] = p;
    }

  trav->rb_height = 0;
  trav->rb_node = NULL;
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a68
movq %rsi, %r15
testq %rsi, %rsi
je 0x1a68
movq %rdx, %r14
testq %rdx, %rdx
je 0x1a68
movq %rdi, %rbx
movq %r15, (%rdi)
andq $0x0, 0x190(%rdi)
movq 0x28(%r15), %rax
movq %rax, 0x198(%rdi)
movq (%r15), %r12
testq %r12, %r12
je 0x1a23
movq 0x10(%r12), %rsi
movq 0x10(%r15), %rdx
movq %r14, %rdi
callq *0x8(%r15)
movq %r12, %rcx
testl %eax, %eax
js 0x19fe
je 0x1a34
leaq 0x8(%r12), %rcx
movq 0x190(%rbx), %rax
cmpq $0x30, %rax
jae 0x1a49
movq (%rcx), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x190(%rbx)
movq %r12, 0x10(%rbx,%rax,8)
movq %rcx, %r12
jmp 0x19db
andq $0x0, 0x190(%rbx)
andq $0x0, 0x8(%rbx)
xorl %eax, %eax
jmp 0x1a3d
movq %r12, 0x8(%rbx)
movq 0x10(%r12), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1722(%rip), %rdi      # 0x3172
leaq 0x15d9(%rip), %rsi      # 0x3030
leaq 0x179b(%rip), %rcx      # 0x31f9
movl $0x227, %edx            # imm = 0x227
callq 0x1040
leaq 0x175d(%rip), %rdi      # 0x31cc
leaq 0x15ba(%rip), %rsi      # 0x3030
leaq 0x177c(%rip), %rcx      # 0x31f9
movl $0x215, %edx            # imm = 0x215
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_insert
void *
rb_t_insert (struct rb_traverser *trav, struct rb_table *tree, void *item)
{
  void **p;

  assert (trav != NULL && tree != NULL && item != NULL);

  p = rb_probe (tree, item);
  if (p != NULL)
    {
      trav->rb_table = tree;
      trav->rb_node =
        ((struct rb_node *)
         ((char *) p - offsetof (struct rb_node, rb_data)));
      trav->rb_generation = tree->rb_generation - 1;
      return *p;
    }
  else
    {
      rb_t_init (trav, tree);
      return NULL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1aec
movq %rsi, %r14
testq %rsi, %rsi
je 0x1aec
testq %rdx, %rdx
je 0x1aec
movq %rdi, %rbx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x1266
movq %r14, (%rbx)
testq %rax, %rax
je 0x1aca
movq %rax, %rcx
addq $-0x10, %rcx
movq %rcx, 0x8(%rbx)
movq 0x28(%r14), %rcx
decq %rcx
movq (%rax), %rax
jmp 0x1add
andq $0x0, 0x8(%rbx)
andq $0x0, 0x190(%rbx)
movq 0x28(%r14), %rcx
xorl %eax, %eax
movq %rcx, 0x198(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x16d9(%rip), %rdi      # 0x31cc
leaq 0x1536(%rip), %rsi      # 0x3030
leaq 0x173a(%rip), %rcx      # 0x323b
movl $0x23c, %edx            # imm = 0x23C
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_copy
void *
rb_t_copy (struct rb_traverser *trav, const struct rb_traverser *src)
{
  assert (trav != NULL && src != NULL);

  if (trav != src)
    {
      trav->rb_table = src->rb_table;
      trav->rb_node = src->rb_node;
      trav->rb_generation = src->rb_generation;
      if (trav->rb_generation == trav->rb_table->rb_generation)
        {
          trav->rb_height = src->rb_height;
          memcpy (trav->rb_stack, (const void *) src->rb_stack,
                  sizeof *trav->rb_stack * trav->rb_height);
        }
    }

  return trav->rb_node != NULL ? trav->rb_node->rb_data : NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1b71
testq %rsi, %rsi
je 0x1b71
cmpq %rsi, %rdi
je 0x1b5e
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rbx
movq %rbx, 0x8(%rdi)
movq 0x198(%rsi), %rcx
movq %rcx, 0x198(%rdi)
cmpq 0x28(%rax), %rcx
jne 0x1b62
movq 0x190(%rsi), %rdx
movq %rdx, 0x190(%rdi)
addq $0x10, %rdi
addq $0x10, %rsi
shlq $0x3, %rdx
callq 0x1060
jmp 0x1b62
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x1b6d
movq 0x10(%rbx), %rax
jmp 0x1b6f
xorl %eax, %eax
popq %rbx
retq
leaq 0x1707(%rip), %rdi      # 0x327f
leaq 0x14b1(%rip), %rsi      # 0x3030
leaq 0x1715(%rip), %rcx      # 0x329b
movl $0x253, %edx            # imm = 0x253
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_next
void *
rb_t_next (struct rb_traverser *trav)
{
  struct rb_node *x;

  assert (trav != NULL);

  if (trav->rb_generation != trav->rb_table->rb_generation)
    trav_refresh (trav);

  x = trav->rb_node;
  if (x == NULL)
    {
      return rb_t_first (trav, trav->rb_table);
    }
  else if (x->rb_link[1] != NULL)
    {
      assert (trav->rb_height < RB_MAX_HEIGHT);
      trav->rb_stack[trav->rb_height++] = x;
      x = x->rb_link[1];

      while (x->rb_link[0] != NULL)
        {
          assert (trav->rb_height < RB_MAX_HEIGHT);
          trav->rb_stack[trav->rb_height++] = x;
          x = x->rb_link[0];
        }
    }
  else
    {
      struct rb_node *y;

      do
        {
          if (trav->rb_height == 0)
            {
              trav->rb_node = NULL;
              return NULL;
            }

          y = x;
          x = trav->rb_stack[--trav->rb_height];
        }
      while (y == x->rb_link[1]);
    }
  trav->rb_node = x;

  return x->rb_data;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1c6d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x198(%rdi), %rcx
cmpq 0x28(%rax), %rcx
je 0x1bb5
movq %rbx, %rdi
callq 0x1cab
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1c2d
cmpq $0x0, 0x8(%rax)
movq 0x190(%rbx), %rcx
je 0x1c39
cmpq $0x30, %rcx
jae 0x1c8c
leaq 0x8(%rax), %rdx
movq %rax, 0x10(%rbx,%rcx,8)
movq (%rdx), %rax
cmpq $0x0, (%rax)
je 0x1c1e
incq %rcx
leaq -0x1(%rcx), %rsi
movq %rax, %rdx
cmpq $0x2f, %rsi
jb 0x1bda
movq %rcx, 0x190(%rbx)
leaq 0x156c(%rip), %rdi      # 0x3172
leaq 0x1423(%rip), %rsi      # 0x3030
leaq 0x16cb(%rip), %rcx      # 0x32df
movl $0x27f, %edx            # imm = 0x27F
callq 0x1040
incq %rcx
movq %rcx, 0x190(%rbx)
movq %rax, %rdx
jmp 0x1c5a
movq (%rbx), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x1854
decq %rcx
cmpq $-0x1, %rcx
je 0x1c64
movq %rcx, 0x190(%rbx)
movq 0x10(%rbx,%rcx,8), %rdx
decq %rcx
cmpq 0x8(%rdx), %rax
movq %rdx, %rax
je 0x1c3c
movq %rdx, 0x8(%rbx)
movq 0x10(%rdx), %rax
popq %rbx
retq
andq $0x0, 0x8(%rbx)
xorl %eax, %eax
jmp 0x1c62
leaq 0x14b6(%rip), %rdi      # 0x312a
leaq 0x13b5(%rip), %rsi      # 0x3030
leaq 0x165d(%rip), %rcx      # 0x32df
movl $0x26d, %edx            # imm = 0x26D
callq 0x1040
leaq 0x14df(%rip), %rdi      # 0x3172
leaq 0x1396(%rip), %rsi      # 0x3030
leaq 0x163e(%rip), %rcx      # 0x32df
movl $0x279, %edx            # imm = 0x279
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: trav_refresh
static void
trav_refresh (struct rb_traverser *trav)
{
  assert (trav != NULL);

  trav->rb_generation = trav->rb_table->rb_generation;

  if (trav->rb_node != NULL)
    {
      rb_comparison_func *cmp = trav->rb_table->rb_compare;
      void *param = trav->rb_table->rb_param;
      struct rb_node *node = trav->rb_node;
      struct rb_node *i;

      trav->rb_height = 0;
      for (i = trav->rb_table->rb_root; i != node; )
        {
          assert (trav->rb_height < RB_MAX_HEIGHT);
          assert (i != NULL);

          trav->rb_stack[trav->rb_height++] = i;
          i = i->rb_link[cmp (node->rb_data, i->rb_data, param) > 0];
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %r15
movq 0x28(%rax), %rcx
movq %rcx, 0x198(%rdi)
testq %r15, %r15
je 0x1d2a
movq %rdi, %rbx
movq 0x8(%rax), %r12
movq 0x10(%rax), %r14
andq $0x0, 0x190(%rdi)
movq (%rax), %r13
cmpq %r15, %r13
je 0x1d2a
movq 0x190(%rbx), %rax
cmpq $0x30, %rax
jae 0x1d53
testq %r13, %r13
je 0x1d34
leaq 0x1(%rax), %rcx
movq %rcx, 0x190(%rbx)
movq %r13, 0x10(%rbx,%rax,8)
movq 0x10(%r15), %rdi
movq 0x10(%r13), %rsi
movq %r14, %rdx
callq *%r12
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
leaq (,%rcx,8), %rax
addq %r13, %rax
jmp 0x1cde
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x18ab(%rip), %rdi      # 0x35e6
leaq 0x12ee(%rip), %rsi      # 0x3030
leaq 0x1874(%rip), %rcx      # 0x35bd
movl $0x1c2, %edx            # imm = 0x1C2
callq 0x1040
leaq 0x1418(%rip), %rdi      # 0x3172
leaq 0x12cf(%rip), %rsi      # 0x3030
leaq 0x1855(%rip), %rcx      # 0x35bd
movl $0x1c1, %edx            # imm = 0x1C1
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_replace
void *
rb_t_replace (struct rb_traverser *trav, void *new)
{
  void *old;

  assert (trav != NULL && trav->rb_node != NULL && new != NULL);
  old = trav->rb_node->rb_data;
  trav->rb_node->rb_data = new;
  return old;
}

// Assembly:
testq %rdi, %rdi
je 0x1ede
testq %rsi, %rsi
je 0x1ede
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x1ede
movq 0x10(%rcx), %rax
movq %rsi, 0x10(%rcx)
retq
pushq %rax
leaq 0x146d(%rip), %rdi      # 0x3353
leaq 0x1143(%rip), %rsi      # 0x3030
leaq 0x1494(%rip), %rcx      # 0x3388
movl $0x2e0, %edx            # imm = 0x2E0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: copy_error_recovery
static void
copy_error_recovery (struct rb_node **stack, int height,
                     struct rb_table *new, rb_item_func *destroy)
{
  assert (stack != NULL && height >= 0 && new != NULL);

  for (; height > 2; height -= 2)
    stack[height - 1]->rb_link[1] = NULL;
  rb_destroy (new, destroy);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x20c2
testl %esi, %esi
js 0x20c2
movl %esi, %eax
cmpq $0x3, %rax
jl 0x20b6
movq -0x8(%rdi,%rax,8), %rsi
andq $0x0, 0x8(%rsi)
addq $-0x2, %rax
jmp 0x20a0
movq %rdx, %rdi
movq %rcx, %rsi
popq %rax
jmp 0x20e1
leaq 0x1527(%rip), %rdi      # 0x35f0
leaq 0xf60(%rip), %rsi       # 0x3030
leaq 0x1545(%rip), %rcx      # 0x361c
movl $0x2ed, %edx            # imm = 0x2ED
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb.c
// Function: rb_destroy
void
rb_destroy (struct rb_table *tree, rb_item_func *destroy)
{
  struct rb_node *p, *q;

  assert (tree != NULL);

  for (p = tree->rb_root; p != NULL; p = q)
    if (p->rb_link[0] == NULL)
      {
        q = p->rb_link[1];
        if (destroy != NULL && p->rb_data != NULL)
          destroy (p->rb_data, tree->rb_param);
        tree->rb_alloc->libavl_free (tree->rb_alloc, p);
      }
    else
      {
        q = p->rb_link[0];
        p->rb_link[0] = q->rb_link[1];
        q->rb_link[1] = p;
      }

  tree->rb_alloc->libavl_free (tree->rb_alloc, tree);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2154
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x213c
movq (%r15), %rax
testq %rax, %rax
je 0x2114
movq 0x8(%rax), %rcx
movq %rcx, (%r15)
movq %r15, 0x8(%rax)
movq %rax, %r15
jmp 0x20f7
movq 0x8(%r15), %r12
testq %r14, %r14
je 0x212d
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x212d
movq 0x10(%rbx), %rsi
callq *%r14
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq *0x8(%rdi)
movq %r12, %r15
jmp 0x20f7
movq 0x18(%rbx), %rdi
movq 0x8(%rdi), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
leaq 0x12f9(%rip), %rdi      # 0x3454
leaq 0xece(%rip), %rsi       # 0x3030
leaq 0x12f8(%rip), %rcx      # 0x3461
movl $0x361, %edx            # imm = 0x361
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/attractivechaos[P]rb-eval/rb-c.c
// Function: test_int
int test_int(int n)
{
	int i, cnt = 0;
	uint64_t x = 11;
	intmap_t *d, *r;
	struct rb_table *h;

	h = rb_create(int_cmp, 0, 0);
	for (i = 0; i < n; ++i) {
		unsigned y = x % (n>>1);
		x = kad_splitmix64(x);
		d = (intmap_t*)malloc(sizeof(intmap_t));
		d->key = y; d->value = i;
		if (rb_find(h, d) == 0) {
			rb_insert(h, d);
			++cnt;
		} else {
			r = rb_delete(h, d);
			free(d); free(r);
			--cnt;
		}
	}
	rb_destroy(h, 0);
	return cnt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebp
leaq -0x24(%rip), %rdi       # 0x2238
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x118c
movq %rax, %r14
movl %ebp, %eax
sarl %eax
cltq
movq %rax, 0x10(%rsp)
testl %ebp, %ebp
cmovlel %ebx, %ebp
movl %ebp, 0xc(%rsp)
pushq $0xb
popq %r12
xorl %ebp, %ebp
cmpl %ebp, 0xc(%rsp)
je 0x2339
movq %r12, %rax
xorl %edx, %edx
divq 0x10(%rsp)
movq %rdx, %r15
pushq $0x8
popq %rdi
callq 0x1070
movq %rax, %r13
movl %r15d, (%rax)
movl %ebp, 0x4(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x11f2
movq %r14, %rdi
testq %rax, %rax
je 0x22de
movq %r13, %rsi
callq 0x148f
movq %rax, %r15
movq %r13, %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
pushq $-0x1
jmp 0x22e8
movq %r13, %rsi
callq 0x144d
pushq $0x1
popq %rax
movabsq $-0x61c8864680b583eb, %rcx # imm = 0x9E3779B97F4A7C15
addq %rcx, %r12
movq %r12, %rcx
shrq $0x1e, %rcx
xorq %r12, %rcx
movabsq $-0x40a7b892e31b1a47, %rdx # imm = 0xBF58476D1CE4E5B9
imulq %rdx, %rcx
movq %rcx, %rdx
shrq $0x1b, %rdx
xorq %rcx, %rdx
movabsq $-0x6b2fb644ecceee15, %rcx # imm = 0x94D049BB133111EB
imulq %rcx, %rdx
movq %rdx, %r12
shrq $0x1f, %r12
xorq %rdx, %r12
addl %eax, %ebx
incl %ebp
jmp 0x2284
movq %r14, %rdi
xorl %esi, %esi
callq 0x20e1
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: all_names
char ** all_names(char *path, int * total_length){
	char *absPath=malloc((unsigned int)strlen(path) + 1);
	strcpy(absPath,path);
	char **names=malloc(256* sizeof(char*));
	remove_trailing_slash(absPath);

	int num_names=0;
	while((unsigned int)strlen(absPath)){
		unsigned int path_len=(unsigned int)strlen(absPath);
		char * temp_name=basename(absPath);
		unsigned int temp_name_len=(unsigned int) strlen(temp_name);
		names[num_names]=malloc(temp_name_len); strcpy(names[num_names],temp_name);
		absPath[path_len-(temp_name_len+1)]='\0';
		num_names++;
	}
	 *total_length=num_names;
	return names;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r15
callq 0x1060
leal 0x1(%rax), %edi
callq 0x10d0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x1050
movl $0x800, %edi            # imm = 0x800
callq 0x10d0
movq %rax, %r15
movq %r14, %rdi
callq 0x193c
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x1060
movq %rax, %r12
testl %r12d, %r12d
je 0x1a55
movq %r14, %rdi
callq 0x10b0
movq %rax, %r13
movq %rax, %rdi
callq 0x1060
movq %rax, %rbp
movl %ebp, %edi
callq 0x10d0
movq %rax, (%r15,%rbx,8)
movq %rax, %rdi
movq %r13, %rsi
callq 0x1050
notl %ebp
addl %ebp, %r12d
movb $0x0, (%r14,%r12)
incq %rbx
jmp 0x1a0a
movq (%rsp), %rax
movl %ebx, (%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: set_avail_db
int set_avail_db(){

	unsigned int * bb=(unsigned int *)(disk + (EXT2_BLOCK_SIZE*3));			   

	int i;
	 //4= 128/32 because 128 is the total blocks and 32 bits is 4 bytes=unsigned int
	for (i=0; i<4; i++){
		int j=0;	
		while(j<32){
			
			if (!(bb[i]&(1<<j))){
				// updating to notify data block in now in use
				bb[i]|=(1<<j);
				sb->s_free_blocks_count-=1;
				gd->bg_free_blocks_count-=1;
				return (32*i)+(j+1);
			}
			
			j++;
		}
		
	}
	return -1;					   
}

// Assembly:
leaq 0x243d(%rip), %rax      # 0x40b0
movq (%rax), %rsi
pushq $-0x1
popq %rax
xorl %edi, %edi
pushq $0x1
popq %r8
movl %eax, %edx
cmpq $0x4, %rdi
je 0x1cd8
movl 0xc00(%rsi,%rdi,4), %r9d
xorl %ecx, %ecx
cmpl $0x20, %ecx
je 0x1ca6
movl %r8d, %r10d
shll %cl, %r10d
btl %ecx, %r9d
jae 0x1cae
incl %ecx
jmp 0x1c91
incq %rdi
addl $-0x20, %edx
jmp 0x1c81
orl %r10d, %r9d
movl %r9d, 0xc00(%rsi,%rdi,4)
leaq 0x23f8(%rip), %rax      # 0x40b8
movq (%rax), %rax
decl 0xc(%rax)
leaq 0x23f3(%rip), %rax      # 0x40c0
movq (%rax), %rax
decw 0xc(%rax)
subl %edx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: set_avail_ib
int set_avail_ib(){

	unsigned int * ib = (unsigned int *)(disk+(EXT2_BLOCK_SIZE*4));
	int j=EXT2_GOOD_OLD_FIRST_INO-1;
	while(j<32){
			if (!(ib[0]&(1<<j))){
				// updating to notify inode in now in use
				ib[0]|=1<<j;
				sb->s_free_inodes_count-=1;
				gd->bg_free_inodes_count-=1;
				return j+1;
			}
			
			j++;
	}
	return -1;
}

// Assembly:
leaq 0x23d0(%rip), %rax      # 0x40b0
movq (%rax), %rdx
movl 0x1000(%rdx), %esi
pushq $0xb
popq %rax
pushq $-0x1
popq %rdi
pushq $0x1
popq %r8
cmpl $0x21, %eax
je 0x1d0a
leal -0x1(%rax), %ecx
movl %r8d, %r9d
shll %cl, %r9d
btl %ecx, %esi
jae 0x1d0d
incl %eax
jmp 0x1cf3
movl %edi, %eax
retq
orl %r9d, %esi
movl %esi, 0x1000(%rdx)
leaq 0x239b(%rip), %rcx      # 0x40b8
movq (%rcx), %rcx
decl 0x10(%rcx)
leaq 0x2396(%rip), %rcx      # 0x40c0
movq (%rcx), %rcx
decw 0xe(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: create_inode
void create_inode(int avail_ib,unsigned short mode,unsigned int size,unsigned short link_count,unsigned short blocks,unsigned int *block_pointers){
	time_t rawtime; // for setting creation time
	struct ext2_inode inode;
	inode.i_mode=mode;        
	inode.i_uid=0;        
	inode.i_size=size;     
	inode.i_ctime=(unsigned int)(time( &rawtime ));       /* Creation time */
	inode.i_dtime=0;
	inode.i_gid=0;        
	inode.i_links_count=link_count; 
	inode.i_blocks=blocks;    
	inode.osd1=0;        
	for (int i=0;i<15;i++){
		inode.i_block[i]=block_pointers[i];
	}     /* Pointers to blocks */
	free(block_pointers);

	inode.i_generation=0;  
	inode.i_file_acl=0;    
	inode.i_dir_acl=0;    
	inode.i_faddr=0;       
	inode_table[avail_ib-1]=inode;
	if ((mode & EXT2_S_IFDIR) == EXT2_S_IFDIR){
		gd->bg_used_dirs_count+=1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %r9, %r14
movl %r8d, %r15d
movl %ecx, %r12d
movl %esi, %ebx
movl %edi, %ebp
movw %bx, 0x10(%rsp)
andw $0x0, 0x12(%rsp)
movl %edx, 0x14(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x10c0
movl %eax, 0x1c(%rsp)
andl $0x0, 0x24(%rsp)
andw $0x0, 0x28(%rsp)
movw %r12w, 0x2a(%rsp)
movl %r15d, 0x2c(%rsp)
andl $0x0, 0x34(%rsp)
xorl %eax, %eax
cmpq $0xf, %rax
je 0x1d9b
movl (%r14,%rax,4), %ecx
movl %ecx, 0x38(%rsp,%rax,4)
incq %rax
jmp 0x1d88
movq %r14, %rdi
callq 0x1030
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movups %xmm0, 0x64(%rsi)
leaq 0x2312(%rip), %rax      # 0x40c8
movq (%rax), %rax
movslq %ebp, %rcx
shlq $0x7, %rcx
leaq (%rax,%rcx), %rdi
addq $-0x80, %rdi
pushq $0x20
popq %rcx
rep  movsl (%rsi), %es:(%rdi)
btl $0xe, %ebx
jae 0x1de1
leaq 0x22e6(%rip), %rax      # 0x40c0
movq (%rax), %rax
incw 0x10(%rax)
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: create_entry
void create_entry(int dbaddr,unsigned int inode, unsigned short rec_len, unsigned char name_len, unsigned char file_type, char* name){
	//store entry at dbaddr= data block address
	struct ext2_dir_entry* new_entry = (struct ext2_dir_entry *)(disk+dbaddr); 
	new_entry->inode=inode;
	new_entry->rec_len=rec_len;
	new_entry->name_len=name_len;
	new_entry->file_type=file_type;
	// store name after dir entry struct
	memcpy(disk+dbaddr + sizeof(struct ext2_dir_entry), name, name_len); 
}

// Assembly:
leaq 0x22b8(%rip), %rax      # 0x40b0
movq (%rax), %r10
movslq %edi, %rdi
movl %esi, (%r10,%rdi)
movw %dx, 0x4(%r10,%rdi)
movb %cl, 0x6(%r10,%rdi)
movb %r8b, 0x7(%r10,%rdi)
movq (%rax), %rax
addq %rax, %rdi
addq $0x8, %rdi
movl %ecx, %edx
movq %r9, %rsi
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/prog.c
// Function: main
int main(int argc, char *argv[])
{
	int i, delay, pid;

	/*
	 * Print a number of messages,
	 * use a random delay, so that processes terminate
	 * in random order.
	 */

	pid = getpid();
	srand(pid);
	delay = 30 + ((double)rand() / RAND_MAX) * DELAY;
	printf("%s: Starting, NMSG = %d, delay = %d\n",
		argv[0], NMSG, delay);

	for (i = 0; i < NMSG; i++) {
		printf("%s[%d]: This is message %d\n", argv[0], pid, i);
		compute(delay);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
callq 0x1030
movl %eax, %ebp
movl %eax, %edi
callq 0x1080
callq 0x1110
cvtsi2sd %eax, %xmm0
divsd 0xdc2(%rip), %xmm0      # 0x2008
mulsd 0xdc2(%rip), %xmm0      # 0x2010
addsd 0xdc2(%rip), %xmm0      # 0x2018
cvttsd2si %xmm0, %r14d
movq (%rbx), %rsi
leaq 0xdbb(%rip), %rdi       # 0x2020
pushq $0x64
popq %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1060
leaq 0xdcc(%rip), %r15       # 0x2045
xorl %r12d, %r12d
cmpl $0x64, %r12d
je 0x12a1
movq (%rbx), %rsi
movq %r15, %rdi
movl %ebp, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1060
movl %r14d, %edi
callq 0x12b9
incl %r12d
jmp 0x127c
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: compute
void compute(int count)
{
	long i;
	volatile long junk;

	junk = 0;
	for (i = 0; i < count * 1000000; i++) {
		junk++;
	}
}

// Assembly:
movq $0x0, -0x8(%rsp)
imull $0xf4240, %edi, %ecx    # imm = 0xF4240
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
subq $0x1, %rax
jb 0x12dc
incq -0x8(%rsp)
jmp 0x12cf
retq
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: change_pname
void
change_pname(const char *new_name)
{
	int ret;
	ret = prctl(PR_SET_NAME, new_name);
	if (ret == -1){
		perror("prctl set_name");
		exit(1);
	}
}

// Assembly:
pushq %rax
movq %rdi, %rsi
pushq $0xf
popq %rdi
xorl %eax, %eax
callq 0x10a0
cmpl $-0x1, %eax
je 0x12f2
popq %rax
retq
leaq 0xd68(%rip), %rdi       # 0x2061
callq 0x10d0
pushq $0x1
popq %rdi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: explain_wait_status
void
explain_wait_status(pid_t pid, int status)
{
	if (WIFEXITED(status))
		fprintf(stderr, "My PID = %ld: Child PID = %ld terminated normally, exit status = %d\n",
			(long)getpid(), (long)pid, WEXITSTATUS(status));
	else if (WIFSIGNALED(status))
		fprintf(stderr, "My PID = %ld: Child PID = %ld was terminated by a signal, signo = %d\n",
			(long)getpid(), (long)pid, WTERMSIG(status));
	else if (WIFSTOPPED(status))
		fprintf(stderr, "My PID = %ld: Child PID = %ld has been stopped by a signal, signo = %d\n",
			(long)getpid(), (long)pid, WSTOPSIG(status));
	else {
		fprintf(stderr, "%s: Internal error: Unhandled case, PID = %ld, status = %d\n",
			__func__, (long)pid, status);
		exit(1);
	}
	fflush(stderr);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl %esi, %ebx
andl $0x7f, %ebx
jne 0x1336
movq 0x2cde(%rip), %rax      # 0x3ff8
movq (%rax), %r14
movl %esi, %ebx
callq 0x1030
movslq %eax, %rdx
movslq %ebp, %rcx
movzbl %bh, %eax
leaq 0xd3c(%rip), %rsi       # 0x2070
jmp 0x1392
movl %ebx, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x136b
movq 0x2caa(%rip), %rax      # 0x3ff8
movq (%rax), %r14
callq 0x1030
movslq %eax, %rdx
movslq %ebp, %rcx
leaq 0xd52(%rip), %rsi       # 0x20b5
movq %r14, %rdi
movl %ebx, %r8d
jmp 0x1398
movq 0x2c86(%rip), %rax      # 0x3ff8
movq (%rax), %r14
cmpb $0x7f, %sil
movl %esi, %ebx
jne 0x13b2
callq 0x1030
movslq %eax, %rdx
movslq %ebp, %rcx
movzbl %bh, %eax
leaq 0xd69(%rip), %rsi       # 0x20fb
movq %r14, %rdi
movl %eax, %r8d
xorl %eax, %eax
callq 0x1090
movq 0x2c52(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10b0
movslq %ebp, %rcx
leaq 0xd87(%rip), %rsi       # 0x2143
leaq 0xdbc(%rip), %rdx       # 0x217f
movq %r14, %rdi
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1090
pushq $0x1
popq %rdi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: wait_for_ready_children
void
wait_for_ready_children(int cnt)
{
	int i;
	pid_t p;
	int status;

	for (i = 0; i < cnt; i++) {
		/* Wait for any child, also get status for stopped children */
		p = waitpid(-1, &status, WUNTRACED);
		explain_wait_status(p, status);
		if (!WIFSTOPPED(status)) {
			fprintf(stderr, "Parent: Child with PID %ld has died unexpectedly!\n",
				(long)p);
			exit(1);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %r12d, %r12d
testl %edi, %edi
cmovgl %edi, %r12d
incl %r12d
pushq $-0x1
popq %rbx
leaq 0xc(%rsp), %r14
pushq $0x2
popq %rbp
decl %r12d
je 0x1444
movl %ebx, %edi
movq %r14, %rsi
movl %ebp, %edx
callq 0x10c0
movl %eax, %r15d
movl 0xc(%rsp), %esi
movl %eax, %edi
callq 0x1306
cmpb $0x7f, 0xc(%rsp)
je 0x13fb
movq 0x2bd0(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movslq %r15d, %rdx
leaq 0xd5e(%rip), %rsi       # 0x2193
xorl %eax, %eax
callq 0x1090
pushq $0x1
popq %rdi
callq 0x10f0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: show_pstree
void
show_pstree(pid_t p)
{
	int ret;
	char cmd[1024];

	snprintf(cmd, sizeof(cmd), "echo; echo; pstree -G -c -p %ld; echo; echo",
		(long)p);
	cmd[sizeof(cmd)-1] = '\0';
	ret = system(cmd);
	if (ret < 0) {
		perror("system");
		exit(104);
	}
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movslq %edi, %rcx
leaq 0xd63(%rip), %rdx       # 0x21c6
movq %rsp, %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1070
movb $0x0, 0x3ff(%rbx)
movq %rbx, %rdi
callq 0x1050
testl %eax, %eax
js 0x1491
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
leaq 0xd5a(%rip), %rdi       # 0x21f2
callq 0x10d0
pushq $0x68
popq %rdi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: create_shared_memory_area
void *create_shared_memory_area(unsigned int numbytes)
{
	int pages;
	void *addr;

	if (numbytes == 0) {
		fprintf(stderr, "%s: internal error: called for numbytes == 0\n", __func__);
		exit(1);
	}

	/* Determine the number of pages needed, round up the requested number of pages */
	pages = (numbytes - 1) / sysconf(_SC_PAGE_SIZE) + 1;

	/* Create a shared, anonymous mapping for this number of pages */
	addr = mmap(NULL, pages * sysconf(_SC_PAGE_SIZE),
		PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
	if (addr == MAP_FAILED) {
		perror("create_shared_memory_area: mmap failed");
		exit(1);
	}

	return addr;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %edi, %edi
je 0x14f9
movl %edi, %ebx
decl %ebx
pushq $0x1e
popq %rbp
movl %ebp, %edi
callq 0x10e0
movq %rax, %rcx
movq %rbx, %rax
xorl %edx, %edx
idivq %rcx
incl %eax
movslq %eax, %rbx
movl %ebp, %edi
callq 0x10e0
imulq %rax, %rbx
pushq $0x3
popq %rdx
pushq $0x21
popq %rcx
pushq $-0x1
popq %r8
xorl %edi, %edi
movq %rbx, %rsi
xorl %r9d, %r9d
callq 0x1040
cmpq $-0x1, %rax
je 0x151a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x2af8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xcef(%rip), %rsi       # 0x21f9
leaq 0xd16(%rip), %rdx       # 0x2227
xorl %eax, %eax
callq 0x1090
jmp 0x1526
leaq 0xd20(%rip), %rdi       # 0x2241
callq 0x10d0
pushq $0x1
popq %rdi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/tlb_flush1.c
// Function: testcase
void testcase(unsigned long *iteration, unsigned long nr)
{
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);
	unsigned long offset = 0;
	unsigned long pgsize = getpagesize();
	assert(fd >= 0);
	assert(ftruncate(fd, FILESIZE) == 0);
	unlink(tmpfile);
	unsigned long i;

	while (1) {
		char *addr = mmap(NULL, FILESIZE, PROT_READ|PROT_WRITE,
						MAP_PRIVATE, fd, offset);
		for (i = 0; i < FILESIZE; i += pgsize) {
			*(addr + i) = 1;
			madvise(addr + i, pgsize, MADV_DONTNEED);
			assert(*(addr + i) == 0);
			(*iteration)++;
		}
		munmap(addr, FILESIZE);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movaps 0x7b8(%rip), %xmm0      # 0x3310
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movabsq $0x5858585858582e, %rax # imm = 0x5858585858582E
movq %rax, 0x10(%rdi)
callq 0x21c0
movl %eax, %ebp
callq 0x2280
testl %ebp, %ebp
js 0x2bfb
movl %eax, %r14d
movl $0x8000000, %esi        # imm = 0x8000000
movl %ebp, %edi
callq 0x2110
testl %eax, %eax
jne 0x2c14
movslq %r14d, %r14
movq %rsp, %rdi
callq 0x2080
pushq $0x4
popq %r13
movl $0x8000000, %esi        # imm = 0x8000000
xorl %edi, %edi
pushq $0x3
popq %rdx
pushq $0x2
popq %rcx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x20e0
movq %rax, %r15
xorl %r12d, %r12d
cmpq $0x7ffffff, %r12        # imm = 0x7FFFFFF
ja 0x2bec
leaq (%r15,%r12), %rdi
movb $0x1, (%r15,%r12)
movq %r14, %rsi
movl %r13d, %edx
callq 0x2200
cmpb $0x0, (%r15,%r12)
jne 0x2c2d
incq (%rbx)
addq %r14, %r12
jmp 0x2bc0
movl $0x8000000, %esi        # imm = 0x8000000
movq %r15, %rdi
callq 0x21d0
jmp 0x2ba2
leaq 0x691(%rip), %rdi       # 0x3293
leaq 0x692(%rip), %rsi       # 0x329b
leaq 0x69e(%rip), %rcx       # 0x32ae
pushq $0x16
jmp 0x2c44
leaq 0x6c1(%rip), %rdi       # 0x32dc
leaq 0x679(%rip), %rsi       # 0x329b
leaq 0x685(%rip), %rcx       # 0x32ae
pushq $0x17
jmp 0x2c44
leaq 0x6c5(%rip), %rdi       # 0x32f9
leaq 0x660(%rip), %rsi       # 0x329b
leaq 0x66c(%rip), %rcx       # 0x32ae
pushq $0x21
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/bench/bulk_update/main.c
// Function: sendbatch
static int
sendbatch(struct bulkupdate_state * C)
{

	while (C->Nip < 4096) {
		/* Try to read a key-value pair. */
		if (fread(C->key->buf, 40, 1, C->f) < 1) {
			C->generation++;
			rewind(C->f);
			continue;
		}
		if (fread(C->val->buf, 40, 1, C->f) < 1) {
			C->generation++;
			rewind(C->f);
			continue;
		}

		/* Create a new (somewhat arbitrary) value to record. */
		C->val->buf[39] += C->generation;

		/* Send the request. */
		if (proto_kvlds_request_set(C->Q, C->key, C->val,
		    callback_done, C))
			goto err0;
		C->Nip += 1;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
pushq $0x28
popq %r15
pushq $0x1
popq %r12
leaq 0x96(%rip), %r13        # 0x2762
pushq $-0x1
popq %rbx
cmpq $0xfff, 0x10(%r14)      # imm = 0xFFF
ja 0x2754
movq 0x8(%r14), %rcx
movq 0x28(%r14), %rdi
incq %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x20c0
testq %rax, %rax
je 0x273a
movq 0x8(%r14), %rcx
movq 0x30(%r14), %rdi
incq %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x20c0
movl 0x18(%r14), %ecx
testq %rax, %rax
je 0x2740
movq 0x30(%r14), %rax
addb %cl, 0x28(%rax)
movq (%r14), %rdi
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x528e
testl %eax, %eax
jne 0x2756
incq 0x10(%r14)
jmp 0x26cf
incl 0x18(%r14)
jmp 0x2746
incl %ecx
movl %ecx, 0x18(%r14)
movq 0x8(%r14), %rdi
callq 0x2150
jmp 0x26cf
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq