LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/minkcv[P]vm/machine/cpu.c
// Function: print_cpu_state
void print_cpu_state(CPU *cpu)
{
    // Print program counter as segment.offset, disassembly of current instruction, and registers
    int instructionCount = cpu->pc - cpu->code;
    int instructionSegment = instructionCount / JUMP_SEGMENT_SIZE;
    int instructionOffset = instructionCount % JUMP_SEGMENT_SIZE;
    printf("PC:  %03d.%03d 0x%02X.0x%02X\n", 
	   instructionSegment, instructionOffset,
	   instructionSegment, instructionOffset);
    char assembly[256];
    memset(assembly, 0, sizeof(char) * 256);
    Instruction decoded;
    decode(*(cpu->pc), &decoded);
    disassemble(&decoded, assembly);
    printf("ASM: %s\n", assembly);
    int i;
    for (i = 0; i < REGISTER_COUNT; i++)
	printf("r%02d: %03d (0x%02X)\n", i, cpu->regs[i], cpu->regs[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movq 0x10(%rdi), %rdx
subq 0x18(%rdi), %rdx
shrq %rdx
leal 0xff(%rdx), %ecx
testl %edx, %edx
cmovnsl %edx, %ecx
movl %ecx, %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
subl %eax, %edx
sarl $0x8, %ecx
leaq 0x945(%rip), %rdi       # 0x3448
movl %ecx, %esi
movl %edx, %r8d
xorl %eax, %eax
callq 0x1040
leaq -0x120(%rbp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x10a0
movq 0x10(%rbx), %rax
movzwl (%rax), %eax
movl %eax, %ecx
shrl $0xc, %ecx
movl %eax, %edx
shrl $0x4, %edx
andl $0xf0, %edx
movl %eax, %esi
shll $0x4, %esi
andl $0xf00, %esi            # imm = 0xF00
shll $0xc, %eax
orl %ecx, %eax
orl %edx, %eax
orl %esi, %eax
leaq -0x1c(%rbp), %rdi
movw %ax, (%rdi)
movq %r14, %rsi
callq 0x2540
leaq 0x900(%rip), %rdi       # 0x3466
movq %r14, %rsi
xorl %eax, %eax
callq 0x1040
leaq 0x8f8(%rip), %r14       # 0x346f
xorl %r15d, %r15d
movzbl (%rbx,%r15), %ecx
movq %r14, %rdi
movl %r15d, %esi
movl %ecx, %edx
xorl %eax, %eax
callq 0x1040
incq %r15
cmpq $0x10, %r15
jne 0x2b7a
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/jwang11[P]intel_avx_perf/matrix_double.c
// Function: init
void init(void) {
  srand(time(0));
  for (int i = 0; i < row; i++) {
    for (int j = 0; j < col; j++) {
      mat[i][j] = (double)(rand() % 1000) / 300.0f;
    }   
  }
  for (int j = 0; j < col; j++) {
    mutiplier[j] = (double)(rand() % 1000) / 300.0f;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1070
movl %eax, %edi
callq 0x1060
leaq 0x2ec8(%rip), %r14      # 0x4070
xorl %r15d, %r15d
callq 0x1080
vmovsd 0xe50(%rip), %xmm1      # 0x2008
cltq
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
subl %ecx, %eax
vcvtsi2sd %eax, %xmm2, %xmm0
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, (%r14,%r15,8)
incq %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0x11ab
incq %rbx
addq $0x2000, %r14           # imm = 0x2000
cmpq $0x40, %rbx
jne 0x11a8
xorl %ebx, %ebx
leaq 0x82e67(%rip), %r14     # 0x84070
callq 0x1080
cltq
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
subl %ecx, %eax
vcvtsi2sd %eax, %xmm2, %xmm0
vdivsd 0xdd0(%rip), %xmm0, %xmm0 # 0x2008
vmovsd %xmm0, (%rbx,%r14)
addq $0x8, %rbx
cmpq $0x2000, %rbx           # imm = 0x2000
jne 0x1209
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/jwang11[P]intel_avx_perf/matrix_double.c
// Function: calc_non
void calc_non(void) {
  for(int j = 0; j < row; j++) {
    double sum = 0;
    double *vec = mat[j];

    for(int i = 0; i < col; i++)
      sum += vec[i] * mutiplier[i];

    result[j] = sum;
  }
}

// Assembly:
leaq 0x2e18(%rip), %rax      # 0x4070
xorl %ecx, %ecx
leaq 0x82e0f(%rip), %rdx     # 0x84070
leaq 0x84e08(%rip), %rsi     # 0x86070
vxorpd %xmm0, %xmm0, %xmm0
xorl %edi, %edi
vmovsd (%rax,%rdi), %xmm1
vfmadd231sd (%rdi,%rdx), %xmm1, %xmm0 # xmm0 = (xmm1 * mem) + xmm0
addq $0x8, %rdi
cmpq $0x2000, %rdi           # imm = 0x2000
jne 0x126e
vmovsd %xmm0, (%rsi,%rcx,8)
incq %rcx
addq $0x2000, %rax           # imm = 0x2000
cmpq $0x40, %rcx
jne 0x1268
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x40, %rsp
leaq 0x2dc2(%rip), %rax      # 0x4070
xorl %ecx, %ecx
vxorps %xmm0, %xmm0, %xmm0
leaq 0x82db5(%rip), %rdx     # 0x84070
leaq 0x84dae(%rip), %rsi     # 0x86070
vmovaps %ymm0, (%rsp)
movq $-0x4, %rdi
movq %rdx, %r8
vmovapd (%r8), %ymm1
vmovapd 0x20(%rax,%rdi,8), %ymm2
vfmadd213pd (%rsp), %ymm1, %ymm2 # ymm2 = (ymm1 * ymm2) + mem
vmovapd %ymm2, (%rsp)
addq $0x4, %rdi
addq $0x20, %r8
cmpq $0x3fc, %rdi            # imm = 0x3FC
jb 0x12d1
vxorpd %xmm1, %xmm1, %xmm1
xorl %edi, %edi
vaddsd (%rsp,%rdi,8), %xmm1, %xmm1
incq %rdi
cmpq $0x4, %rdi
jne 0x12fe
vmovsd %xmm1, (%rsi,%rcx,8)
incq %rcx
addq $0x2000, %rax           # imm = 0x2000
cmpq $0x40, %rcx
jne 0x12c2
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x80, %rsp
leaq 0x2d32(%rip), %rax      # 0x4070
xorl %ecx, %ecx
vxorps %xmm0, %xmm0, %xmm0
leaq 0x82d25(%rip), %rdx     # 0x84070
leaq 0x84d1e(%rip), %rsi     # 0x86070
vmovaps %zmm0, (%rsp)
movq $-0x8, %rdi
movq %rdx, %r8
vmovapd (%r8), %zmm1
vmovapd 0x40(%rax,%rdi,8), %zmm2
vfmadd213pd (%rsp), %zmm1, %zmm2 # zmm2 = (zmm1 * zmm2) + mem
vmovapd %zmm2, (%rsp)
addq $0x8, %rdi
addq $0x40, %r8
cmpq $0x3f8, %rdi            # imm = 0x3F8
jb 0x1363
vxorpd %xmm1, %xmm1, %xmm1
xorl %edi, %edi
vaddsd (%rsp,%rdi,8), %xmm1, %xmm1
incq %rdi
cmpq $0x8, %rdi
jne 0x1396
vmovsd %xmm1, (%rsi,%rcx,8)
incq %rcx
addq $0x2000, %rax           # imm = 0x2000
cmpq $0x40, %rcx
jne 0x1352
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
subq $0x18, %rsp
movabsq $0x5858585858586b, %rax # imm = 0x5858585858586B
leaq -0x18(%rbp), %rbx
movq %rax, 0x7(%rbx)
movabsq $0x6b63617473676962, %rax # imm = 0x6B63617473676962
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x1080
movl %eax, %edi
callq 0x1060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
testl %eax, %eax
js 0x120f
cmpl $0x1, %eax
je 0x1222
xorl %edi, %edi
callq 0x1247
leaq -0x18(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0xdfd(%rip), %rsi       # 0x2013
movl $0x1, %edi
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x10a0
leaq 0xde2(%rip), %rsi       # 0x201a
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x1d4c, %edi           # imm = 0x1D4C
je 0x1292
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %edi, %ebx
leaq -0x410(%rbp), %rdi
movl $0x400, %edx            # imm = 0x400
movl %ebx, %esi
callq 0x1050
leaq 0xdac(%rip), %rdi       # 0x2023
movl %ebx, %esi
xorl %eax, %eax
callq 0x1040
incl %ebx
movl %ebx, %edi
callq 0x1247
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x343f
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)
testq %rdi, %rdi
je 0x34a6
movq %rdi, %rbx
movq 0x2ba2(%rip), %r14      # 0x5ff0
movq (%r14), %rdi
leaq 0x2de0(%rip), %rax      # 0x6238
movq (%rax), %rdx
leaq 0xf58(%rip), %rsi       # 0x43ba
xorl %eax, %eax
callq 0x2150
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 (%r14), %rdi
movq %rbx, %rsi
callq 0x21f0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x2120
movq 0x2b43(%rip), %rax      # 0x5ff0
movq (%rax), %rdi
leaq 0x2d81(%rip), %rax      # 0x6238
movq (%rax), %rdx
leaq 0xefe(%rip), %rsi       # 0x43bf
xorl %eax, %eax
callq 0x2150
movl $0x2, %edi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O1/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:
movq (%rdi), %rcx
movq (%rcx), %rax
cmpb $0x0, 0x2(%rax)
je 0x34e3
addq $0x2, %rax
retq
leaq 0x8(%rcx), %rax
movq %rax, (%rdi)
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0x34f4
retq
pushq %rax
callq 0x22b6
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movl $0x2f, %esi
callq 0x20e0
leaq 0x1(%rax), %r14
testq %rax, %rax
cmoveq %r15, %r14
movq %r14, %rdi
movl $0x2e, %esi
callq 0x20e0
testq %rax, %rax
je 0x3537
movq %rax, %r15
subq %r14, %r15
jmp 0x3542
movq %r14, %rdi
callq 0x20c0
movq %rax, %r15
movq %rbx, %rdi
callq 0x20c0
leaq (%r15,%rax), %rdi
addq $0x2, %rdi
callq 0x37c2
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2160
leaq (%r12,%r15), %rdi
incq %rdi
movb $0x2e, -0x1(%rdi)
movq %rbx, %rsi
callq 0x2070
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, %edi
andl $0x7f, %edi
je 0x35c5
movl %edi, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x35ea
callq 0x21b0
leaq 0xec9(%rip), %rdi       # 0x447d
xorl %ebp, %ebp
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3650
jmp 0x3602
movl %edx, %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
je 0x35ff
movslq %esi, %rdx
leaq 0xe7b(%rip), %rdi       # 0x4457
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3650
jmp 0x3602
leaq 0xea5(%rip), %rdi       # 0x4496
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3650
jmp 0x3602
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x5dfa(%rip), %rsi      # 0xb0ad
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xada2(%rip)      # 0x10068
leaq 0x5d33(%rip), %rsi      # 0xb000
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xad90(%rip)      # 0x10070
leaq 0x5d2e(%rip), %rsi      # 0xb015
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xad7e(%rip)      # 0x10078
leaq 0x5d08(%rip), %rsi      # 0xb009
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xad6c(%rip)      # 0x10080
leaq 0x5cf9(%rip), %rsi      # 0xb014
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xad5a(%rip)      # 0x10088
leaq 0x5ce7(%rip), %rsi      # 0xb01c
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xad48(%rip)      # 0x10090
leaq 0x5cd6(%rip), %rsi      # 0xb025
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xad36(%rip)      # 0x10098
leaq 0x5cba(%rip), %rsi      # 0xb023
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xad24(%rip)      # 0x100a0
leaq 0x5cab(%rip), %rsi      # 0xb02e
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xad12(%rip)      # 0x100a8
leaq 0x5c9c(%rip), %rsi      # 0xb039
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xad00(%rip)      # 0x100b0
leaq 0x5c80(%rip), %rsi      # 0xb037
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xacee(%rip)      # 0x100b8
leaq 0x5c73(%rip), %rsi      # 0xb044
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xacdc(%rip)      # 0x100c0
leaq 0x5c5f(%rip), %rsi      # 0xb04a
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xacca(%rip)      # 0x100c8
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, -0xe0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %r8, -0xd0(%rbp)
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0x5463
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)
testl $0x410040, %esi         # imm = 0x410040
je 0x54a8
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x40(%rbp)
movl $0x10, %ecx
cmpq $0x28, %rcx
ja 0x54ad
movl $0x10, %eax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x54b9
xorl %r15d, %r15d
jmp 0x54bc
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %r15d
xorl %eax, %eax
callq 0xa34c
xorl %eax, %eax
callq 0x5030
movq %rax, %r12
xorl %eax, %eax
callq 0x50a0
testl %eax, %eax
je 0x5525
xorl %eax, %eax
callq 0x5090
testl %eax, %eax
sete %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x5525
cmpq $0x0, (%r12)
je 0x5525
leaq 0x5bae(%rip), %rdi      # 0xb0ad
callq 0x5070
movq 0xab5d(%rip), %rsi      # 0x10068
movq %r12, %rdi
movq %r14, %rdx
movl %ebx, %ecx
movl %r15d, %r8d
callq *(%r12)
movl %eax, %ebx
xorl %eax, %eax
callq 0x5060
jmp 0x5537
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
xorl %eax, %eax
callq *0xab33(%rip)           # 0x10068
movl %eax, %ebx
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, -0xe0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %r8, -0xd0(%rbp)
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0x5644
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)
testl $0x410040, %esi         # imm = 0x410040
je 0x5689
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x40(%rbp)
movl $0x10, %ecx
cmpq $0x28, %rcx
ja 0x568e
movl $0x10, %eax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x569a
xorl %r15d, %r15d
jmp 0x569d
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %r15d
xorl %eax, %eax
callq 0xa34c
xorl %eax, %eax
callq 0x5030
movq %rax, %r12
xorl %eax, %eax
callq 0x50a0
testl %eax, %eax
je 0x5708
xorl %eax, %eax
callq 0x5090
testl %eax, %eax
sete %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x5708
cmpq $0x0, 0x10(%r12)
je 0x5708
leaq 0x5934(%rip), %rdi      # 0xb015
callq 0x5070
movq 0xa98b(%rip), %rsi      # 0x10078
movq %r12, %rdi
movq %r14, %rdx
movl %ebx, %ecx
movl %r15d, %r8d
callq *0x10(%r12)
movl %eax, %ebx
xorl %eax, %eax
callq 0x5060
jmp 0x571a
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
xorl %eax, %eax
callq *0xa960(%rip)           # 0x10078
movl %eax, %ebx
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
movq %rcx, -0xd8(%rbp)
movq %r8, -0xd0(%rbp)
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0x5825
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)
testl $0x410040, %edx         # imm = 0x410040
je 0x586a
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, -0x40(%rbp)
movl $0x18, %ecx
cmpq $0x28, %rcx
ja 0x586f
movl $0x18, %eax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x587b
xorl %r12d, %r12d
jmp 0x587e
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %r12d
xorl %eax, %eax
callq 0xa34c
xorl %eax, %eax
callq 0x5030
movq %rax, %r13
xorl %eax, %eax
callq 0x50a0
testl %eax, %eax
je 0x58eb
xorl %eax, %eax
callq 0x5090
testl %eax, %eax
sete %al
testq %r13, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x58eb
cmpq $0x0, 0x20(%r13)
je 0x58eb
leaq 0x575b(%rip), %rdi      # 0xb01c
callq 0x5070
movq 0xa7c3(%rip), %rsi      # 0x10090
movq %r13, %rdi
movl %r15d, %edx
movq %r14, %rcx
movl %ebx, %r8d
movl %r12d, %r9d
callq *0x20(%r13)
movl %eax, %ebx
xorl %eax, %eax
callq 0x5060
jmp 0x5900
movl %r15d, %edi
movq %r14, %rsi
movl %ebx, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq *0xa792(%rip)           # 0x10090
movl %eax, %ebx
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
movq %rcx, -0xd8(%rbp)
movq %r8, -0xd0(%rbp)
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0x5ab7
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)
testl $0x410040, %edx         # imm = 0x410040
je 0x5afc
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, -0x40(%rbp)
movl $0x18, %ecx
cmpq $0x28, %rcx
ja 0x5b01
movl $0x18, %eax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x5b0d
xorl %r12d, %r12d
jmp 0x5b10
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %r12d
xorl %eax, %eax
callq 0xa34c
xorl %eax, %eax
callq 0x5030
movq %rax, %r13
xorl %eax, %eax
callq 0x50a0
testl %eax, %eax
je 0x5b7d
xorl %eax, %eax
callq 0x5090
testl %eax, %eax
sete %al
testq %r13, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x5b7d
cmpq $0x0, 0x38(%r13)
je 0x5b7d
leaq 0x54db(%rip), %rdi      # 0xb02e
callq 0x5070
movq 0xa549(%rip), %rsi      # 0x100a8
movq %r13, %rdi
movl %r15d, %edx
movq %r14, %rcx
movl %ebx, %r8d
movl %r12d, %r9d
callq *0x38(%r13)
movl %eax, %ebx
xorl %eax, %eax
callq 0x5060
jmp 0x5b92
movl %r15d, %edi
movq %r14, %rsi
movl %ebx, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq *0xa518(%rip)           # 0x100a8
movl %eax, %ebx
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x50e7(%rip), %rsi      # 0xb052
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xa152(%rip)      # 0x100d0
leaq 0x50db(%rip), %rsi      # 0xb060
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xa140(%rip)      # 0x100d8
leaq 0x50ba(%rip), %rsi      # 0xb059
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xa12e(%rip)      # 0x100e0
leaq 0x50ae(%rip), %rsi      # 0xb067
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xa11c(%rip)      # 0x100e8
leaq 0x509f(%rip), %rsi      # 0xb072
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xa10a(%rip)      # 0x100f0
leaq 0x5083(%rip), %rsi      # 0xb070
movq $-0x1, %rdi
callq 0x5080
movq %rax, 0xa0f8(%rip)      # 0x100f8
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x0, 0x6005(%rip)      # 0x10358
jne 0xa384
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
callq 0x52a8
xorl %eax, %eax
callq 0x685c
xorl %eax, %eax
callq 0x5f60
xorl %eax, %eax
callq 0x8b5c
xorl %eax, %eax
callq 0x8fb8
movb $0x1, 0x5fd5(%rip)      # 0x10358
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
testq %rdi, %rdi
je 0x1216
movq %rdi, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x120c
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
callq 0x1030
jmp 0x11f6
movq $0x0, 0x8(%rbx)
popq %rbx
retq
leaq 0xde7(%rip), %rdi       # 0x2004
leaq 0xde8(%rip), %rsi       # 0x200c
leaq 0xdfd(%rip), %rcx       # 0x2028
movl $0x30, %edx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl $0x10, %edi
callq 0x1080
testq %rax, %rax
je 0x124d
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rcx
retq
leaq 0xde6(%rip), %rdi       # 0x203a
xorl %eax, %eax
callq 0x1060
movl $0x1, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1310
cmpq $0x0, (%rdi)
je 0x12f1
cmpq $0x0, 0x8(%rdi)
je 0x12f1
movq (%rdi), %r14
testq %r14, %r14
je 0x12ff
leaq 0xd9b(%rip), %rbx       # 0x2074
movl (%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1060
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x12d9
jmp 0x12ff
leaq 0xe8b(%rip), %rdi       # 0x2183
xorl %eax, %eax
callq 0x1060
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
leaq 0xced(%rip), %rdi       # 0x2004
leaq 0xcee(%rip), %rsi       # 0x200c
leaq 0xd3d(%rip), %rcx       # 0x2062
movl $0x4e, %edx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1381
movq %rsi, %rbx
movl %edi, %ebp
movl $0x10, %edi
callq 0x1080
testq %rax, %rax
je 0x13a0
movl %ebp, (%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, (%rbx)
je 0x1370
cmpq $0x0, 0x8(%rbx)
je 0x1370
movq 0x8(%rbx), %rcx
addq $0x8, %rbx
movq %rax, 0x8(%rcx)
jmp 0x1377
movq %rax, (%rbx)
addq $0x8, %rbx
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xc7c(%rip), %rdi       # 0x2004
leaq 0xc7d(%rip), %rsi       # 0x200c
leaq 0xce2(%rip), %rcx       # 0x2078
movl $0x5f, %edx
callq 0x1070
leaq 0xdbc(%rip), %rdi       # 0x2163
callq 0x1050
movl $0x1, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/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 %rax
testq %rdi, %rdi
je 0x13ec
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x13d6
cmpq $0x0, 0x8(%rdi)
je 0x13d6
movl (%rcx), %eax
movq 0x8(%rcx), %rcx
movq %rcx, (%rdi)
popq %rcx
retq
leaq 0xda6(%rip), %rdi       # 0x2183
callq 0x1050
movl $0x1, %edi
callq 0x1090
leaq 0xc11(%rip), %rdi       # 0x2004
leaq 0xc12(%rip), %rsi       # 0x200c
leaq 0xc90(%rip), %rcx       # 0x2091
movl $0x6e, %edx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 %rax
testq %rdi, %rdi
je 0x143c
movq (%rdi), %rax
testq %rax, %rax
je 0x1424
cmpq $0x0, 0x8(%rdi)
je 0x1424
movl (%rax), %eax
popq %rcx
retq
leaq 0xc8a(%rip), %rdi       # 0x20b5
xorl %eax, %eax
callq 0x1060
movl $0x1, %edi
callq 0x1090
leaq 0xbc1(%rip), %rdi       # 0x2004
leaq 0xbc2(%rip), %rsi       # 0x200c
leaq 0xc53(%rip), %rcx       # 0x20a4
movl $0x79, %edx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
leaq 0xc6d(%rip), %rdi       # 0x20d2
callq 0x1050
xorl %ebp, %ebp
callq 0x1235
movq %rax, %rbx
movl %ebp, %edi
movq %rbx, %rsi
callq 0x132f
movq %rbx, %rdi
callq 0x12b4
incl %ebp
cmpl $0xa, %ebp
jne 0x1474
leaq 0xc5b(%rip), %rdi       # 0x20ef
callq 0x1050
movl $0x8, %ebp
movq %rbx, %rdi
callq 0x13b6
movq %rbx, %rdi
callq 0x12b4
decl %ebp
jne 0x149e
leaq 0xc53(%rip), %rdi       # 0x210c
callq 0x1050
xorl %ebp, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x132f
movq %rbx, %rdi
callq 0x12b4
decl %ebp
cmpl $-0x7, %ebp
jne 0x14c0
leaq 0xc49(%rip), %rdi       # 0x2129
callq 0x1050
movl $0x6, %ebp
movq %rbx, %rdi
callq 0x13b6
movq %rbx, %rdi
callq 0x12b4
decl %ebp
jne 0x14ea
leaq 0xc41(%rip), %rdi       # 0x2146
callq 0x1050
movq %rbx, %rdi
callq 0x11ed
movq %rbx, %rdi
callq 0x12b4
leaq 0xba3(%rip), %rdi       # 0x20c4
xorl %eax, %eax
callq 0x1060
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x11f0
cmpl $0x1, %ebp
jne 0x120b
cmpb $0xf, (%r14)
je 0x11fd
cmpl $0x2, %ebp
jne 0x120b
cmpb $0xf, (%r14)
jne 0x120b
cmpb $0xf, 0x1(%r14)
jne 0x120b
movl $0x1, %ebp
leaq 0x2e70(%rip), %r15      # 0x4079
jmp 0x1242
leaq 0x4(%rsp), %r15
movl %ebp, (%r15)
movl $0x1, %esi
movl $0x4, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x10c0
incl %ebp
andl $-0x2, %ebp
movslq %ebp, %rdx
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rcx
callq 0x10c0
xorl %ebp, %ebp
movl $0x1, %esi
movl $0x4, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x10c0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x1236
movq %r14, %rdi
callq 0x1050
movl $0x40, %edi
callq 0x10b0
testq %rax, %rax
je 0x1299
movq %rax, %rbx
leaq 0xe48(%rip), %rsi       # 0x2097
movq %r14, %rdi
callq 0x10e0
testq %rax, %rax
je 0x1281
xorl %r15d, %r15d
leaq 0xe31(%rip), %r14       # 0x2097
movq %rax, (%rbx,%r15,8)
incq %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x10e0
testq %rax, %rax
jne 0x1266
movl %r15d, %eax
jmp 0x1283
xorl %eax, %eax
movq $0x0, (%rbx,%rax,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xed6(%rip), %rdi       # 0x2176
callq 0x1040
movl $0x1, %edi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
callq 0x1060
testq %rax, %rax
je 0x136e
movq %rax, %r14
movq %rax, %rdi
callq 0x10a0
testq %rax, %rax
je 0x137c
leaq 0xd39(%rip), %r15       # 0x2025
leaq 0xedf(%rip), %r12       # 0x21d2
leaq -0x2c(%rbp), %r13
movq %r15, -0x60(%rbp)
movq 0x8(%rbx), %rcx
movq %rcx, -0x58(%rbp)
addq $0x13, %rax
movq %rax, -0x50(%rbp)
movq 0x10(%rbx), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
callq 0x1110
testl %eax, %eax
js 0x1337
je 0x1341
movl %eax, %edi
movq %r13, %rsi
movl $0x2, %edx
callq 0x10c0
jmp 0x135f
movq %r12, %rdi
callq 0x1040
jmp 0x135f
movq %r15, %rdi
leaq -0x60(%rbp), %rsi
callq 0x1100
testl %eax, %eax
jns 0x135f
leaq 0xcdc(%rip), %rdi       # 0x2034
xorl %eax, %eax
callq 0x1070
movq %r14, %rdi
callq 0x10a0
testq %rax, %rax
jne 0x12f7
jmp 0x137c
leaq 0xc8f(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1070
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/niuyuling[P]CProxy/main.c
// Function: help_information
static char help_information(void)
{
    static const char name[] = "C";
    static const char subject[] = "Proxy Server";
    static const struct {
        const char *email;
    } author = {
        "AIXIAO@AIXIAO.ME",
    };

    static const char usage[] = "Usage: [-?h] [-s signal] [-c filename]";
    static const char *s_help[] = {
        "",
        "Options:",
        "    -s --signal            : send signal to a master process: stop, quit, restart, reload, status",
        "    -c --config            : set configuration file, default: CProxy.conf",
        "    -? -h --? --help       : help information",
        "",
        0
    };

    fprintf(stderr, "%s %s\n", name, subject);
    fprintf(stderr, "Author: %s\n", author.email);
    fprintf(stderr, "%s\n", usage);

    int l;
    for (l = 0; s_help[l]; l++) {
        fprintf(stderr, "%s\n", s_help[l]);
    }

    BUILD("Compile、link.\n");

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x9a71(%rip), %r14      # 0xbff0
movq (%r14), %rdi
leaq 0x6d0c(%rip), %rsi      # 0x9295
leaq 0x6ac8(%rip), %rdx      # 0x9058
leaq 0x6ac3(%rip), %rcx      # 0x905a
xorl %eax, %eax
callq 0x22a0
movq (%r14), %rdi
leaq 0x6cf4(%rip), %rsi      # 0x929c
leaq 0x6bf2(%rip), %rdx      # 0x91a1
xorl %eax, %eax
callq 0x22a0
movq (%r14), %rdi
leaq 0x6ce4(%rip), %rbx      # 0x92a4
leaq 0x6aa9(%rip), %rdx      # 0x9070
movq %rbx, %rsi
xorl %eax, %eax
callq 0x22a0
leaq 0x9778(%rip), %r15      # 0xbd50
xorl %r12d, %r12d
movq (%r12,%r15), %rdx
movq (%r14), %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x22a0
addq $0x8, %r12
cmpq $0x30, %r12
jne 0x25db
movq (%r14), %rdi
leaq 0x6ca8(%rip), %rsi      # 0x92a8
leaq 0x6ca8(%rip), %rdx      # 0x92af
leaq 0x6cad(%rip), %rcx      # 0x92bb
xorl %eax, %eax
callq 0x22a0
movq (%r14), %rcx
leaq 0x6ca5(%rip), %rdi      # 0x92c4
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x24c0
// File: /workspace/github_c_makefile_star2_O1/niuyuling[P]CProxy/main.c
// Function: create_server_socket
int create_server_socket(int port)
{
    int server_sock;
    int optval = 1;
    struct sockaddr_in server_addr;
    if ((server_sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket");
        return -1;
    }
    if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0) {
        perror("setsockopt");
        return -1;
    }
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    server_addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(server_sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) != 0) {
        perror("bind");
        return -1;
    }
    if (listen(server_sock, 500) < 0) {
        perror("listen");
        return -1;
    }
    return server_sock;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebp
movl $0x1, 0xc(%rsp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2540
testl %eax, %eax
js 0x285b
movl %eax, %ebx
leaq 0xc(%rsp), %rcx
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x20b0
testl %eax, %eax
js 0x2864
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movw $0x2, (%rsi)
rolw $0x8, %bp
movw %bp, 0x2(%rsi)
movl $0x0, 0x4(%rsi)
movl %ebx, %edi
movl $0x10, %edx
callq 0x2400
testl %eax, %eax
jne 0x286d
movl %ebx, %edi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x2350
testl %eax, %eax
jns 0x287e
leaq 0x6cbb(%rip), %rdi      # 0x9514
jmp 0x2874
leaq 0x6879(%rip), %rdi      # 0x90db
jmp 0x2874
leaq 0x682c(%rip), %rdi      # 0x9097
jmp 0x2874
leaq 0x6872(%rip), %rdi      # 0x90e6
callq 0x2450
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/niuyuling[P]CProxy/main.c
// Function: create_server_socket6
int create_server_socket6(int port)
{
    int server_sock;
    int optval = SO_REUSEADDR;
    struct sockaddr_in6 server_addr;
    if ((server_sock = socket(AF_INET6, SOCK_STREAM, 0)) < 0) {
        perror("socket");
        return -1;
    }

    if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0) {
        perror("setsockopt");
        return -1;
    }

    if (setsockopt(server_sock, IPPROTO_IPV6, IPV6_V6ONLY, &optval, sizeof(optval)) < 0) {
        perror("setsockopt");
        return -1;
    }

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin6_family = AF_INET6;
    server_addr.sin6_port = htons(port);
    server_addr.sin6_addr = in6addr_any;

    if (bind(server_sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in6)) != 0) {
        perror("bind");
        return -1;
    }

    if (listen(server_sock, 500) < 0) {
        perror("listen");
        return -1;
    }

    return server_sock;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebp
movl $0x2, 0xc(%rsp)
movl $0xa, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2540
testl %eax, %eax
js 0x2952
movl %eax, %ebx
leaq 0xc(%rsp), %rcx
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x20b0
leaq 0x67c0(%rip), %r14      # 0x9097
testl %eax, %eax
js 0x2962
leaq 0xc(%rsp), %rcx
movl %ebx, %edi
movl $0x29, %esi
movl $0x1a, %edx
movl $0x4, %r8d
callq 0x20b0
testl %eax, %eax
js 0x2962
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movups %xmm0, 0xc(%rsi)
movw $0xa, (%rsi)
rolw $0x8, %bp
movw %bp, 0x2(%rsi)
movq 0x96a6(%rip), %rax      # 0xbfc8
movups (%rax), %xmm0
movups %xmm0, 0x8(%rsi)
movl %ebx, %edi
movl $0x1c, %edx
callq 0x2400
testl %eax, %eax
jne 0x295b
movl %ebx, %edi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x2350
testl %eax, %eax
jns 0x296f
leaq 0x6bc4(%rip), %r14      # 0x9514
jmp 0x2962
leaq 0x6782(%rip), %r14      # 0x90db
jmp 0x2962
leaq 0x6784(%rip), %r14      # 0x90e6
movq %r14, %rdi
callq 0x2450
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/niuyuling[P]CProxy/main.c
// Function: accept_client
void accept_client()
{
    struct epoll_event epollEvent;
    struct sockaddr_in addr;
    conn_t *client;
    socklen_t addr_len = sizeof(addr);

    // 偶数为客户端,奇数为服务端
    for (client = cts; client - cts < MAX_CONNECTION; client += 2)
        if (client->fd < 0)
            break;
    if (client - cts >= MAX_CONNECTION)
        return;
    client->timer = (client + 1)->timer = 0;
    client->fd = accept(server_sock, (struct sockaddr *)&addr, &addr_len);
    if (client->fd < 0)
        return;
    fcntl(client->fd, F_SETFL, O_NONBLOCK);
    epollEvent.events = EPOLLIN | EPOLLET;
    epollEvent.data.ptr = client;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, client->fd, &epollEvent);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl $0x10, (%rsp)
cmpl $0x0, 0x9a93(%rip)      # 0xc420
js 0x29c6
xorl %ecx, %ecx
leaq 0x9a78(%rip), %rax      # 0xc410
movl $0x9f60, %edx           # imm = 0x9F60
leaq (%rax,%rdx), %rbx
leaq 0x50(%rcx), %rsi
cmpq %rdx, %rsi
jge 0x29d1
cmpl $0x0, 0x60(%rcx,%rax)
movq %rsi, %rcx
jns 0x29a1
cmpq $0x9f39, %rsi           # imm = 0x9F39
setge %cl
addq %rsi, %rax
movq %rax, %rbx
jmp 0x29d3
leaq 0x9a43(%rip), %rbx      # 0xc410
xorl %ecx, %ecx
jmp 0x29d3
movb $0x1, %cl
testb %cl, %cl
jne 0x2a2e
xorl %eax, %eax
movl %eax, 0x48(%rbx)
movl %eax, 0x20(%rbx)
movl 0x1398b(%rip), %edi     # 0x16370
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
callq 0x2460
movl %eax, 0x10(%rbx)
testl %eax, %eax
js 0x2a2e
movl %eax, %edi
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x20d0
leaq 0x4(%rsp), %rcx
movl $0x80000001, (%rcx)     # imm = 0x80000001
movq %rbx, 0x4(%rcx)
movl 0x13953(%rip), %edi     # 0x16374
movl 0x10(%rbx), %edx
movl $0x1, %esi
callq 0x2220
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/niuyuling[P]CProxy/main.c
// Function: accept_client6
void accept_client6()
{
    struct epoll_event epollEvent;
    struct sockaddr_in6 addr;
    conn_t *client;
    socklen_t addr_len = sizeof(addr);

    // 偶数为客户端,奇数为服务端
    for (client = cts; client - cts < MAX_CONNECTION; client += 2)
        if (client->fd < 0)
            break;
    if (client - cts >= MAX_CONNECTION)
        return;
    client->timer = (client + 1)->timer = 0;
    client->fd = accept(server_sock6, (struct sockaddr *)&addr, &addr_len);
    if (client->fd < 0)
        return;
    fcntl(client->fd, F_SETFL, O_NONBLOCK);
    epollEvent.events = EPOLLIN | EPOLLET;
    epollEvent.data.ptr = client;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, client->fd, &epollEvent);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl $0x1c, 0x4(%rsp)
cmpl $0x0, 0x99d8(%rip)      # 0xc420
js 0x2a81
xorl %ecx, %ecx
leaq 0x99bd(%rip), %rax      # 0xc410
movl $0x9f60, %edx           # imm = 0x9F60
leaq (%rax,%rdx), %rbx
leaq 0x50(%rcx), %rsi
cmpq %rdx, %rsi
jge 0x2a8c
cmpl $0x0, 0x60(%rcx,%rax)
movq %rsi, %rcx
jns 0x2a5c
cmpq $0x9f39, %rsi           # imm = 0x9F39
setge %cl
addq %rsi, %rax
movq %rax, %rbx
jmp 0x2a8e
leaq 0x9988(%rip), %rbx      # 0xc410
xorl %ecx, %ecx
jmp 0x2a8e
movb $0x1, %cl
testb %cl, %cl
jne 0x2aeb
xorl %eax, %eax
movl %eax, 0x48(%rbx)
movl %eax, 0x20(%rbx)
movl 0x138d8(%rip), %edi     # 0x16378
leaq 0x14(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x2460
movl %eax, 0x10(%rbx)
testl %eax, %eax
js 0x2aeb
movl %eax, %edi
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x20d0
leaq 0x8(%rsp), %rcx
movl $0x80000001, (%rcx)     # imm = 0x80000001
movq %rbx, 0x4(%rcx)
movl 0x13896(%rip), %edi     # 0x16374
movl 0x10(%rbx), %edx
movl $0x1, %esi
callq 0x2220
addq $0x30, %rsp
popq %rbx
retq