LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/minkcv[P]vm/machine/ipu.c
// Function: destroyIPU
void destroyIPU(IPU* ipu)
{
    free(ipu->js1);
    ipu->js1 = NULL;
    free(ipu->js2);
    ipu->js2 = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1170
andq $0x0, (%rbx)
movq 0x8(%rbx), %rdi
callq 0x1170
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/minkcv[P]vm/machine/ipu.c
// Function: updateIPU
void updateIPU(IPU* ipu, SDL_KeyboardEvent kEvent, 
        uint8_t memory[MEMORY_SEGMENT_COUNT][MEMORY_SEGMENT_SIZE])
{
    updateJoystick(ipu->js1, kEvent);
    updateJoystick(ipu->js2, kEvent);
    memory[JOYSTICK_SEG][JOYSTICK_1_OFFSET] = ipu->js1->keysAsBits;
    memory[JOYSTICK_SEG][JOYSTICK_2_OFFSET] = ipu->js2->keysAsBits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movaps 0x10(%rbp), %xmm0
movaps 0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x23ff
movq 0x8(%r14), %rdi
movaps 0x10(%rbp), %xmm0
movaps 0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x23ff
movq (%r14), %rax
movb 0x20(%rax), %al
movb %al, 0x7f00(%rbx)
movq 0x8(%r14), %rax
movb 0x20(%rax), %al
movb %al, 0x7f01(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/minkcv[P]vm/machine/ipu.c
// Function: updateJoystick
void updateJoystick(JOYSTICK* js, SDL_KeyboardEvent kEvent)
{
    int i;
    uint8_t bit = 1;
    for (i = 0; i < NUM_JOYSTICK_BUTTONS; i++)
    {
        if (kEvent.keysym.sym == js->buttons[i])
        {
            if (kEvent.type == SDL_KEYDOWN)
            {
                // Leave the other bits but ensure the ith bit is 1
                js->keysAsBits |= (bit << i);
            }
            else if (kEvent.type == SDL_KEYUP)
            {
                // Leave the other bits but ensure the ith bit is 0
                js->keysAsBits &= (~(bit << i)); // Bitwise inversion
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movl 0x24(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %esi
cmpq $0x8, %rcx
je 0x244b
cmpl (%rdi,%rcx,4), %edx
jne 0x2446
cmpl $0x301, %eax            # imm = 0x301
je 0x2435
cmpl $0x300, %eax            # imm = 0x300
jne 0x2446
movl %esi, %r8d
shll %cl, %r8d
orb 0x20(%rdi), %r8b
jmp 0x2442
movl %esi, %r8d
shll %cl, %r8d
notb %r8b
andb 0x20(%rdi), %r8b
movb %r8b, 0x20(%rdi)
incq %rcx
jmp 0x2410
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/minkcv[P]vm/machine/cpu.c
// Function: print_disasm_block
void print_disasm_block(CPU *cpu) {
    // Disassemble next 16 instructions
    int i;
    for (i = 0; i < 16; i++)
    {
	int instructionCount = cpu->pc - cpu->code + i;
	if (instructionCount > JUMP_SEGMENT_SIZE * JUMP_SEGMENT_SIZE)
	  continue; // End of program, can't keep reading instructions.
	int instructionSegment = instructionCount / JUMP_SEGMENT_SIZE;
	int instructionOffset = instructionCount % JUMP_SEGMENT_SIZE;
	char assembly[256];
	memset(assembly, 0, sizeof(char) * 256);
	Instruction decoded;
	decode(*(cpu->pc + i), &decoded);
	disassemble(&decoded, assembly);
	// Print star for current instruction
	if (i == 0)
	  printf("*");
	else
	  printf(" ");

	// Print disassembly with segment.offset address
	printf(" %-30s ; %03d.%03d 0x%02X.0x%02X\n", assembly,
	       instructionSegment, instructionOffset,
	       instructionSegment, instructionOffset);
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
xorl %r15d, %r15d
movq %rdi, -0x30(%rbp)
cmpq $0x10, %r15
je 0x2993
movq 0x10(%rdi), %r14
movq %r14, %rax
subq 0x18(%rdi), %rax
shrq %rax
addq %r15, %rax
cmpl $0x10000, %eax          # imm = 0x10000
jg 0x298b
cltd
movl $0x100, %ecx            # imm = 0x100
idivl %ecx
movl %edx, %r13d
movl %eax, %r12d
movl $0x100, %edx            # imm = 0x100
leaq -0x140(%rbp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10a0
movzwl (%r14,%r15,2), %edi
leaq -0x34(%rbp), %r14
movq %r14, %rsi
callq 0x2609
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2450
testq %r15, %r15
pushq $0x20
popq %rdi
pushq $0x2a
popq %rax
cmovel %eax, %edi
callq 0x11b0
leaq 0xaa5(%rip), %rdi       # 0x3416
movq %rbx, %rsi
movl %r12d, %edx
movl %r13d, %ecx
movl %r12d, %r8d
movl %r13d, %r9d
xorl %eax, %eax
callq 0x1040
movq -0x30(%rbp), %rdi
incq %r15
jmp 0x28f7
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rax
subq 0x18(%rdi), %rax
shrq %rax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
leaq 0xa66(%rip), %rdi       # 0x3438
movl %eax, %esi
movl %eax, %ecx
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), %edi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x2609
movq %r15, %rdi
movq %r14, %rsi
callq 0x2450
leaq 0xa3b(%rip), %rdi       # 0x3456
movq %r14, %rsi
xorl %eax, %eax
callq 0x1040
leaq 0xa33(%rip), %r14       # 0x345f
xorl %r15d, %r15d
cmpq $0x10, %r15
je 0x2a4e
movzbl (%rbx,%r15), %ecx
movq %r14, %rdi
movl %r15d, %esi
movl %ecx, %edx
xorl %eax, %eax
callq 0x1040
incq %r15
jmp 0x2a2f
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1070
movl %eax, %edi
callq 0x1060
leaq 0x2ec6(%rip), %r14      # 0x4070
movl $0x3e8, %ebp            # imm = 0x3E8
cmpq $0x40, %rbx
je 0x11ec
xorl %r15d, %r15d
cmpq $0x400, %r15            # imm = 0x400
je 0x11e0
callq 0x1080
cltd
idivl %ebp
vcvtsi2sd %edx, %xmm1, %xmm0
vdivsd 0xe33(%rip), %xmm0, %xmm0 # 0x2008
vmovsd %xmm0, (%r14,%r15,8)
incq %r15
jmp 0x11b8
incq %rbx
addq $0x2000, %r14           # imm = 0x2000
jmp 0x11af
xorl %ebx, %ebx
movl $0x3e8, %ebp            # imm = 0x3E8
leaq 0x82e76(%rip), %r14     # 0x84070
cmpq $0x2000, %rbx           # imm = 0x2000
je 0x1223
callq 0x1080
cltd
idivl %ebp
vcvtsi2sd %edx, %xmm1, %xmm0
vdivsd 0xdf1(%rip), %xmm0, %xmm0 # 0x2008
vmovsd %xmm0, (%rbx,%r14)
addq $0x8, %rbx
jmp 0x11fa
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2e3b(%rip), %rax      # 0x4070
xorl %ecx, %ecx
leaq 0x84e32(%rip), %rdx     # 0x86070
leaq 0x82e2b(%rip), %rsi     # 0x84070
cmpq $0x40, %rcx
je 0x127b
vxorpd %xmm0, %xmm0, %xmm0
xorl %edi, %edi
cmpq $0x2000, %rdi           # imm = 0x2000
je 0x126b
vmovsd (%rax,%rdi), %xmm1
vfmadd231sd (%rdi,%rsi), %xmm1, %xmm0 # xmm0 = (xmm1 * mem) + xmm0
addq $0x8, %rdi
jmp 0x1251
vmovsd %xmm0, (%rdx,%rcx,8)
incq %rcx
addq $0x2000, %rax           # imm = 0x2000
jmp 0x1245
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2de1(%rip), %rax      # 0x4070
xorl %ecx, %ecx
vxorps %xmm0, %xmm0, %xmm0
leaq 0x82dd4(%rip), %rdx     # 0x84070
leaq 0x84dcd(%rip), %rsi     # 0x86070
cmpq $0x40, %rcx
je 0x1302
vmovaps %ymm0, (%rsp)
movq %rdx, %rdi
xorl %r8d, %r8d
cmpq $0x400, %r8             # imm = 0x400
jae 0x12dc
vmovapd (%rdi), %ymm1
vmovapd (%rax,%r8,8), %ymm2
vfmadd213pd (%rsp), %ymm1, %ymm2 # ymm2 = (ymm1 * ymm2) + mem
vmovapd %ymm2, (%rsp)
addq $0x4, %r8
addq $0x20, %rdi
jmp 0x12b4
vxorpd %xmm1, %xmm1, %xmm1
xorl %edi, %edi
cmpq $0x4, %rdi
je 0x12f2
vaddsd (%rsp,%rdi,8), %xmm1, %xmm1
incq %rdi
jmp 0x12e2
vmovsd %xmm1, (%rsi,%rcx,8)
incq %rcx
addq $0x2000, %rax           # imm = 0x2000
jmp 0x12a3
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d50(%rip), %rax      # 0x4070
xorl %ecx, %ecx
vxorps %xmm0, %xmm0, %xmm0
leaq 0x82d43(%rip), %rdx     # 0x84070
leaq 0x84d3c(%rip), %rsi     # 0x86070
cmpq $0x40, %rcx
je 0x139b
vmovaps %zmm0, (%rsp)
movq %rdx, %rdi
xorl %r8d, %r8d
cmpq $0x400, %r8             # imm = 0x400
jae 0x1375
vmovapd (%rdi), %zmm1
vmovapd (%rax,%r8,8), %zmm2
vfmadd213pd (%rsp), %zmm1, %zmm2 # zmm2 = (zmm1 * zmm2) + mem
vmovapd %zmm2, (%rsp)
addq $0x8, %r8
addq $0x40, %rdi
jmp 0x1347
vxorpd %xmm1, %xmm1, %xmm1
xorl %edi, %edi
cmpq $0x8, %rdi
je 0x138b
vaddsd (%rsp,%rdi,8), %xmm1, %xmm1
incq %rdi
jmp 0x137b
vmovsd %xmm1, (%rsi,%rcx,8)
incq %rcx
addq $0x2000, %rax           # imm = 0x2000
jmp 0x1334
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1220
xorl %edi, %edi
callq 0x1243
leaq -0x18(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0xdfd(%rip), %rsi       # 0x2013
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x10a0
leaq 0xde4(%rip), %rsi       # 0x201a
pushq $0x1
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/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 0x128e
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 0xdb0(%rip), %rdi       # 0x2023
movl %ebx, %esi
xorl %eax, %eax
callq 0x1040
incl %ebx
movl %ebx, %edi
callq 0x1243
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x345b
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 0x34c0
movq %rdi, %rbx
movq 0x2b86(%rip), %r14      # 0x5ff0
movq (%r14), %rdi
leaq 0x2dc4(%rip), %rax      # 0x6238
movq (%rax), %rdx
leaq 0xf85(%rip), %rsi       # 0x4403
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 0x2200
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x2120
movq 0x2b29(%rip), %rax      # 0x5ff0
movq (%rax), %rdi
leaq 0x2d67(%rip), %rax      # 0x6238
movq (%rax), %rdx
leaq 0xf2d(%rip), %rsi       # 0x4408
xorl %eax, %eax
callq 0x2150
pushq $0x2
popq %rdi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O2/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 0x34fb
addq $0x2, %rax
retq
leaq 0x8(%rcx), %rax
movq %rax, (%rdi)
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0x350c
retq
pushq %rax
xorl %edi, %edi
xorl %eax, %eax
callq 0x33fd
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2f
popq %rsi
callq 0x20e0
leaq 0x1(%rax), %r14
testq %rax, %rax
cmoveq %r15, %r14
pushq $0x2e
popq %rsi
movq %r14, %rdi
callq 0x20e0
testq %rax, %rax
je 0x354f
movq %rax, %r15
subq %r14, %r15
jmp 0x355a
movq %r14, %rdi
callq 0x20c0
movq %rax, %r15
movq %rbx, %rdi
callq 0x20c0
leaq (%r15,%rax), %rdi
addq $0x2, %rdi
callq 0x38ab
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_O2/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 0x35dd
movl %edi, %eax
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x2000000, %eax        # imm = 0x2000000
jl 0x3602
callq 0x21c0
leaq 0xefa(%rip), %rdi       # 0x44c6
xorl %ebp, %ebp
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x36c8
jmp 0x361a
movl %edx, %ecx
shrl $0x8, %ecx
andl $0xff, %ecx
je 0x3617
movslq %esi, %rdx
leaq 0xeac(%rip), %rdi       # 0x44a0
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x36c8
jmp 0x361a
leaq 0xed6(%rip), %rdi       # 0x44df
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x36c8
jmp 0x361a
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, 0x2bf4(%rip)      # 0x6232
je 0x366b
movq (%r15), %r8
movq (%r8), %rsi
movq 0x298b(%rip), %rax      # 0x5fd8
movq (%rax), %r9
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
movq 0x297e(%rip), %r13      # 0x5ff0
movq (%r13), %rdi
leaq 0x2bbb(%rip), %rax      # 0x6238
movq (%rax), %rdx
leaq 0xe0c(%rip), %rsi       # 0x4493
xorl %eax, %eax
callq 0x2150
movq (%r15), %rbp
leaq 0xdeb(%rip), %r12       # 0x4483
movq (%rbp), %rdx
movq (%r13), %rsi
testq %rdx, %rdx
je 0x36b8
movq %rsi, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2150
addq $0x8, %rbp
jmp 0x3698
pushq $0xa
popq %rdi
callq 0x2120
jmp 0x3640
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
leaq 0x5df8(%rip), %rsi      # 0xb0ad
pushq $-0x1
popq %rbx
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xada1(%rip)      # 0x10068
leaq 0x5d32(%rip), %rsi      # 0xb000
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad93(%rip)      # 0x10070
leaq 0x5d31(%rip), %rsi      # 0xb015
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad85(%rip)      # 0x10078
leaq 0x5d0f(%rip), %rsi      # 0xb009
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad77(%rip)      # 0x10080
leaq 0x5d04(%rip), %rsi      # 0xb014
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad69(%rip)      # 0x10088
leaq 0x5cf6(%rip), %rsi      # 0xb01c
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad5b(%rip)      # 0x10090
leaq 0x5ce9(%rip), %rsi      # 0xb025
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad4d(%rip)      # 0x10098
leaq 0x5cd1(%rip), %rsi      # 0xb023
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad3f(%rip)      # 0x100a0
leaq 0x5cc6(%rip), %rsi      # 0xb02e
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad31(%rip)      # 0x100a8
leaq 0x5cbb(%rip), %rsi      # 0xb039
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad23(%rip)      # 0x100b0
leaq 0x5ca3(%rip), %rsi      # 0xb037
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad15(%rip)      # 0x100b8
leaq 0x5c9a(%rip), %rsi      # 0xb044
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xad07(%rip)      # 0x100c0
leaq 0x5c8a(%rip), %rsi      # 0xb04a
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xacf9(%rip)      # 0x100c8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5439
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 0x547a
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)
pushq $0x10
popq %rcx
cmpq $0x28, %rcx
ja 0x547f
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x548b
xorl %r15d, %r15d
jmp 0x548e
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %r15d
xorl %eax, %eax
callq 0xa200
xorl %eax, %eax
callq 0x5030
movq %rax, %r12
xorl %eax, %eax
callq 0x50a0
testl %eax, %eax
je 0x54f7
xorl %eax, %eax
callq 0x5090
testl %eax, %eax
sete %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x54f7
cmpq $0x0, (%r12)
je 0x54f7
leaq 0x5bdc(%rip), %rdi      # 0xb0ad
callq 0x5070
movq 0xab8b(%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 0x5509
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
xorl %eax, %eax
callq *0xab61(%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_O2/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 0x5616
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 0x5657
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)
pushq $0x10
popq %rcx
cmpq $0x28, %rcx
ja 0x565c
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x5668
xorl %r15d, %r15d
jmp 0x566b
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %r15d
xorl %eax, %eax
callq 0xa200
xorl %eax, %eax
callq 0x5030
movq %rax, %r12
xorl %eax, %eax
callq 0x50a0
testl %eax, %eax
je 0x56d6
xorl %eax, %eax
callq 0x5090
testl %eax, %eax
sete %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x56d6
cmpq $0x0, 0x10(%r12)
je 0x56d6
leaq 0x5966(%rip), %rdi      # 0xb015
callq 0x5070
movq 0xa9bd(%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 0x56e8
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
xorl %eax, %eax
callq *0xa992(%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_O2/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 0x57f3
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 0x5834
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)
pushq $0x18
popq %rcx
cmpq $0x28, %rcx
ja 0x5839
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x5845
xorl %r12d, %r12d
jmp 0x5848
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %r12d
xorl %eax, %eax
callq 0xa200
xorl %eax, %eax
callq 0x5030
movq %rax, %r13
xorl %eax, %eax
callq 0x50a0
testl %eax, %eax
je 0x58b5
xorl %eax, %eax
callq 0x5090
testl %eax, %eax
sete %al
testq %r13, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x58b5
cmpq $0x0, 0x20(%r13)
je 0x58b5
leaq 0x5791(%rip), %rdi      # 0xb01c
callq 0x5070
movq 0xa7f9(%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 0x58ca
movl %r15d, %edi
movq %r14, %rsi
movl %ebx, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq *0xa7c8(%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_O2/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 0x5a81
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 0x5ac2
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)
pushq $0x18
popq %rcx
cmpq $0x28, %rcx
ja 0x5ac7
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x5ad3
xorl %r12d, %r12d
jmp 0x5ad6
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %r12d
xorl %eax, %eax
callq 0xa200
xorl %eax, %eax
callq 0x5030
movq %rax, %r13
xorl %eax, %eax
callq 0x50a0
testl %eax, %eax
je 0x5b43
xorl %eax, %eax
callq 0x5090
testl %eax, %eax
sete %al
testq %r13, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x5b43
cmpq $0x0, 0x38(%r13)
je 0x5b43
leaq 0x5515(%rip), %rdi      # 0xb02e
callq 0x5070
movq 0xa583(%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 0x5b58
movl %r15d, %edi
movq %r14, %rsi
movl %ebx, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq *0xa552(%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_O2/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
pushq %rbx
pushq %rax
leaq 0x5121(%rip), %rsi      # 0xb052
pushq $-0x1
popq %rbx
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xa18d(%rip)      # 0x100d0
leaq 0x5116(%rip), %rsi      # 0xb060
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xa17f(%rip)      # 0x100d8
leaq 0x50f9(%rip), %rsi      # 0xb059
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xa171(%rip)      # 0x100e0
leaq 0x50f1(%rip), %rsi      # 0xb067
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xa163(%rip)      # 0x100e8
leaq 0x50e6(%rip), %rsi      # 0xb072
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xa155(%rip)      # 0x100f0
leaq 0x50ce(%rip), %rsi      # 0xb070
movq %rbx, %rdi
callq 0x5080
movq %rax, 0xa147(%rip)      # 0x100f8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x6151(%rip)      # 0x10358
jne 0xa238
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
callq 0x52a8
xorl %eax, %eax
callq 0x6810
xorl %eax, %eax
callq 0x5f24
xorl %eax, %eax
callq 0x8a68
xorl %eax, %eax
callq 0x8ec8
movb $0x1, 0x6121(%rip)      # 0x10358
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x121d
movq %rdi, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1216
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
callq 0x1030
jmp 0x1200
andq $0x0, 0x8(%rbx)
popq %rbx
retq
leaq 0xde0(%rip), %rdi       # 0x2004
leaq 0xde1(%rip), %rsi       # 0x200c
leaq 0xdf6(%rip), %rcx       # 0x2028
pushq $0x30
popq %rdx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x1080
testq %rax, %rax
je 0x124d
popq %rcx
retq
leaq 0xde6(%rip), %rdi       # 0x203a
callq 0x11ac
// File: /workspace/github_c_makefile_star2_O2/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 0x12e1
movq (%rdi), %r14
testq %r14, %r14
je 0x12c4
cmpq $0x0, 0x8(%rdi)
je 0x12c4
leaq 0xdd8(%rip), %rbx       # 0x2084
testq %r14, %r14
je 0x12d2
movl (%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1060
movq 0x8(%r14), %r14
jmp 0x12ac
leaq 0xda9(%rip), %rdi       # 0x2074
xorl %eax, %eax
callq 0x1060
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
leaq 0xd1c(%rip), %rdi       # 0x2004
leaq 0xd1d(%rip), %rsi       # 0x200c
leaq 0xd6c(%rip), %rcx       # 0x2062
pushq $0x4e
popq %rdx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/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 0x1349
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x10
popq %rdi
callq 0x1090
testq %rax, %rax
je 0x1366
movl %ebp, (%rax)
andq $0x0, 0x8(%rax)
cmpq $0x0, (%rbx)
je 0x1338
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x1338
addq $0x8, %rbx
movq %rax, 0x8(%rcx)
jmp 0x133f
movq %rax, (%rbx)
addq $0x8, %rbx
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xcb4(%rip), %rdi       # 0x2004
leaq 0xcb5(%rip), %rsi       # 0x200c
leaq 0xd2a(%rip), %rcx       # 0x2088
pushq $0x5f
popq %rdx
callq 0x1070
leaq 0xd86(%rip), %rdi       # 0x20f3
callq 0x11ac
// File: /workspace/github_c_makefile_star2_O2/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 0x139e
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1392
cmpq $0x0, 0x8(%rdi)
je 0x1392
movl (%rcx), %eax
movq 0x8(%rcx), %rcx
movq %rcx, (%rdi)
popq %rcx
retq
leaq 0xd1b(%rip), %rdi       # 0x20b4
callq 0x11ac
leaq 0xc5f(%rip), %rdi       # 0x2004
leaq 0xc60(%rip), %rsi       # 0x200c
leaq 0xcee(%rip), %rcx       # 0x20a1
pushq $0x6e
popq %rdx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/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 0x13e0
movq (%rdi), %rax
testq %rax, %rax
je 0x13d4
cmpq $0x0, 0x8(%rdi)
je 0x13d4
movl (%rax), %eax
popq %rcx
retq
leaq 0xcfb(%rip), %rdi       # 0x20d6
callq 0x11ac
leaq 0xc1d(%rip), %rdi       # 0x2004
leaq 0xc1e(%rip), %rsi       # 0x200c
leaq 0xcd0(%rip), %rcx       # 0x20c5
pushq $0x79
popq %rdx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/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 0xd0d(%rip), %rdi       # 0x2114
callq 0x1050
xorl %ebp, %ebp
callq 0x123a
movq %rax, %rbx
cmpl $0xa, %ebp
je 0x1431
movl %ebp, %edi
movq %rbx, %rsi
callq 0x12fe
movq %rbx, %rdi
callq 0x128d
incl %ebp
jmp 0x1416
leaq 0xcf9(%rip), %rdi       # 0x2131
callq 0x1050
pushq $0x8
popq %rbp
subl $0x1, %ebp
jb 0x1457
movq %rbx, %rdi
callq 0x1372
movq %rbx, %rdi
callq 0x128d
jmp 0x1440
leaq 0xcf0(%rip), %rdi       # 0x214e
callq 0x1050
xorl %ebp, %ebp
cmpl $-0x7, %ebp
je 0x1480
movl %ebp, %edi
movq %rbx, %rsi
callq 0x12fe
movq %rbx, %rdi
callq 0x128d
decl %ebp
jmp 0x1465
leaq 0xce4(%rip), %rdi       # 0x216b
callq 0x1050
pushq $0x6
popq %rbp
subl $0x1, %ebp
jb 0x14a6
movq %rbx, %rdi
callq 0x1372
movq %rbx, %rdi
callq 0x128d
jmp 0x148f
leaq 0xcdb(%rip), %rdi       # 0x2188
callq 0x1050
movq %rbx, %rdi
callq 0x11f7
movq %rbx, %rdi
callq 0x128d
leaq 0xc1c(%rip), %rdi       # 0x20e5
xorl %eax, %eax
callq 0x1060
xorl %edi, %edi
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x11f1
cmpl $0x1, %ebp
jne 0x1218
cmpb $0xf, (%r14)
je 0x11fe
jmp 0x1218
cmpb $0xf, (%r14)
jne 0x1218
cmpb $0xf, 0x1(%r14)
jne 0x1218
leaq 0x2e74(%rip), %rdi      # 0x4079
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rcx
callq 0x10c0
pushq $0x1
popq %rax
jmp 0x1262
leaq 0x4(%rsp), %r15
movl %ebp, (%r15)
pushq $0x1
popq %r12
pushq $0x4
popq %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x10c0
incl %ebp
andl $-0x2, %ebp
movslq %ebp, %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x10c0
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x10c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
cmpb $0x0, (%rdi)
je 0x1236
movq %r15, %rdi
callq 0x1050
pushq $0x40
popq %rdi
callq 0x10b0
testq %rax, %rax
je 0x1289
movq %rax, %rbx
leaq 0xe47(%rip), %r14       # 0x2094
movq %r15, %rdi
movq %r14, %rsi
callq 0x10e0
xorl %r15d, %r15d
testq %rax, %rax
je 0x1273
movq %rax, (%rbx,%r15,8)
incq %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x10e0
jmp 0x125b
movl %r15d, %eax
andq $0x0, (%rbx,%rax,8)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xee3(%rip), %rdi       # 0x2173
callq 0x1040
pushq $0x1
popq %rdi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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 0x1347
movq %rax, %r14
leaq 0xd5c(%rip), %r15       # 0x2025
leaq -0x2c(%rbp), %r13
pushq $0x2
popq %r12
movq %r14, %rdi
callq 0x10a0
testq %rax, %rax
je 0x1355
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)
andq $0x0, -0x40(%rbp)
callq 0x1110
testl %eax, %eax
js 0x1319
je 0x1327
movl %eax, %edi
movq %r13, %rsi
movl %r12d, %edx
callq 0x10c0
jmp 0x12d1
leaq 0xeaf(%rip), %rdi       # 0x21cf
callq 0x1040
jmp 0x12d1
movq %r15, %rdi
leaq -0x60(%rbp), %rsi
callq 0x1100
testl %eax, %eax
jns 0x12d1
leaq 0xcf6(%rip), %rdi       # 0x2034
xorl %eax, %eax
callq 0x1070
jmp 0x12d1
leaq 0xcb6(%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_O2/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 $0x18, %rsp
movl %edi, %ebp
movl $0x1, 0x4(%rsp)
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2550
testl %eax, %eax
js 0x26eb
movl %eax, %ebx
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
leaq 0x4(%rsp), %rcx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x20b0
testl %eax, %eax
js 0x26f4
leaq 0x8(%rsp), %rsi
andq $0x0, 0x8(%rsi)
movw $0x2, (%rsi)
rolw $0x8, %bp
movw %bp, 0x2(%rsi)
andl $0x0, 0x4(%rsi)
pushq $0x10
popq %rdx
movl %ebx, %edi
callq 0x2410
testl %eax, %eax
jne 0x26fd
movl %ebx, %edi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x2360
testl %eax, %eax
jns 0x270c
leaq 0x6e27(%rip), %rdi      # 0x9510
jmp 0x2704
leaq 0x69e6(%rip), %rdi      # 0x90d8
jmp 0x2704
leaq 0x699c(%rip), %rdi      # 0x9097
jmp 0x2704
leaq 0x69df(%rip), %rdi      # 0x90e3
callq 0x2460
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movl %edi, %ebp
movl $0x2, 0x8(%rsp)
pushq $0xa
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2550
testl %eax, %eax
js 0x27cc
movl %eax, %ebx
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
leaq 0x8(%rsp), %rcx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x20b0
testl %eax, %eax
js 0x27c3
pushq $0x29
popq %rsi
pushq $0x1a
popq %rdx
leaq 0x8(%rsp), %rcx
pushq $0x4
popq %r8
movl %ebx, %edi
callq 0x20b0
testl %eax, %eax
js 0x27c3
xorps %xmm0, %xmm0
leaq 0xc(%rsp), %rsi
andq $0x0, 0x14(%rsi)
movups %xmm0, 0x4(%rsi)
movw $0xa, (%rsi)
rolw $0x8, %bp
movw %bp, 0x2(%rsi)
movq 0x9833(%rip), %rax      # 0xbfc8
movups (%rax), %xmm0
movups %xmm0, 0x8(%rsi)
pushq $0x1c
popq %rdx
movl %ebx, %edi
callq 0x2410
testl %eax, %eax
jne 0x27d5
movl %ebx, %edi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x2360
testl %eax, %eax
jns 0x27e4
leaq 0x6d4f(%rip), %rdi      # 0x9510
jmp 0x27dc
leaq 0x68cd(%rip), %rdi      # 0x9097
jmp 0x27dc
leaq 0x6905(%rip), %rdi      # 0x90d8
jmp 0x27dc
leaq 0x6907(%rip), %rdi      # 0x90e3
callq 0x2460
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movl $0x10, 0x8(%rsp)
xorl %r14d, %r14d
leaq 0x9c1a(%rip), %rbx      # 0xc420
cmpq $0x9f5f, %r14           # imm = 0x9F5F
jg 0x2884
cmpl $0x0, 0x10(%r14,%rbx)
js 0x281d
addq $0x50, %r14
jmp 0x2806
cmpq $0x9f38, %r14           # imm = 0x9F38
jg 0x2884
andl $0x0, 0x48(%r14,%rbx)
andl $0x0, 0x20(%r14,%rbx)
movl 0x13b48(%rip), %edi     # 0x16380
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x2470
movl %eax, 0x10(%r14,%rbx)
testl %eax, %eax
js 0x2884
addq %r14, %rbx
pushq $0x4
popq %rsi
movl %eax, %edi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x20d0
leaq 0xc(%rsp), %rcx
movl $0x80000001, (%rcx)     # imm = 0x80000001
movq %rbx, 0x4(%rcx)
movl 0x13b0b(%rip), %edi     # 0x16384
movl 0x10(%rbx), %edx
pushq $0x1
popq %rsi
callq 0x2220
addq $0x28, %rsp
popq %rbx
popq %r14
retq