LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jwang11[P]intel_avx_perf/matrix_double.c
// Function: calc_avx2
void calc_avx2(void) {
  #define VLEN (256/8/sizeof(double))

  const int col_aligned = col - col % VLEN;
  double *f_arr;

  __m256d op0, op1;
  volatile __m256d tgt;

  for (int i = 0; i < row; i++) {
    double sum = 0;

    tgt = _mm256_setzero_pd();
    for (int j = 0; j < col_aligned; j += VLEN) {
      op0 = _mm256_load_pd(&mutiplier[j]);
      op1 = _mm256_load_pd(&mat[i][j]);
      tgt = _mm256_fmadd_pd(op0, op1, tgt);
    }

    f_arr = (double *)&tgt;
    for (int k = 0; k < VLEN; k++)
      sum += f_arr[k];

    for (int l = col_aligned; l < col; l++)
      sum += mat[i][l] * mutiplier[l];

    result[i] = sum;
  }
  #undef VLEN
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x160, %rsp            # imm = 0x160
movl $0x400, 0x9c(%rsp) # imm = 0x400
movl $0x0, 0x1c(%rsp)
cmpl $0x40, 0x1c(%rsp)
jge 0x1513
movq $0x0, 0x10(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovapd %ymm0, 0xa0(%rsp)
vmovapd 0xa0(%rsp), %ymm0
vmovapd %ymm0, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x400, 0xc(%rsp)       # imm = 0x400
jge 0x1443
movslq 0xc(%rsp), %rcx
leaq 0x82cdc(%rip), %rax     # 0x84060
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
vmovapd (%rax), %ymm0
vmovapd %ymm0, 0x60(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x2caf(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0xc(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
vmovapd (%rax), %ymm0
vmovapd %ymm0, 0x40(%rsp)
vmovapd 0x60(%rsp), %ymm2
vmovapd 0x40(%rsp), %ymm1
vmovapd 0x20(%rsp), %ymm0
vmovapd %ymm2, 0x120(%rsp)
vmovapd %ymm1, 0x100(%rsp)
vmovapd %ymm0, 0xe0(%rsp)
vmovapd 0x120(%rsp), %ymm1
vmovapd 0x100(%rsp), %ymm0
vmovapd 0xe0(%rsp), %ymm2
vfmadd213pd %ymm2, %ymm1, %ymm0 # ymm0 = (ymm1 * ymm0) + ymm2
vmovapd %ymm0, 0x20(%rsp)
movslq 0xc(%rsp), %rax
addq $0x4, %rax
movl %eax, 0xc(%rsp)
jmp 0x136a
leaq 0x20(%rsp), %rax
movq %rax, 0x90(%rsp)
movl $0x0, 0x8(%rsp)
movslq 0x8(%rsp), %rax
cmpq $0x4, %rax
jae 0x148e
movq 0x90(%rsp), %rax
movslq 0x8(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm0
vaddsd 0x10(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x10(%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1458
movl $0x400, 0x4(%rsp)       # imm = 0x400
cmpl $0x400, 0x4(%rsp)       # imm = 0x400
jge 0x14ec
movslq 0x1c(%rsp), %rcx
leaq 0x2bb4(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0x4(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm1
movslq 0x4(%rsp), %rcx
leaq 0x82b97(%rip), %rax     # 0x84060
vmovsd (%rax,%rcx,8), %xmm0
vmovsd 0x10(%rsp), %xmm2
vfmadd213sd %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
vmovsd %xmm0, 0x10(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1496
vmovsd 0x10(%rsp), %xmm0
movslq 0x1c(%rsp), %rcx
leaq 0x84b62(%rip), %rax     # 0x86060
vmovsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1332
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jwang11[P]intel_avx_perf/matrix_double.c
// Function: calc_avx512
void calc_avx512(void) {
  #define VLEN (512/8/sizeof(double))
  const int col_aligned = col - col % VLEN;
  double *f_arr;

  __m512d op0, op1;
  volatile __m512d tgt;

  for (int i = 0; i < row; i++) {
    double sum = 0;

    tgt = _mm512_setzero_pd();
    for (int j = 0; j < col_aligned; j += VLEN) {
      op0 = _mm512_load_pd(&mutiplier[j]);
      op1 = _mm512_load_pd(&mat[i][j]);
      tgt = _mm512_fmadd_pd(op0, op1, tgt);
    }

    f_arr =  (double *)&tgt;
    for (int k = 0; k < VLEN; k++)
      sum += f_arr[k];

    for (int l = col_aligned; l < col; l++)
      sum += mat[i][l] * mutiplier[l];
    result[i] = sum;
  }
  #undef VLEN
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0x2c0, %rsp            # imm = 0x2C0
movl $0x400, 0x13c(%rsp) # imm = 0x400
movl $0x0, 0x3c(%rsp)
cmpl $0x40, 0x3c(%rsp)
jge 0x172e
movq $0x0, 0x30(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovapd %zmm0, 0x140(%rsp)
vmovapd 0x140(%rsp), %zmm0
vmovapd %zmm0, 0x40(%rsp)
movl $0x0, 0x2c(%rsp)
cmpl $0x400, 0x2c(%rsp)      # imm = 0x400
jge 0x165e
movslq 0x2c(%rsp), %rcx
leaq 0x82acc(%rip), %rax     # 0x84060
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x1b8(%rsp)
movq 0x1b8(%rsp), %rax
vmovapd (%rax), %zmm0
vmovapd %zmm0, 0xc0(%rsp)
movslq 0x3c(%rsp), %rcx
leaq 0x2a9b(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0x2c(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x1b0(%rsp)
movq 0x1b0(%rsp), %rax
vmovapd (%rax), %zmm0
vmovapd %zmm0, 0x80(%rsp)
vmovapd 0xc0(%rsp), %zmm2
vmovapd 0x80(%rsp), %zmm1
vmovapd 0x40(%rsp), %zmm0
vmovapd %zmm2, 0x240(%rsp)
vmovapd %zmm1, 0x200(%rsp)
vmovapd %zmm0, 0x1c0(%rsp)
vmovapd 0x240(%rsp), %zmm1
vmovapd 0x200(%rsp), %zmm0
vmovapd 0x1c0(%rsp), %zmm2
vfmadd213pd %zmm2, %zmm1, %zmm0 # zmm0 = (zmm1 * zmm0) + zmm2
vmovapd %zmm0, 0x40(%rsp)
movslq 0x2c(%rsp), %rax
addq $0x8, %rax
movl %eax, 0x2c(%rsp)
jmp 0x157a
leaq 0x40(%rsp), %rax
movq %rax, 0x130(%rsp)
movl $0x0, 0x28(%rsp)
movslq 0x28(%rsp), %rax
cmpq $0x8, %rax
jae 0x16a9
movq 0x130(%rsp), %rax
movslq 0x28(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm0
vaddsd 0x30(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x30(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1673
movl $0x400, 0x24(%rsp)      # imm = 0x400
cmpl $0x400, 0x24(%rsp)      # imm = 0x400
jge 0x1707
movslq 0x3c(%rsp), %rcx
leaq 0x2999(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0x24(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm1
movslq 0x24(%rsp), %rcx
leaq 0x8297c(%rip), %rax     # 0x84060
vmovsd (%rax,%rcx,8), %xmm0
vmovsd 0x30(%rsp), %xmm2
vfmadd213sd %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
vmovsd %xmm0, 0x30(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x16b1
vmovsd 0x30(%rsp), %xmm0
movslq 0x3c(%rsp), %rcx
leaq 0x84947(%rip), %rax     # 0x86060
vmovsd %xmm0, (%rax,%rcx,8)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x1542
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sos22[P]unexec/tests/bigstack.c
// Function: main
int main() {
    char buf[] = "bigstackXXXXXX";
    close(mkstemp(buf));
    int r = unexec(buf, NULL);
    if (r < 0) err(1, "unexec");
    if (r == 1) {
        execl(buf, buf, NULL);
        err(1, "execl %s", buf); }
    burnstack(0);
    unlink(buf);
    return 0; }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movq 0xe3e(%rip), %rax       # 0x2004
movq %rax, -0x13(%rbp)
movl 0xe3c(%rip), %eax       # 0x200c
movl %eax, -0xb(%rbp)
movw 0xe36(%rip), %ax        # 0x2010
movw %ax, -0x7(%rbp)
movb 0xe2e(%rip), %al        # 0x2012
movb %al, -0x5(%rbp)
leaq -0x13(%rbp), %rdi
callq 0x1080
movl %eax, %edi
callq 0x1060
leaq -0x13(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1090
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x1220
movl $0x1, %edi
leaq 0xdfa(%rip), %rsi       # 0x2013
movb $0x0, %al
callq 0x1070
cmpl $0x1, -0x18(%rbp)
jne 0x1250
leaq -0x13(%rbp), %rdi
leaq -0x13(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x10a0
leaq -0x13(%rbp), %rdx
movl $0x1, %edi
leaq 0xdd1(%rip), %rsi       # 0x201a
movb $0x0, %al
callq 0x1070
xorl %edi, %edi
callq 0x1270
leaq -0x13(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sos22[P]unexec/tests/bigstack.c
// Function: burnstack
static void burnstack(int cntr) {
    /* Experimentally determined to be the biggest thing which works
     * pre-fiddling. */
    if (cntr == 7500) return;
    char buf[1024];
    memset(buf, cntr, sizeof(buf));
    unsigned long rsp;
    asm("" : "=r" (rsp) : "m" (buf));
    printf("%05d: %lx\n", cntr, rsp);
    burnstack(cntr + 1);
    asm("" :: "m" (buf)); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl %edi, -0x4(%rbp)
cmpl $0x1d4c, -0x4(%rbp)     # imm = 0x1D4C
jne 0x1289
jmp 0x12ca
leaq -0x410(%rbp), %rdi
movl -0x4(%rbp), %eax
movl $0x400, %edx            # imm = 0x400
movzbl %al, %esi
callq 0x1050
movq %rax, -0x418(%rbp)
movl -0x4(%rbp), %esi
movq -0x418(%rbp), %rdx
leaq 0xd6b(%rip), %rdi       # 0x2023
movb $0x0, %al
callq 0x1040
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0x1270
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/driver.c
// Function: compilecommand
static char *
compilecommand(char *arg)
{
	char self[PATH_MAX], *cmd;
	size_t n;

	n = readlink("/proc/self/exe", self, sizeof(self) - 5);
	if (n == -1) {
		n = strlen(arg);
		if (n > sizeof(self) - 5)
			fatal("argv[0] is too large");
		memcpy(self, arg, n);
	} else if (n == sizeof(self) - 5) {
		fatal("target of /proc/self/exe is too large");
	}
	strcpy(self + n, "-qbe");
	cmd = strdup(self);
	if (!cmd)
		fatal("strdup:");
	return cmd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
leaq -0x1010(%rbp), %rsi
leaq 0x23a4(%rip), %rdi      # 0x53b1
movl $0xffb, %edx            # imm = 0xFFB
callq 0x2090
movq %rax, -0x1020(%rbp)
cmpq $-0x1, -0x1020(%rbp)
jne 0x306c
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, -0x1020(%rbp)
cmpq $0xffb, -0x1020(%rbp) # imm = 0xFFB
jbe 0x3053
leaq 0x2374(%rip), %rdi      # 0x53c0
movb $0x0, %al
callq 0x3f60
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x1020(%rbp), %rdx
callq 0x2170
jmp 0x3089
cmpq $0xffb, -0x1020(%rbp) # imm = 0xFFB
jne 0x3087
leaq 0x2355(%rip), %rdi      # 0x53d5
movb $0x0, %al
callq 0x3f60
jmp 0x3089
leaq -0x1010(%rbp), %rdi
addq -0x1020(%rbp), %rdi
leaq 0x2138(%rip), %rsi      # 0x51d6
callq 0x2070
leaq -0x1010(%rbp), %rdi
callq 0x2230
movq %rax, -0x1018(%rbp)
cmpq $0x0, -0x1018(%rbp)
jne 0x30ce
leaq 0x2334(%rip), %rdi      # 0x53fb
movb $0x0, %al
callq 0x3f60
movq -0x1018(%rbp), %rax
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/driver.c
// Function: detectfiletype
static enum filetype
detectfiletype(const char *name)
{
	const char *dot;

	dot = strrchr(name, '.');
	if (dot) {
		++dot;
		if (strcmp(dot, "c") == 0)
			return C;
		if (strcmp(dot, "h") == 0)
			return CHDR;
		if (strcmp(dot, "i") == 0)
			return CPPOUT;
		if (strcmp(dot, "qbe") == 0)
			return QBE;
		if (strcmp(dot, "s") == 0)
			return ASM;
		if (strcmp(dot, "S") == 0)
			return ASMPP;
	}

	return OBJ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x20e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3221
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2446(%rip), %rsi      # 0x55b6
callq 0x2150
cmpl $0x0, %eax
jne 0x3186
movl $0x3, -0x4(%rbp)
jmp 0x3228
movq -0x18(%rbp), %rdi
leaq 0x22c6(%rip), %rsi      # 0x5457
callq 0x2150
cmpl $0x0, %eax
jne 0x31a7
movl $0x4, -0x4(%rbp)
jmp 0x3228
movq -0x18(%rbp), %rdi
leaq 0x22a7(%rip), %rsi      # 0x5459
callq 0x2150
cmpl $0x0, %eax
jne 0x31c5
movl $0x5, -0x4(%rbp)
jmp 0x3228
movq -0x18(%rbp), %rdi
leaq 0x2007(%rip), %rsi      # 0x51d7
callq 0x2150
cmpl $0x0, %eax
jne 0x31e3
movl $0x7, -0x4(%rbp)
jmp 0x3228
movq -0x18(%rbp), %rdi
leaq 0x22f1(%rip), %rsi      # 0x54df
callq 0x2150
cmpl $0x0, %eax
jne 0x3201
movl $0x1, -0x4(%rbp)
jmp 0x3228
movq -0x18(%rbp), %rdi
leaq 0x224f(%rip), %rsi      # 0x545b
callq 0x2150
cmpl $0x0, %eax
jne 0x321f
movl $0x2, -0x4(%rbp)
jmp 0x3228
jmp 0x3221
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/driver.c
// Function: usage
static void
usage(const char *fmt, ...)
{
	va_list ap;

	if (fmt) {
		fprintf(stderr, "%s: ", argv0);
		va_start(ap, fmt);
		vfprintf(stderr, fmt, ap);
		va_end(ap);
		fputc('\n', stderr);
	}
	fprintf(stderr, "usage: %s [-c|-S|-E] [-D name[=value]] [-U name] [-s] [-g] [-o output] input...\n", argv0);
	exit(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x3275
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3318
movq 0x3d46(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
leaq 0x3f84(%rip), %rax      # 0x7238
movq (%rax), %rdx
leaq 0x219f(%rip), %rsi      # 0x545d
movb $0x0, %al
callq 0x2160
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x3d00(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2200
leaq -0x20(%rbp), %rax
movq 0x3ce5(%rip), %rax      # 0x6ff0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2130
movq 0x3cd1(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
leaq 0x3f0f(%rip), %rax      # 0x7238
movq (%rax), %rdx
leaq 0x212f(%rip), %rsi      # 0x5462
movb $0x0, %al
callq 0x2160
movl $0x2, %edi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/driver.c
// Function: nextarg
static char *
nextarg(char ***argv)
{
	if ((**argv)[2] != '\0')
		return &(**argv)[2];
	++*argv;
	if (!**argv)
		usage(NULL);
	return **argv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
je 0x3383
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x33b7
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
jne 0x33a9
xorl %eax, %eax
movl %eax, %edi
movb $0x0, %al
callq 0x3240
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/driver.c
// Function: changeext
static char *
changeext(const char *name, const char *ext)
{
	const char *slash, *dot;
	char *result;
	size_t baselen;

	slash = strrchr(name, '/');
	if (slash)
		name = slash + 1;
	dot = strrchr(name, '.');
	baselen = dot ? (size_t)(--dot - name + 1) : strlen(name);
	result = xmalloc(baselen + strlen(ext) + 2);
	memcpy(result, name, baselen);
	result[baselen] = '.';
	strcpy(result + baselen + 1, ext);

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x20e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x39d5
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x20e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3a0b
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3a18
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c0
movq -0x40(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
callq 0x40d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2170
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x2e, (%rax,%rcx)
movq -0x28(%rbp), %rdi
addq -0x30(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
callq 0x2070
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/driver.c
// Function: succeeded
static bool
succeeded(const char *phase, pid_t pid, int status)
{
	if (WIFEXITED(status)) {
		if (WEXITSTATUS(status) == 0)
			return true;
		warn("%s: process %ju exited with status %d", phase, (uintmax_t)pid, WEXITSTATUS(status));
	} else if (WIFSIGNALED(status)) {
		warn("%s: process signaled: %s", phase, strsignal(WTERMSIG(status)));
	} else {
		warn("%s: process failed", phase);
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x3cd7
movl -0x18(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
jne 0x3cb3
movb $0x1, -0x1(%rbp)
jmp 0x3d2c
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
movl -0x18(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
sarl $0x8, %ecx
leaq 0x182c(%rip), %rdi      # 0x54fa
movb $0x0, %al
callq 0x3e10
jmp 0x3d28
movl -0x18(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x3d14
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %edi
andl $0x7f, %edi
callq 0x21c0
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x1815(%rip), %rdi      # 0x5520
movb $0x0, %al
callq 0x3e10
jmp 0x3d26
movq -0x10(%rbp), %rsi
leaq 0x181a(%rip), %rdi      # 0x5539
movb $0x0, %al
callq 0x3e10
jmp 0x3d28
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/driver.c
// Function: spawn
static int
spawn(pid_t *pid, struct array *args, posix_spawn_file_actions_t *actions)
{
	extern char **environ;
	char **arg;

	if (flags.verbose) {
		fprintf(stderr, "%s: spawning", argv0);
		for (arg = args->val; *arg; ++arg)
			fprintf(stderr, " %s", *arg);
		fputc('\n', stderr);
	}
	return posix_spawnp(pid, *(char **)args->val, actions, NULL, args->val, environ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
testb $0x1, 0x34d7(%rip)      # 0x7232
je 0x3dd5
movq 0x328c(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
leaq 0x34ca(%rip), %rax      # 0x7238
movq (%rax), %rdx
leaq 0x1775(%rip), %rsi      # 0x54ed
movb $0x0, %al
callq 0x2160
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3dc1
movq 0x3255(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x1731(%rip), %rsi      # 0x54dd
movb $0x0, %al
callq 0x2160
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x3d8a
movq 0x3228(%rip), %rax      # 0x6ff0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %r8
movq 0x31e3(%rip), %rax      # 0x6fd8
movq (%rax), %r9
xorl %eax, %eax
movl %eax, %ecx
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aviralg[P]interceptr/src/library/fcntl/definition.c
// Function: initialize_fcntl_wrappers
void initialize_fcntl_wrappers() {
    real_open = DLSYM_NEXT_FUNCTION(open);
    real___open_2 = DLSYM_NEXT_FUNCTION(__open_2);
    real_open64 = DLSYM_NEXT_FUNCTION(open64);
    real___open64_2 = DLSYM_NEXT_FUNCTION(__open64_2);
    real_fopen64 = DLSYM_NEXT_FUNCTION(fopen64);
    real_openat = DLSYM_NEXT_FUNCTION(openat);
    real_openat_2 = DLSYM_NEXT_FUNCTION(openat_2);
    real___openat_2 = DLSYM_NEXT_FUNCTION(__openat_2);
    real_openat64 = DLSYM_NEXT_FUNCTION(openat64);
    real_openat64_2 = DLSYM_NEXT_FUNCTION(openat64_2);
    real___openat64_2 = DLSYM_NEXT_FUNCTION(__openat64_2);
    real_creat = DLSYM_NEXT_FUNCTION(creat);
    real_creat64 = DLSYM_NEXT_FUNCTION(creat64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $-0x1, %rdi
leaq 0x6bdb(%rip), %rsi      # 0xc0ad
callq 0x5080
movq %rax, 0xbb8a(%rip)      # 0x11068
movq $-0x1, %rdi
leaq 0x6b14(%rip), %rsi      # 0xc000
callq 0x5080
movq %rax, 0xbb78(%rip)      # 0x11070
movq $-0x1, %rdi
leaq 0x6b0f(%rip), %rsi      # 0xc015
callq 0x5080
movq %rax, 0xbb66(%rip)      # 0x11078
movq $-0x1, %rdi
leaq 0x6ae9(%rip), %rsi      # 0xc009
callq 0x5080
movq %rax, 0xbb54(%rip)      # 0x11080
movq $-0x1, %rdi
leaq 0x6ada(%rip), %rsi      # 0xc014
callq 0x5080
movq %rax, 0xbb42(%rip)      # 0x11088
movq $-0x1, %rdi
leaq 0x6ac8(%rip), %rsi      # 0xc01c
callq 0x5080
movq %rax, 0xbb30(%rip)      # 0x11090
movq $-0x1, %rdi
leaq 0x6ab7(%rip), %rsi      # 0xc025
callq 0x5080
movq %rax, 0xbb1e(%rip)      # 0x11098
movq $-0x1, %rdi
leaq 0x6a9b(%rip), %rsi      # 0xc023
callq 0x5080
movq %rax, 0xbb0c(%rip)      # 0x110a0
movq $-0x1, %rdi
leaq 0x6a8c(%rip), %rsi      # 0xc02e
callq 0x5080
movq %rax, 0xbafa(%rip)      # 0x110a8
movq $-0x1, %rdi
leaq 0x6a7d(%rip), %rsi      # 0xc039
callq 0x5080
movq %rax, 0xbae8(%rip)      # 0x110b0
movq $-0x1, %rdi
leaq 0x6a61(%rip), %rsi      # 0xc037
callq 0x5080
movq %rax, 0xbad6(%rip)      # 0x110b8
movq $-0x1, %rdi
leaq 0x6a54(%rip), %rsi      # 0xc044
callq 0x5080
movq %rax, 0xbac4(%rip)      # 0x110c0
movq $-0x1, %rdi
leaq 0x6a40(%rip), %rsi      # 0xc04a
callq 0x5080
movq %rax, 0xbab2(%rip)      # 0x110c8
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aviralg[P]interceptr/src/library/fcntl/definition.c
// Function: open
int open(const char* path, int flags, ...) {
    mode_t mode = 0;

    if (flags & O_CREAT || flags & O_TMPFILE) {
        va_list varargs;
        va_start(varargs, flags);
        mode = va_arg(varargs, int);
        va_end(varargs);
    }

    GENERATE_WRAPPER_BODY(fcntl, open, int, path, flags, mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x565b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x56a1
movl -0xc(%rbp), %eax
andl $0x410000, %eax         # imm = 0x410000
cmpl $0x0, %eax
je 0x572d
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x5700
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x571d
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
leaq -0x30(%rbp), %rax
movb $0x0, %al
callq 0xbc30
movb $0x0, %al
callq 0x5030
movq %rax, -0x40(%rbp)
movb $0x0, %al
callq 0x50a0
cmpl $0x0, %eax
je 0x579f
movb $0x0, %al
callq 0x5090
cmpl $0x0, %eax
jne 0x579f
cmpq $0x0, -0x40(%rbp)
je 0x579f
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
je 0x579f
leaq 0x693e(%rip), %rdi      # 0xc0ad
callq 0x5070
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rdi
movq 0xb8e2(%rip), %rsi      # 0x11068
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
callq *%rax
movl %eax, -0x34(%rbp)
movb $0x0, %al
callq 0x5060
jmp 0x57b7
movq 0xb8c2(%rip), %rcx      # 0x11068
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movb $0x0, %al
callq *%rcx
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aviralg[P]interceptr/src/library/fcntl/definition.c
// Function: open64
int open64(const char* path, int flags, ...) {
    mode_t mode = 0;

    if (flags & O_CREAT || flags & O_TMPFILE) {
        va_list varargs;
        va_start(varargs, flags);
        mode = va_arg(varargs, int);
        va_end(varargs);
    }

    GENERATE_WRAPPER_BODY(fcntl, open64, int, path, flags, mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x58ab
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x58f1
movl -0xc(%rbp), %eax
andl $0x410000, %eax         # imm = 0x410000
cmpl $0x0, %eax
je 0x597d
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x5950
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x596d
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
leaq -0x30(%rbp), %rax
movb $0x0, %al
callq 0xbc30
movb $0x0, %al
callq 0x5030
movq %rax, -0x40(%rbp)
movb $0x0, %al
callq 0x50a0
cmpl $0x0, %eax
je 0x59f1
movb $0x0, %al
callq 0x5090
cmpl $0x0, %eax
jne 0x59f1
cmpq $0x0, -0x40(%rbp)
je 0x59f1
movq -0x40(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x59f1
leaq 0x6655(%rip), %rdi      # 0xc015
callq 0x5070
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x40(%rbp), %rdi
movq 0xb6a0(%rip), %rsi      # 0x11078
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
callq *%rax
movl %eax, -0x34(%rbp)
movb $0x0, %al
callq 0x5060
jmp 0x5a09
movq 0xb680(%rip), %rcx      # 0x11078
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movb $0x0, %al
callq *%rcx
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aviralg[P]interceptr/src/library/fcntl/definition.c
// Function: openat
int openat(int dirfd, const char* path, int flags, ...) {
    mode_t mode = 0;

    if (flags & O_CREAT || flags & O_TMPFILE) {
        va_list varargs;
        va_start(varargs, flags);
        mode = va_arg(varargs, int);
        va_end(varargs);
    }

    GENERATE_WRAPPER_BODY(fcntl, openat, int, dirfd, path, flags, mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x5afb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x5b3d
movl -0x14(%rbp), %eax
andl $0x410000, %eax         # imm = 0x410000
cmpl $0x0, %eax
je 0x5bc9
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x5b9c
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x5bb9
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
leaq -0x30(%rbp), %rax
movb $0x0, %al
callq 0xbc30
movb $0x0, %al
callq 0x5030
movq %rax, -0x40(%rbp)
movb $0x0, %al
callq 0x50a0
cmpl $0x0, %eax
je 0x5c41
movb $0x0, %al
callq 0x5090
cmpl $0x0, %eax
jne 0x5c41
cmpq $0x0, -0x40(%rbp)
je 0x5c41
movq -0x40(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5c41
leaq 0x6410(%rip), %rdi      # 0xc01c
callq 0x5070
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x40(%rbp), %rdi
movq 0xb46c(%rip), %rsi      # 0x11090
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
callq *%rax
movl %eax, -0x34(%rbp)
movb $0x0, %al
callq 0x5060
jmp 0x5c5d
movq 0xb448(%rip), %r8       # 0x11090
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movb $0x0, %al
callq *%r8
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aviralg[P]interceptr/src/library/fcntl/definition.c
// Function: openat64
int openat64(int dirfd, const char* path, int flags, ...) {
    mode_t mode = 0;

    if (flags & O_CREAT || flags & O_TMPFILE) {
        va_list varargs;
        va_start(varargs, flags);
        mode = va_arg(varargs, int);
        va_end(varargs);
    }
    GENERATE_WRAPPER_BODY(fcntl, openat64, int, dirfd, path, flags, mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x5e0b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x5e4d
movl -0x14(%rbp), %eax
andl $0x410000, %eax         # imm = 0x410000
cmpl $0x0, %eax
je 0x5ed9
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x5eac
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x5ec9
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
leaq -0x30(%rbp), %rax
movb $0x0, %al
callq 0xbc30
movb $0x0, %al
callq 0x5030
movq %rax, -0x40(%rbp)
movb $0x0, %al
callq 0x50a0
cmpl $0x0, %eax
je 0x5f51
movb $0x0, %al
callq 0x5090
cmpl $0x0, %eax
jne 0x5f51
cmpq $0x0, -0x40(%rbp)
je 0x5f51
movq -0x40(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x5f51
leaq 0x6112(%rip), %rdi      # 0xc02e
callq 0x5070
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x40(%rbp), %rdi
movq 0xb174(%rip), %rsi      # 0x110a8
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
callq *%rax
movl %eax, -0x34(%rbp)
movb $0x0, %al
callq 0x5060
jmp 0x5f6d
movq 0xb150(%rip), %r8       # 0x110a8
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movb $0x0, %al
callq *%r8
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aviralg[P]interceptr/src/library/stdlib/definition.c
// Function: initialize_stdlib_wrappers
void initialize_stdlib_wrappers() {
    real_putenv = DLSYM_NEXT_FUNCTION(putenv);
    real_getenv = DLSYM_NEXT_FUNCTION(getenv);
    real_secure_getenv = DLSYM_NEXT_FUNCTION(secure_getenv);
    real_clearenv = DLSYM_NEXT_FUNCTION(clearenv);
    real_setenv = DLSYM_NEXT_FUNCTION(setenv);
    real_unsetenv = DLSYM_NEXT_FUNCTION(unsetenv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $-0x1, %rdi
leaq 0x5ba0(%rip), %rsi      # 0xc052
callq 0x5080
movq %rax, 0xac12(%rip)      # 0x110d0
movq $-0x1, %rdi
leaq 0x5b94(%rip), %rsi      # 0xc060
callq 0x5080
movq %rax, 0xac00(%rip)      # 0x110d8
movq $-0x1, %rdi
leaq 0x5b73(%rip), %rsi      # 0xc059
callq 0x5080
movq %rax, 0xabee(%rip)      # 0x110e0
movq $-0x1, %rdi
leaq 0x5b67(%rip), %rsi      # 0xc067
callq 0x5080
movq %rax, 0xabdc(%rip)      # 0x110e8
movq $-0x1, %rdi
leaq 0x5b58(%rip), %rsi      # 0xc072
callq 0x5080
movq %rax, 0xabca(%rip)      # 0x110f0
movq $-0x1, %rdi
leaq 0x5b3c(%rip), %rsi      # 0xc070
callq 0x5080
movq %rax, 0xabb8(%rip)      # 0x110f8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aviralg[P]interceptr/src/initialization.c
// Function: interceptr_initialize_wrappers
void interceptr_initialize_wrappers() {
    if (interceptr_wrappers_initialized) {
        return;
    }
    initialize_fcntl_wrappers();
    initialize_stdio_wrappers();
    initialize_stdlib_wrappers();
    initialize_unistd_wrappers();
    initialize_sys_stat_wrappers();
    interceptr_wrappers_initialized = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x571d(%rip)      # 0x11358
je 0xbc3f
jmp 0xbc6c
movb $0x0, %al
callq 0x54c0
movb $0x0, %al
callq 0x7720
movb $0x0, %al
callq 0x64a0
movb $0x0, %al
callq 0x9d80
movb $0x0, %al
callq 0xa6f0
movl $0x1, 0x56ec(%rip)      # 0x11358
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_list/queue2.c
// Function: clear
void clear(Queue q)
{
    assert(q!=NULL);
    while(q->front!=NULL)
    {
        Node *cur=q->front;
        q->front=q->front->next;
        free(cur);
    }
    q->rear=NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1235
jmp 0x1254
leaq 0xdc8(%rip), %rdi       # 0x2004
leaq 0xdc9(%rip), %rsi       # 0x200c
movl $0x30, %edx
leaq 0xdd9(%rip), %rcx       # 0x2028
callq 0x1050
jmp 0x1256
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1288
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x1256
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_list/queue2.c
// Function: create
Queue create()
{
    Queue q;
    q=(Queue)malloc(sizeof(struct Node));
    if(q==NULL)
    {
        fatal("queue malloc failed");
    }
    q->front=NULL;
    q->rear=NULL;
    return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x1060
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x12c9
leaq 0xd76(%rip), %rdi       # 0x203a
callq 0x1180
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_list/queue2.c
// Function: print
void print(Queue q)
{
    assert(q!=NULL);
    if(isEmpty(q))
    {
        printf("queue is empty.");
    }
    else
    {
    	Node *cur;
        for(cur=q->front; cur!=NULL; cur=cur->next)
        {
            printf("%d ",cur->value);
        }
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1355
jmp 0x1374
leaq 0xca8(%rip), %rdi       # 0x2004
leaq 0xca9(%rip), %rsi       # 0x200c
movl $0x4e, %edx
leaq 0xcf3(%rip), %rcx       # 0x2062
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x11b0
cmpl $0x0, %eax
je 0x1392
leaq 0xceb(%rip), %rdi       # 0x2074
movb $0x0, %al
callq 0x1040
jmp 0x13c8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13c6
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0xcd3(%rip), %rdi       # 0x2084
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x139d
jmp 0x13c8
leaq 0xdd9(%rip), %rdi       # 0x21a8
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_list/queue2.c
// Function: enqueue
void enqueue(int value, Queue q)
{
    assert(q!=NULL);
    Node *node=makeNode(value);
    if(isEmpty(q))
    {
        q->front=node;
        q->rear=node;
    }
    else
    {
        q->rear->next=node;
        q->rear=node;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13f8
jmp 0x1417
leaq 0xc05(%rip), %rdi       # 0x2004
leaq 0xc06(%rip), %rsi       # 0x200c
movl $0x5f, %edx
leaq 0xc76(%rip), %rcx       # 0x2088
callq 0x1050
movl -0x4(%rbp), %edi
callq 0x1470
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11b0
cmpl $0x0, %eax
je 0x144a
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1466
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_list/queue2.c
// Function: makeNode
static Node* makeNode(int value)
{
    Node *node;
    node=(Node*)malloc(sizeof(struct Node));
    if(node==NULL)
    {
        fatal("makeNode(): malloc node failed.\n");
    }
    node->value=value;
    node->next=NULL;
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x1060
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x149c
leaq 0xcf2(%rip), %rdi       # 0x2189
callq 0x1180
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_list/queue2.c
// Function: dequeue
int dequeue(Queue q)
{
    assert(q!=NULL);
    if(isEmpty(q))
    {
        fatal("queue is empty.\n");
    }
    int value=q->front->value;
    q->front=q->front->next;
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x14d5
jmp 0x14f4
leaq 0xb28(%rip), %rdi       # 0x2004
leaq 0xb29(%rip), %rsi       # 0x200c
movl $0x6e, %edx
leaq 0xbb2(%rip), %rcx       # 0x20a1
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x11b0
cmpl $0x0, %eax
je 0x150e
leaq 0xbab(%rip), %rdi       # 0x20b4
callq 0x1180
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_list/queue2.c
// Function: front
int front(Queue q)
{
    assert(q!=NULL);
    if(isEmpty(q))
    {
        fatal("queue is empty");
    }
    return q->front->value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1555
jmp 0x1574
leaq 0xaa8(%rip), %rdi       # 0x2004
leaq 0xaa9(%rip), %rsi       # 0x200c
movl $0x79, %edx
leaq 0xb56(%rip), %rcx       # 0x20c5
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x11b0
cmpl $0x0, %eax
je 0x158e
leaq 0xb4d(%rip), %rdi       # 0x20d6
callq 0x1180
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_list/queue2.c
// Function: main
int main(int argc, char **argv)
{
    printf("===========================A\n");
    Queue q=create();
    int i;
    for(i=0; i<10; i++)
    {
        enqueue(i, q);
        print(q);
    }
    printf("===========================B\n");
    i=0;
    for(int i=0; i<8; i++)
    {
        dequeue(q);
        print(q);
    }
    printf("===========================C\n");
    i=0;
    for(int i=0; i<7; i++)
    {
        enqueue(-i,q);
        print(q);
    }
    printf("===========================D\n");
    i=0;
    for(int i=0; i<6; i++)
    {
        dequeue(q);
        print(q);
    }
    printf("===========================E\n");
    clear(q);
    print(q);
    printf("hello, world!");
    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xb28(%rip), %rdi       # 0x20e5
movb $0x0, %al
callq 0x1040
callq 0x12a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x15fa
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x13e0
movq -0x18(%rbp), %rdi
callq 0x1340
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15d4
leaq 0xb02(%rip), %rdi       # 0x2103
movb $0x0, %al
callq 0x1040
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jge 0x1639
movq -0x18(%rbp), %rdi
callq 0x14c0
movq -0x18(%rbp), %rdi
callq 0x1340
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1616
leaq 0xae1(%rip), %rdi       # 0x2121
movb $0x0, %al
callq 0x1040
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x7, -0x24(%rbp)
jge 0x167d
xorl %edi, %edi
subl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x13e0
movq -0x18(%rbp), %rdi
callq 0x1340
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1655
leaq 0xabb(%rip), %rdi       # 0x213f
movb $0x0, %al
callq 0x1040
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x6, -0x28(%rbp)
jge 0x16bc
movq -0x18(%rbp), %rdi
callq 0x14c0
movq -0x18(%rbp), %rdi
callq 0x1340
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1699
leaq 0xa9a(%rip), %rdi       # 0x215d
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1220
movq -0x18(%rbp), %rdi
callq 0x1340
leaq 0xa98(%rip), %rdi       # 0x217b
movb $0x0, %al
callq 0x1040
xorl %edi, %edi
callq 0x1070
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/gt7cvt/gt7cvt.c
// Function: dump_rec
int dump_rec (FILE *of, int bc, char *buf)
{
unsigned char buc[4];

if (((bc == 1) && (buf[0] == 0xF)) ||
    ((bc == 2) && (buf[0] == 0xF) && (buf[1] == 0xF))) {
	fwrite (fzero, sizeof (char), 4, of);
	return 1;  }
buc[0] = bc & 0xFF;
buc[1] = (bc >> 8) & 0xFF;
buc[2] = (bc >> 16) & 0xFF;
buc[3] = (bc >> 24) & 0xFF;
fwrite (buc, sizeof (char), 4, of);
fwrite (buf, sizeof (char), (bc + 1) & ~1, of);
fwrite (buc, sizeof (char), 4, of);
return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x11e5
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xf, %eax
je 0x1204
cmpl $0x2, -0x14(%rbp)
jne 0x122a
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xf, %eax
jne 0x122a
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0xf, %eax
jne 0x122a
movq -0x10(%rbp), %rcx
leaq 0x2e62(%rip), %rdi      # 0x4071
movl $0x1, %esi
movl $0x4, %edx
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x12b2
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x24(%rbp)
movl -0x14(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x23(%rbp)
movl -0x14(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, -0x22(%rbp)
movl -0x14(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movb %al, -0x21(%rbp)
leaq -0x24(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x10b0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
andl $-0x2, %eax
movslq %eax, %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x10b0
leaq -0x24(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x4, %edx
callq 0x10b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sushant8421[P]create_your_own_shell/my_shell.c
// Function: get_input
char **get_input(char *input) {

	if (strlen(input) != 0) 
		add_history(input);

    char **command = malloc(8 * sizeof(char *));
    if (command == NULL) {
        printf("malloc failed\n");
        exit(1);
    }

    char *separator = " ";
    char *parsed;
    int index = 0;

    parsed = strtok(input, separator);
    while (parsed != NULL) {
        command[index] = parsed;
        index++;

        parsed = strtok(NULL, separator);
    }

    command[index] = NULL;
    return command;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
cmpq $0x0, %rax
je 0x1244
movq -0x8(%rbp), %rdi
callq 0x1040
movl $0x40, %edi
callq 0x10b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1271
leaq 0xda4(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10f0
leaq 0xea1(%rip), %rax       # 0x2119
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12c7
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x10e0
movq %rax, -0x20(%rbp)
jmp 0x1294
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sushant8421[P]create_your_own_shell/my_shell.c
// Function: SS
int SS(char *directory , char *argv[]){	
	int x , stat_loc;
	pid_t ch ;
	struct dirent *de;  // Pointer for directory entry 
  
    // opendir() returns a pointer of DIR type.  
    DIR *dr = opendir(directory); 
  
    if (dr == NULL)  // opendir returns NULL if couldn't open directory 
    { 
        printf("Could not open current directory" ); 
        return 0; 
    }
    
    while ((de = readdir(dr)) != NULL) {
     	char *args[] = {"./searchstring" , argv[1] ,  de->d_name, argv[2], NULL};
    	if((ch = fork()) < 0){
    		printf("child is not created\n") ;
    	}
    	else if(ch > 0){
    		waitpid(ch, &stat_loc, WUNTRACED);
    	}
    	else{
    		if(x=execv("./searchstring", args)<0)
    			printf("execution error");
		}
	}
    		
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x132e
leaq 0xcf8(%rip), %rdi       # 0x2013
movb $0x0, %al
callq 0x1070
movl $0x0, -0x4(%rbp)
jmp 0x13f9
jmp 0x1330
movq -0x38(%rbp), %rdi
callq 0x10a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x13f2
leaq 0xce6(%rip), %rax       # 0x2034
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
addq $0x13, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
callq 0x1110
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x139b
leaq 0xcb1(%rip), %rdi       # 0x2043
movb $0x0, %al
callq 0x1070
jmp 0x13ed
cmpl $0x0, -0x24(%rbp)
jle 0x13b4
movl -0x24(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x2, %edx
callq 0x10c0
jmp 0x13eb
leaq -0x60(%rbp), %rsi
leaq 0xc75(%rip), %rdi       # 0x2034
callq 0x1100
cmpl $0x0, %eax
setl %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x1c(%rbp)
testb $0x1, %al
jne 0x13db
jmp 0x13e9
leaq 0xc77(%rip), %rdi       # 0x2059
movb $0x0, %al
callq 0x1070
jmp 0x13eb
jmp 0x13ed
jmp 0x1330
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)