LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mohuangrui[P]ArtraCFD/postprocess.c
// Function: Postprocess
int Postprocess(Time *time, Space *space, Model *model)
{
    ShowInfo("Postprocessing...\n");
    ShowInfo("  releasing memory...\n");
    ReleaseProgramMemory(time, space, model);
    ShowInfo("  computing finished, successfully exit.\n");
    ShowInfo("Session");
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa7c4(%rip), %rdi      # 0x20b33
xorl %eax, %eax
callq 0x9051
leaq 0xa7c9(%rip), %rdi      # 0x20b46
xorl %eax, %eax
callq 0x9051
movslq 0xc(%r15), %r12
cmpl 0x8(%r15), %r12d
jge 0x163ef
imulq $0x238, %r12, %r13      # imm = 0x238
addq $0x228, %r13            # imm = 0x228
movq 0x18(%r15), %rbp
movq -0x28(%rbp,%r13), %rdi
callq 0x9146
movq -0x20(%rbp,%r13), %rdi
callq 0x9146
movq -0x18(%rbp,%r13), %rdi
callq 0x9146
movq -0x10(%rbp,%r13), %rdi
callq 0x9146
movq -0x8(%rbp,%r13), %rdi
callq 0x9146
movq (%rbp,%r13), %rdi
callq 0x9146
incq %r12
movslq 0x8(%r15), %rax
addq $0x238, %r13            # imm = 0x238
cmpq %rax, %r12
jl 0x1639c
movq 0x18(%r15), %rdi
callq 0x9146
movq 0x20(%r15), %rdi
callq 0x9146
movq 0x3b8(%r15), %rdi
callq 0x9146
movq 0x3c0(%r15), %rdi
callq 0x9146
movq 0x3c8(%r15), %rdi
callq 0x9146
movq 0x3d8(%r15), %rdi
callq 0x9146
movq 0x3e0(%r15), %rdi
callq 0x9146
movq 0x3e8(%r15), %rdi
callq 0x9146
movq (%r15), %rdi
callq 0x9146
movq 0x60(%r14), %rdi
callq 0x9146
movq 0x58(%r14), %rdi
callq 0x9146
movq 0x90(%rbx), %rdi
callq 0x9146
leaq 0xa6e7(%rip), %rdi      # 0x20b5d
xorl %eax, %eax
callq 0x9051
leaq 0x3ea1(%rip), %rdi      # 0x1a325
xorl %eax, %eax
callq 0x9051
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_O1/mohuangrui[P]ArtraCFD/preprocess.c
// Function: Preprocess
int Preprocess(Time *time, Space *space, Model *model)
{
    ShowInfo("Session");
    ShowInfo("Preprocessing...\n");
    ShowInfo("  loading case data...\n");
    LoadCaseData(time, space, model);
    ShowInfo("  computing parameters...\n");
    ComputeParameters(time, space, model);
    ShowInfo("  partitioning domain...\n");
    PartitionDomain(space);
    ShowInfo("  allocating memory...\n");
    AllocateProgramMemory(space, model);
    ShowInfo("Session");
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3e74(%rip), %rdi      # 0x1a325
xorl %eax, %eax
callq 0x9051
leaq 0xa6c8(%rip), %rdi      # 0x20b87
xorl %eax, %eax
callq 0x9051
leaq 0xa6cc(%rip), %rdi      # 0x20b99
xorl %eax, %eax
callq 0x9051
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x56a8
leaq 0xa6c8(%rip), %rdi      # 0x20bb1
xorl %eax, %eax
callq 0x9051
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8afc
leaq 0xa6c7(%rip), %rdi      # 0x20bcc
xorl %eax, %eax
callq 0x9051
movq %r14, %rdi
callq 0xe500
leaq 0xa6cb(%rip), %rdi      # 0x20be6
xorl %eax, %eax
callq 0x9051
movslq 0x34(%r14), %rax
movslq 0x38(%r14), %rcx
imulq %rax, %rcx
movslq 0x3c(%r14), %rax
imulq %rcx, %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rdi
callq 0x911c
movq %rax, (%r14)
movslq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x16573
shlq $0x4, %rdi
callq 0x911c
movq %rax, 0x20(%r14)
movslq 0x8(%r14), %rax
imulq $0x238, %rax, %rdi      # imm = 0x238
callq 0x911c
movq %rax, 0x18(%r14)
movl $0x8, %edi
callq 0x911c
movq %rax, 0x90(%rbx)
leaq 0x3d9a(%rip), %rdi      # 0x1a325
xorl %eax, %eax
callq 0x9051
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mohuangrui[P]ArtraCFD/source_term.c
// Function: ComputePhi
void ComputePhi(const int tn, const int k, const int j, const int i,
        const int partn[restrict], const Node *const node,
        const Model *model, Real Phi[restrict])
{
    if (0 == model->sState) {
        memset(Phi, 0, DIMU * sizeof(*Phi));
        return;
    }
    const int idx = IndexNode(k, j, i, partn[Y], partn[X]);
    const Real *restrict U = node[idx].U[tn];
    const RealVec V = {U[1] / U[0], U[2] / U[0], U[3] / U[0]};
    const RealVec fb = {U[0] * model->g[X], U[0] * model->g[Y], U[0] * model->g[Z]};
    Phi[0] = 0.0;
    Phi[1] = fb[X];
    Phi[2] = fb[Y];
    Phi[3] = fb[Z];
    Phi[4] = Dot(fb, V);
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq 0x68(%rsp), %r14
movq 0x60(%rsp), %r15
cmpl $0x0, 0x2c(%r15)
je 0x18939
movq %r9, %rbx
movl %edi, %ebp
movl (%r8), %eax
movl 0x4(%r8), %r8d
movl %esi, %edi
movl %edx, %esi
movl %ecx, %edx
movl %r8d, %ecx
movl %eax, %r8d
callq 0x7ea3
cltq
movslq %ebp, %rcx
movq %rax, %rdx
shlq $0x7, %rdx
leaq (%rdx,%rax,8), %rax
addq %rax, %rbx
leaq (%rcx,%rcx,4), %rax
movsd 0x10(%rbx,%rax,8), %xmm0
movsd 0x18(%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
leaq 0x20(%rsp), %rsi
movsd %xmm1, (%rsi)
movsd 0x20(%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsi)
movsd 0x28(%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsi)
movsd 0x78(%r15), %xmm1
mulsd %xmm0, %xmm1
movq %rsp, %rdi
movsd %xmm1, (%rdi)
movsd 0x80(%r15), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rdi)
mulsd 0x88(%r15), %xmm0
movsd %xmm0, 0x10(%rdi)
movq $0x0, (%r14)
movsd %xmm1, 0x8(%r14)
movsd %xmm2, 0x10(%r14)
movsd %xmm0, 0x18(%r14)
callq 0x7f86
movsd %xmm0, 0x20(%r14)
jmp 0x18950
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%r14)
movupd %xmm0, (%r14)
movq $0x0, 0x20(%r14)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mohuangrui[P]ArtraCFD/timer.c
// Function: TockTime
double TockTime(const Timer *tm)
{
    Timer tc; /* store current time at now */
    gettimeofday(&tc, NULL);
    return (double)(tc.tv_sec - tm->tv_sec) +
        (double)(tc.tv_usec - tm->tv_usec) / 1000000.0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x20c0
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq (%rbx), %rax
cvtsi2sd %rax, %xmm1
subq 0x8(%rbx), %rcx
cvtsi2sd %rcx, %xmm0
divsd 0x80a4(%rip), %xmm0     # 0x21020
addsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mohuangrui[P]ArtraCFD/weno3.c
// Function: WENO3
void WENO3(Real F[restrict][DIMU], Real Fhat[restrict])
{
    Real omega[R]; /* weights */
    Real q[R]; /* q vectors */
    Real IS[R]; /* smoothness measurements */
    Real alpha[R];
    const Real C[R] = {1.0 / 3.0, 2.0 / 3.0};
    const Real epsilon = 1.0e-6;
    for (int r = 0; r < DIMU; ++r) {
        IS[0] = Square(F[CN][r] - F[CN-1][r]);
        IS[1] = Square(F[CN+1][r] - F[CN][r]);
        alpha[0] = C[0] / Square(epsilon + IS[0]);
        alpha[1] = C[1] / Square(epsilon + IS[1]);
        omega[0] = alpha[0] / (alpha[0] + alpha[1]);
        omega[1] = alpha[1] / (alpha[0] + alpha[1]);
        q[0] = (1.0 / 2.0) * (-F[CN-1][r] + 3.0 * F[CN][r]);
        q[1] = (1.0 / 2.0) * (F[CN][r] + F[CN+1][r]);
        Fhat[r] = omega[0] * q[0] + omega[1] * q[1];
    }
    return;
}

// Assembly:
xorl %eax, %eax
movsd 0x4666(%rip), %xmm0     # 0x1d5f8
movsd 0x60e6(%rip), %xmm1     # 0x1f080
movsd 0x60e6(%rip), %xmm2     # 0x1f088
movsd 0x807e(%rip), %xmm3     # 0x21028
movsd 0x460e(%rip), %xmm4     # 0x1d5c0
movsd (%rdi,%rax,8), %xmm6
movsd 0x28(%rdi,%rax,8), %xmm5
movapd %xmm5, %xmm7
subsd %xmm6, %xmm7
mulsd %xmm7, %xmm7
movsd 0x50(%rdi,%rax,8), %xmm8
movapd %xmm8, %xmm9
subsd %xmm5, %xmm9
mulsd %xmm9, %xmm9
addsd %xmm0, %xmm7
mulsd %xmm7, %xmm7
movapd %xmm1, %xmm10
divsd %xmm7, %xmm10
addsd %xmm0, %xmm9
mulsd %xmm9, %xmm9
movapd %xmm2, %xmm7
divsd %xmm9, %xmm7
movapd %xmm10, %xmm9
addsd %xmm7, %xmm9
divsd %xmm9, %xmm10
divsd %xmm9, %xmm7
movapd %xmm5, %xmm9
mulsd %xmm3, %xmm9
subsd %xmm6, %xmm9
mulsd %xmm4, %xmm9
mulsd %xmm10, %xmm9
addsd %xmm8, %xmm5
mulsd %xmm4, %xmm5
mulsd %xmm7, %xmm5
addsd %xmm9, %xmm5
movsd %xmm5, (%rsi,%rax,8)
incq %rax
cmpq $0x5, %rax
jne 0x18fb2
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/monoclock/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct timeval tv_wall, tv_cpu;
	double timer_resolution;

	WARNP_INIT;

	(void)argc; /* UNUSED */
	(void)argv; /* UNUSED */

	/* Get time and process CPU time. */
	if (monoclock_get(&tv_wall)) {
		warnp("monoclock_get()");
		goto err0;
	}
	if (monoclock_get_cputime(&tv_cpu)) {
		warnp("monoclock_get_cputime()");
		goto err0;
	}

	/* Get timer resolution. */
	if (monoclock_getres(&timer_resolution)) {
		warnp("monoclock_getres()");
		goto err0;
	}

	/* Display times. */
	printf("monoclock_get():\t\t%ju seconds,\t%06jd microseconds\n",
	    (uintmax_t)tv_wall.tv_sec, (intmax_t)tv_wall.tv_usec);
	printf("monoclock_get_cputime():\t%ju seconds,\t%06jd microseconds\n",
	    (uintmax_t)tv_cpu.tv_sec, (intmax_t)tv_cpu.tv_usec);
	printf("monoclock_getres():\t\t%g\n", timer_resolution);

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x138e
callq 0x16b8
leaq 0x20(%rsp), %rdi
callq 0x147c
testl %eax, %eax
jne 0x1403
leaq 0x10(%rsp), %rdi
callq 0x1563
testl %eax, %eax
jne 0x1416
leaq 0x8(%rsp), %rdi
callq 0x1605
testl %eax, %eax
jne 0x1435
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0xc76(%rip), %rdi       # 0x203f
xorl %eax, %eax
callq 0x1090
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0xc91(%rip), %rdi       # 0x2072
xorl %eax, %eax
callq 0x1090
movsd 0x8(%rsp), %xmm0
leaq 0xcb7(%rip), %rdi       # 0x20ac
movb $0x1, %al
callq 0x1090
xorl %edi, %edi
callq 0x1120
callq 0x1060
cmpl $0x0, (%rax)
jne 0x1429
leaq 0xbf0(%rip), %rdi       # 0x2004
jmp 0x1446
callq 0x1060
cmpl $0x0, (%rax)
jne 0x144f
leaq 0xbed(%rip), %rdi       # 0x2014
jmp 0x1446
movq %rax, %rbx
leaq 0xbd1(%rip), %rdi       # 0x2004
jmp 0x1465
callq 0x1060
cmpl $0x0, (%rax)
jne 0x145b
leaq 0xbe6(%rip), %rdi       # 0x202c
xorl %eax, %eax
callq 0x1857
jmp 0x1472
movq %rax, %rbx
leaq 0xbbb(%rip), %rdi       # 0x2014
jmp 0x1465
movq %rax, %rbx
leaq 0xbc7(%rip), %rdi       # 0x202c
xorl %eax, %eax
callq 0x1738
movl $0x0, (%rbx)
movl $0x1, %edi
callq 0x1120
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_06/scanf.c
// Function: main
int main(void)
{
	char *str; 
	int ret; 

	/* Print a prompt */
	printf("type a string> ");

	/* Read input data accepting strings holding
	 * character between a to z only
	 */
	errno = 0; 
	ret = scanf("%m[a-z]", &str); 
	if (ret != 1) { 
		if (errno != 0) { 
			perror("scanf"); 
			return -1;
		} else { 
			fprintf(stderr,
				"no matching characters\n"); 
			return 0;
		}
	} 

	/* Print read data */
	printf("read: %s\n", str); 
	free(str); 

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xe3d(%rip), %rdi       # 0x2004
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1050
callq 0x1040
movq %rax, %r14
movl $0x0, (%rax)
leaq 0xe2f(%rip), %rdi       # 0x2014
movq %rsp, %rsi
xorl %eax, %eax
callq 0x1070
cmpl $0x1, %eax
jne 0x1219
movq (%rsp), %rsi
leaq 0xe3b(%rip), %rdi       # 0x203a
xorl %eax, %eax
callq 0x1050
movq (%rsp), %rdi
callq 0x1030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x0, (%r14)
jne 0x1228
callq 0x10a0
xorl %ebx, %ebx
jmp 0x120f
leaq 0xded(%rip), %rdi       # 0x201c
callq 0x1060
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x120f
// File: /workspace/github_c_makefile_star2_O1/yurrriq[P]knrc/src/trimlines.c
// Function: trim_line
size_t trim_line(char line[], size_t len)
{
    while (line[--len] == ' ' || line[len] == '\t' || line[len] == '\n') {
        if (len == 0) {
            return 0;
        } else {
            line[len] = '\0';
        }
    }

    line[++len] = '\n';

    return len;
}

// Assembly:
movq %rsi, %rax
movabsq $0x100000600, %rcx      # imm = 0x100000600
movzbl -0x1(%rdi,%rax), %edx
cmpq $0x20, %rdx
ja 0x117d
btq %rdx, %rcx
jae 0x117d
cmpq $0x1, %rax
je 0x117a
movb $0x0, -0x1(%rdi,%rax)
decq %rax
jmp 0x1159
xorl %eax, %eax
retq
movb $0xa, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/yurrriq[P]knrc/src/trimlines.c
// Function: main
int main()
{
    size_t len;
    char line[MAXLINE];

    while ((len = get_line(line, MAXLINE)) > 0)
        if (trim_line(line, len) > 0)
            fputs(line, stdout);

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsp, %rdi
movl $0x78, %esi
callq 0x120c
testl %eax, %eax
je 0x11fb
movq 0x2e3a(%rip), %r14      # 0x3fe0
movq %rsp, %rbx
movabsq $0x100000600, %r15      # imm = 0x100000600
cltq
decq %rax
movzbl (%rsp,%rax), %ecx
cmpq $0x20, %rcx
ja 0x11da
btq %rcx, %r15
jae 0x11da
movq %rax, %rcx
subq $0x1, %rcx
jb 0x11ea
movb $0x0, (%rsp,%rax)
movq %rcx, %rax
jmp 0x11b8
movb $0xa, 0x1(%rsp,%rax)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
movl $0x78, %esi
callq 0x120c
testl %eax, %eax
jne 0x11b3
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/mock-test.c
// Function: print_response
void print_response(const char *osc, void *vv)
{
    char type = rtosc_type(osc, 0);
    //printf("[callback] got a message '%s':%c data=%p...\n", osc, type, v);

    rtosc_arg_t arg = rtosc_argument(osc, 0);

    void *v = *(void**)vv;

    if(type == 'i')
        *(int*)v = arg.i;
    else if(type == 'T')
        *(bool*)v = true;
    else if(type == 'F')
        *(bool*)v = false;
    else if(type == 'f')
        for(rtosc_arg_itr_t itr = rtosc_itr_begin(osc); !rtosc_itr_end(itr);)
            printf("# vec arg %f\n", rtosc_itr_next(&itr).val.f);

    //if(type == 'i')
    //    printf("[callback] value = %d\n", arg.i);
    //else if(type == 'f')
    //    printf("[callback] value = %f\n", arg.f);
    //else if(type == 'T')
    //    printf("[callback] value = true\n");
    //else if(type == 'F')
    //    printf("[callback] value = false\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x6799
movl %eax, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x723b
movq (%r14), %rcx
movzbl %r15b, %edx
cmpl $0x65, %edx
jg 0x84d5
cmpl $0x46, %edx
je 0x84e3
cmpl $0x54, %edx
jne 0x8544
movb $0x1, (%rcx)
jmp 0x8544
cmpl $0x66, %edx
je 0x84e8
cmpl $0x69, %edx
jne 0x8544
movl %eax, (%rcx)
jmp 0x8544
movb $0x0, (%rcx)
jmp 0x8544
movq %rbx, %rdi
callq 0x6f79
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, %rdi
movq %rdx, %rsi
callq 0x7221
testl %eax, %eax
jne 0x8544
leaq -0x40(%rbp), %rbx
leaq -0x28(%rbp), %r14
leaq 0x1987(%rip), %r15      # 0x9e9d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6fe0
xorps %xmm0, %xmm0
cvtss2sd -0x38(%rbp), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x20f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7221
testl %eax, %eax
je 0x8516
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/mock-test.c
// Function: test_pvolume
void test_pvolume(schema_t schema, bridge_t *bridge)
{
    //Add a view to /part0/Pvolume
    printf("#Grabbing Pvolume Handle On Schema...\n");
    uri_t uri = "/part0/Pvolume";
    schema_handle_t handle = sm_get(schema, uri);

    assert_true(sm_valid(handle), "A valid handle is obtained", __LINE__);

    //printf("Obtained Handle for <%s>...\n", uri);
    assert_str_eq("Pvolume", sm_get_name(handle),
            "The name of the parameter is available", __LINE__);
    assert_str_eq("Vol", sm_get_short(handle),
            "The abbreviated name is available", __LINE__);
    assert_str_eq("Part Volume", sm_get_tooltip(handle),
            "The tooltip is available", __LINE__);
    assert_str_eq("", sm_get_units(handle),
            "Optional units have some return value", __LINE__);

    void **v1_ = malloc(sizeof(void*));
    void **v2_ = malloc(sizeof(void*));
    *v1_ = &v1;
    *v2_ = &v2;

    br_add_callback(bridge, uri, print_response, v1_);
    br_add_callback(bridge, uri, print_response, v2_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x1c37(%rip), %rdi      # 0xa1a4
callq 0x2080
movq 0x20(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps 0x10(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x189c(%rip), %r14      # 0x9e26
leaq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x644c
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x670d
leaq 0x18f8(%rip), %rsi      # 0x9eab
movl %eax, %edi
movl $0x61, %edx
callq 0x7d28
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x66a2
leaq 0x1854(%rip), %rdi      # 0x9e2d
leaq 0x18e6(%rip), %rdx      # 0x9ec6
movq %rax, %rsi
movl $0x65, %ecx
callq 0x7d9d
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x66ba
leaq 0x18e6(%rip), %rdi      # 0x9eed
leaq 0x18e3(%rip), %rdx      # 0x9ef1
movq %rax, %rsi
movl $0x67, %ecx
callq 0x7d9d
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x66d2
leaq 0x18de(%rip), %rdi      # 0x9f13
leaq 0x18e3(%rip), %rdx      # 0x9f1f
movq %rax, %rsi
movl $0x69, %ecx
callq 0x7d9d
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x66ea
leaq 0xd49(%rip), %rdi       # 0x93ac
leaq 0x18ce(%rip), %rdx      # 0x9f38
movq %rax, %rsi
movl $0x6b, %ecx
callq 0x7d9d
movl $0x8, %edi
callq 0x21f0
movq %rax, %r15
movl $0x8, %edi
callq 0x21f0
movq %rax, %r12
leaq 0x4af8(%rip), %rax      # 0xd190
movq %rax, (%r15)
leaq 0x4af2(%rip), %rax      # 0xd194
movq %rax, (%r12)
leaq -0x21a(%rip), %r13      # 0x8493
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x34ce
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x34ce
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/mock-test.c
// Function: test_enable
void test_enable(schema_t schema, bridge_t *bridge)
{
    printf("#Grabbing Penabled Handle On Schema...\n");
    uri_t uri = "/part0/Penabled";
    schema_handle_t handle = sm_get(schema, uri);

    assert_true(sm_valid(handle), "A valid handle is obtained", __LINE__);
    assert_str_eq("Penabled", sm_get_name(handle),
            "The name of the parameter is available", __LINE__);
    assert_str_eq("enable", sm_get_short(handle),
            "The abbreviated name is available", __LINE__);
    assert_str_eq("Part enable", sm_get_tooltip(handle),
            "The tooltip is available", __LINE__);
    assert_str_eq("", sm_get_units(handle),
            "Optional units have some return value", __LINE__);

    void **v3_ = malloc(sizeof(void*));
    *v3_ = &v3;

    br_add_callback(bridge, uri, print_response, v3_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x1acf(%rip), %rdi      # 0xa1ca
callq 0x2080
movq 0x20(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps 0x10(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x171d(%rip), %r14      # 0x9e35
leaq -0x70(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x644c
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x670d
leaq 0x176a(%rip), %rsi      # 0x9eab
movl %eax, %edi
movl $0x7c, %edx
callq 0x7d28
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x66a2
leaq 0x16d5(%rip), %rdi      # 0x9e3c
leaq 0x1758(%rip), %rdx      # 0x9ec6
movq %rax, %rsi
movl $0x7e, %ecx
callq 0x7d9d
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x66ba
leaq 0x17ce(%rip), %rdi      # 0x9f63
leaq 0x1755(%rip), %rdx      # 0x9ef1
movq %rax, %rsi
movl $0x80, %ecx
callq 0x7d9d
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x66d2
leaq 0x179b(%rip), %rdi      # 0x9f5e
leaq 0x1755(%rip), %rdx      # 0x9f1f
movq %rax, %rsi
movl $0x82, %ecx
callq 0x7d9d
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x66ea
leaq 0xbbb(%rip), %rdi       # 0x93ac
leaq 0x1740(%rip), %rdx      # 0x9f38
movq %rax, %rsi
movl $0x84, %ecx
callq 0x7d9d
movl $0x8, %edi
callq 0x21f0
leaq 0x4fc2(%rip), %rcx      # 0xd7d8
movq %rcx, (%rax)
leaq -0x38d(%rip), %rdx      # 0x8493
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x34ce
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/mock-test.c
// Function: test_options
void test_options(schema_t schema, bridge_t *bridge)
{
    (void) bridge;
    printf("#Grabbing filter type...\n"); 
    uri_t uri = "/part3/kit8/adpars/VoicePar3/FMSmp/Pfiltertype";
    schema_handle_t handle = sm_get(schema, uri);

    assert_true(sm_valid(handle), "A valid handle is obtained", __LINE__);
    assert_int_eq(14, handle.opts->num_opts, "All Options are recorded", __LINE__);
    assert_int_eq(7, handle.opts->ids[7], "The Option Id is recorded", __LINE__);
    assert_str_eq("hp2", handle.opts->labels[7], "The Option label is recorded", __LINE__);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xb8, %rsp
leaq 0x19a2(%rip), %rdi      # 0xa1f1
callq 0x2080
movq 0x20(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps 0x10(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x16fe(%rip), %rsi      # 0x9f6a
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x644c
movl $0xb, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x670d
leaq 0x1619(%rip), %rsi      # 0x9eab
movl %eax, %edi
movl $0x93, %edx
callq 0x7d28
movq 0x8(%rbx), %rax
movl 0x10(%rax), %esi
leaq 0x16ed(%rip), %rdx      # 0x9f99
movl $0xe, %edi
movl $0x94, %ecx
callq 0x7c34
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl 0x1c(%rax), %esi
leaq 0x16e6(%rip), %rdx      # 0x9fb2
movl $0x7, %edi
movl $0x95, %ecx
callq 0x7c34
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rsi
leaq 0x16de(%rip), %rdi      # 0x9fcc
leaq 0x16db(%rip), %rdx      # 0x9fd0
movl $0x96, %ecx
callq 0x7d9d
addq $0xb8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/mock-test.c
// Function: test_vector_functionality
void test_vector_functionality(bridge_t *br)
{
    char buffer[1024];
    rtosc_message(buffer, sizeof(buffer), "/vector/test", "ffff", 1.1, 2.2, 3.3, 4.4);
    br_recv(br, buffer);
    br_recv(br, buffer);
    void **v1_ = malloc(sizeof(void*));
    *v1_ = &v1;

    br_add_callback(br, "/vector/test", print_response, v1_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
leaq 0x14f4(%rip), %r14      # 0x9e47
leaq 0x1693(%rip), %rcx      # 0x9fed
leaq -0x420(%rbp), %r15
movsd 0x12f7(%rip), %xmm0     # 0x9c60
movsd 0x12f7(%rip), %xmm1     # 0x9c68
movsd 0x12f7(%rip), %xmm2     # 0x9c70
movsd 0x12f7(%rip), %xmm3     # 0x9c78
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movq %r14, %rdx
movb $0x4, %al
callq 0x67f8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24de
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24de
movl $0x8, %edi
callq 0x21f0
leaq 0x47d6(%rip), %rcx      # 0xd190
movq %rcx, (%rax)
leaq -0x531(%rip), %rdx      # 0x8493
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x34ce
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.8/cleanup.c
// Function: do_some_work
void do_some_work ()
{
  /* Allocate a temporary buffer.  */
  void* temp_buffer = allocate_buffer (1024);
  /* Register a cleanup handler for this buffer, to deallocate it in
     case the thread exits or is cancelled.  */
  pthread_cleanup_push (deallocate_buffer, temp_buffer);

  /* Do some work here that might call pthread_exit or might be
     cancelled...  */

  /* Unregister the cleanup handler.  Since we pass a non-zero value,
     this actually performs the cleanup by calling
     deallocate_buffer.  */
  pthread_cleanup_pop (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl $0x400, %edi            # imm = 0x400
callq 0x1050
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0x1080
testl %eax, %eax
jne 0x11ec
leaq -0x80(%rbp), %r14
movq %r14, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1030
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x1196
leaq -0x80(%rbp), %rdi
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/amanelis[P]uici/client_udp.c
// Function: main
int main(int argc, char *argv[]) {
   ssize_t byteswritten;
   char request[BUFSIZE];
   int requestfd;  
   int rlen;
   u_port_t serverport;
 
   if (argc != 3) {
      fprintf(stderr, "Usage: %s servername serverport\n", argv[0]);
      return 1;
   }
   serverport = (u_port_t) atoi(argv[2]);
   if ((requestfd = u_openudp(0)) == -1) {     /* create unbound UDP endpoint */
      perror("Failed to create UDP endpoint");
      return 1;
   }
   sprintf(request, "[%ld]\n", (long)getpid());           /* create a request */
   rlen = strlen(request);
    /* use  simple-request protocol to send a request to (server, serverport) */
   byteswritten = u_sendtohost(requestfd, request, rlen, argv[1], serverport);
   if (byteswritten == -1)
      perror("Failed to send");
   if (r_close(requestfd) == -1 || byteswritten == -1)
      return 1;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rsi, %r14
cmpl $0x3, %edi
jne 0x13d5
movq 0x10(%r14), %rdi
callq 0x11a0
movl %eax, %r15d
xorl %edi, %edi
callq 0x1b84
cmpl $-0x1, %eax
je 0x13df
movl %eax, %ebx
callq 0x1070
movslq %eax, %rdx
leaq 0xcd0(%rip), %rsi       # 0x2043
leaq -0x420(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x11c0
movq %r12, %rdi
callq 0x1090
movslq %eax, %rdx
movq 0x8(%r14), %rcx
movzwl %r15w, %r8d
movl %ebx, %edi
movq %r12, %rsi
callq 0x1e28
movq %rax, %r14
cmpq $-0x1, %rax
je 0x13f2
cmpq $-0x1, %r14
sete %r14b
movl %ebx, %edi
callq 0x1400
cmpl $-0x1, %eax
sete %al
orb %r14b, %al
movzbl %al, %eax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x1210
jmp 0x13eb
leaq 0xc3f(%rip), %rdi       # 0x2025
callq 0x1190
movl $0x1, %eax
jmp 0x13c5
leaq 0xc51(%rip), %rdi       # 0x204a
callq 0x1190
jmp 0x13aa
// File: /workspace/github_c_makefile_star2_O1/X1319RAY[P]fileIO/fgetc.c
// Function: main
int main(int argc, char* argv[]){
	
	// コマンドライン引数のチェック
	if(argc != 2){
		fprintf(stderr, "引数の数が間違っています．\n");
		fprintf(stderr, "./fgetc input.txt\n");
		return 1;
	}
	
	// C言語のファイル入力のための準備
	FILE* fp; // FILE型構造体
	// 読み込みモードでファイルを開く
	fp = fopen(argv[1], "r"); // 失敗するとNULLを返す
	// ファイルを開くのに失敗したときの処理
	if(fp == NULL){
		fprintf(stderr, "Error: file not opened.\n");
		return 1;
	}
	
	// fgetc()で1文字ずつ読み込む
	int tmp; // fgetc()はint型の文字コードを返す
	int num = 0;
	int sum = 0;
	while((tmp = fgetc(fp)) != EOF){
		// ここでtmpを煮るなり焼くなりする
		printf("%c", (char)tmp); // そのまま出力
		
		// 数字ならnumに数として格納
		if(isdigit(tmp)){ // tmpが数字なら
			num = num * 10; // 位を1つ大きくする
			num += tmp - '0'; // 一の位に値を入れる
		}
		else{
			// 数字が終わった直後ならnumがsumに加算される
			// その後numを0にしているので直後以外はsumに0が加算される
			sum += num;
			num = 0;
		}
	}
	
	printf("\nsum: %d\n", sum);
	
	// ファイルを閉じる
	fclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x12cc
movq 0x8(%rsi), %rdi
leaq 0xe12(%rip), %rsi       # 0x2040
callq 0x1070
testq %rax, %rax
je 0x12d3
movq %rax, %rdi
movq %rax, -0x30(%rbp)
callq 0x1060
movl $0x0, %r15d
cmpl $-0x1, %eax
je 0x12a1
movl %eax, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %ebx, %ebx
movsbl %r12b, %edi
callq 0x1030
callq 0x1090
movq (%rax), %rax
movslq %r12d, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xb, %eax
leal (%rbx,%rbx,4), %eax
leal -0x30(%rcx,%rax,2), %r14d
cmovael %r13d, %r14d
cmovbl %r13d, %ebx
addl %ebx, %r15d
movq -0x30(%rbp), %rdi
callq 0x1060
movl %eax, %r12d
movl %r14d, %ebx
cmpl $-0x1, %eax
jne 0x125e
leaq 0xdb3(%rip), %rdi       # 0x205b
movl %r15d, %esi
xorl %eax, %eax
callq 0x1050
movq -0x30(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x10b0
jmp 0x12d8
callq 0x10ef
movl $0x1, %eax
jmp 0x12bd
// File: /workspace/github_c_makefile_star2_O1/c0stya[P]fslib/src/fsstat.c
// Function: main
int main(int argc, char * argv[]) {
    struct _fst * fst = fst_create(); 

    const char * ifilename = NULL; 
    FILE * fin = stdin;

    if (argc > 1)
        ifilename = argv[1];

    if (ifilename) {
        if (( fin = fopen(ifilename, "rb")) == NULL ) {
            fprintf(stderr, "Error opening file: %s", ifilename);
            exit(EXIT_FAILURE);
        }
    }

    fst_read(fst, fin);

    printf("states:\t\t%"PRIu32"\n", fst->n_states);
    printf("arcs:\t\t%"PRIu32"\n", fst_get_n_arcs(fst));
    printf("sorted input:\t%d\n", fst->flags & ISORT ? 1 : 0);
    printf("sorted output:\t%d\n", fst->flags & OSORT ? 1 : 0);
    printf("start state:\t%"PRIu32"\n", fst->start);

    fst_remove(fst);
    
    if (fin != stdout) {
        fclose(fin);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %r12d
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x20c4
movq %rax, %rbx
cmpl $0x2, %r12d
jl 0x523c
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x5260
leaq 0xe86(%rip), %rsi       # 0x60ce
movq %r15, %rdi
callq 0x1180
movq %rax, %r14
testq %rax, %rax
jne 0x526a
movq %r15, %rdi
callq 0x12bd
movq 0x3d71(%rip), %rax      # 0x8fd8
movq (%rax), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x237d
movl 0x4(%rbx), %esi
leaq 0x14f7(%rip), %rdi      # 0x6776
xorl %eax, %eax
callq 0x10b0
movq %rbx, %rdi
callq 0x25a6
leaq 0x14ee(%rip), %rdi      # 0x6783
movl %eax, %esi
xorl %eax, %eax
callq 0x10b0
movzbl 0xd(%rbx), %esi
andl $0x1, %esi
leaq 0x14e2(%rip), %rdi      # 0x678e
xorl %eax, %eax
callq 0x10b0
movzbl 0xd(%rbx), %esi
shrl %esi
andl $0x1, %esi
leaq 0x14dd(%rip), %rdi      # 0x67a0
xorl %eax, %eax
callq 0x10b0
movl (%rbx), %esi
leaq 0x14e0(%rip), %rdi      # 0x67b3
xorl %eax, %eax
callq 0x10b0
movq %rbx, %rdi
callq 0x21c2
movq 0x3ce7(%rip), %rax      # 0x8fd0
cmpq (%rax), %r14
je 0x52f6
movq %r14, %rdi
callq 0x1090
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/test-parse-reg.c
// Function: reg_expected
void reg_expected(sam_hdr_t *hdr, const char *reg, int flags,
                 char *reg_exp, int tid_exp, hts_pos_t beg_exp, hts_pos_t end_exp) {
    const char *reg_out;
    int tid_out = -1;
    hts_pos_t beg_out = -1, end_out = -1;

    reg_out = sam_parse_region(hdr, reg, &tid_out, &beg_out, &end_out, flags);

    if ((reg_out != NULL) != (reg_exp != NULL) ||
        (reg_out && reg_exp && strcmp(reg_out, reg_exp) != 0) ||
        (reg_exp && tid_out != tid_exp) ||
        (reg_exp && beg_out != beg_exp) ||
        (reg_exp && end_out != end_exp)) {
        fprintf(stderr, "Parsing \"%s\" expected return \"%s\", %d:%"PRIhts_pos"-%"PRIhts_pos", "
                "but got \"%s\", %d:%"PRIhts_pos"-%"PRIhts_pos"\n",
                reg,
                reg_exp?reg_exp:"(null)", tid_exp, beg_exp, end_exp,
                reg_out?reg_out:"(null)", tid_out, beg_out, end_out);
        exit(1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r9d
movq %rsi, %r15
movq 0x50(%rsp), %r13
leaq 0x4(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
movq $-0x1, %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %r8
movq %rax, (%r8)
callq 0x16b3a
movq %rax, %r12
testq %rax, %rax
setne %al
testq %r14, %r14
setne %cl
xorb %al, %cl
jne 0x63e9
testq %r14, %r14
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x63b7
movq %r12, %rdi
movq %r14, %rsi
callq 0x46c0
testl %eax, %eax
jne 0x63e9
testq %r14, %r14
je 0x63c2
cmpl %ebp, 0x4(%rsp)
jne 0x63e9
testq %r14, %r14
je 0x63ce
cmpq %rbx, 0x10(%rsp)
jne 0x63e9
testq %r14, %r14
je 0x63da
cmpq %r13, 0x8(%rsp)
jne 0x63e9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r14, %r14
leaq 0x8ac5a(%rip), %r10     # 0x9104d
cmoveq %r10, %r14
testq %r12, %r12
movq 0xabbdf(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
cmovneq %r12, %r10
movl 0x4(%rsp), %r11d
subq $0x8, %rsp
leaq 0x8abec(%rip), %rsi     # 0x91004
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
movq %rbx, %r9
xorl %eax, %eax
pushq 0x10(%rsp)
pushq 0x20(%rsp)
pushq %r11
pushq %r10
pushq %r13
callq 0x4700
addq $0x30, %rsp
movl $0x1, %edi
callq 0x45e0
// File: /workspace/github_c_makefile_star2_O1/CSerxzm[P]WindowstoLinuxInterface/src/REN.c
// Function: main
int main(int argc, char** argv){
    char lines[argc+1][255];
    predealLine(argc, argv, lines);
    if((strcmp("ren",lines[0])==0)||(strcmp("rename",lines[0])==0)){
        struct stat dir_stat;
        if((access(lines[1],F_OK)!=0)){
            perror("Don't exist DIR1\n");
            return 0;
        }
        else if(stat(lines[1], &dir_stat)<0){
            perror("Stat error!\n");
            return 0;
        }
        else if(rename(lines[1],lines[2])<0){
            perror("Rename error!\n");
        }
		else{
			printf("rename %s to %s \n",lines[1],lines[2]);
		}
    }
    else{
        perror("error after lines\n");
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leal 0x1(%rdi), %eax
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rax    # imm = 0x1FFFFFFFFF0
andq %rcx, %rax
movq %rsp, %rbx
subq %rax, %rbx
movq %rbx, %rsp
movq %rbx, %rdx
callq 0x11bc
leaq 0xd07(%rip), %rdi       # 0x2004
movq %rbx, %rsi
callq 0x1050
testl %eax, %eax
je 0x131c
leaq 0xcf8(%rip), %rdi       # 0x2008
movq %rbx, %rsi
callq 0x1050
testl %eax, %eax
jne 0x1394
leaq 0xff(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
testl %eax, %eax
jne 0x1379
leaq -0xa0(%rbp), %rsi
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
js 0x1382
addq $0x1fe, %rbx            # imm = 0x1FE
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1090
testl %eax, %eax
js 0x138b
leaq 0xcdc(%rip), %rdi       # 0x203d
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1040
xorl %eax, %eax
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc8f(%rip), %rdi       # 0x200f
jmp 0x139b
leaq 0xc98(%rip), %rdi       # 0x2021
jmp 0x139b
leaq 0xc9c(%rip), %rdi       # 0x202e
jmp 0x139b
leaq 0xcb4(%rip), %rdi       # 0x204f
callq 0x1080
jmp 0x136e
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/8-Synchronization/pthread_mutex.c
// Function: do_your_job
void *do_your_job(void *input)
{
	int number = *((int *) input);
	int i = 0;

	printf("Thread %d: starts execution.\n", number);

	while(1)
	{
		pthread_mutex_lock(&mutex);	// locking

		if(shared < max)		// the shared counter
		{
			shared++;		// writing shared variables
			i++;
			printf("Thread %d: shared = %d.\n", number, shared);
		}
		else
		{
			pthread_mutex_unlock(&mutex);	// unlocking before break.
			break;
		}

		pthread_mutex_unlock(&mutex);	// unlocking
		sleep(rand() % 2);	// forced context switching
	}

	printf("Thread %d: termination: I'm responsible for %d updates.\n", number, i);

	pthread_exit(0);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %ebx
leaq 0xd18(%rip), %rdi       # 0x2004
xorl %ebp, %ebp
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
leaq 0x2db2(%rip), %rdi      # 0x40b0
callq 0x1110
movl 0x2dcf(%rip), %edx      # 0x40d8
cmpl 0x2dcd(%rip), %edx      # 0x40dc
jge 0x136d
leaq 0xd0a(%rip), %r14       # 0x2022
leaq 0x2d91(%rip), %r15      # 0x40b0
xorl %ebp, %ebp
incl %edx
movl %edx, 0x2daf(%rip)      # 0x40d8
incl %ebp
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movq %r15, %rdi
callq 0x1070
callq 0x1120
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
andl $-0x2, %ecx
subl %ecx, %eax
movl %eax, %edi
callq 0x1100
movq %r15, %rdi
callq 0x1110
movl 0x2d73(%rip), %edx      # 0x40d8
cmpl 0x2d71(%rip), %edx      # 0x40dc
jl 0x1321
leaq 0x2d3c(%rip), %rdi      # 0x40b0
callq 0x1070
leaq 0xcbb(%rip), %rdi       # 0x203b
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1030
xorl %edi, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/keiranrowan[P]tiny-core/./src/echo.c
// Function: main
int main(int argc, char** argv) {
    if (argc > 1) {
        int i;
        for (i = 1;i < argc;i++) {
            printf("%s ",argv[i]);
        }
        printf("\n");
    } else {
        printf("\n");
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x1182
movq %rsi, %rbx
movl %edi, %r15d
movl $0x1, %r12d
leaq 0xe98(%rip), %r14       # 0x2004
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
incq %r12
cmpq %r12, %r15
jne 0x116c
movl $0xa, %edi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/GangZhuo[P]dohclient/http-parser/http_parser.c
// Function: http_message_needs_eof
int
http_message_needs_eof (const http_parser *parser)
{
  if (parser->type == HTTP_REQUEST) {
    return 0;
  }

  /* See RFC 2616 section 4.4 */
  if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */
      parser->status_code == 204 ||     /* No Content */
      parser->status_code == 304 ||     /* Not Modified */
      parser->flags & F_SKIPBODY) {     /* response to a HEAD request */
    return 0;
  }

  /* RFC 7230 3.3.3, see `s_headers_almost_done` */
  if ((parser->uses_transfer_encoding == 1) &&
      (parser->flags & F_CHUNKED) == 0) {
    return 1;
  }

  if ((parser->flags & F_CHUNKED) || parser->content_length != ULLONG_MAX) {
    return 0;
  }

  return 1;
}

// Assembly:
movl (%rdi), %ecx
xorl %eax, %eax
testb $0x3, %cl
je 0x78cd
btl $0x8, %ecx
jb 0x78cd
movzwl 0x14(%rdi), %edx
cmpl $0x130, %edx            # imm = 0x130
je 0x78cd
cmpl $0xcc, %edx
je 0x78cd
addl $0xffffff38, %edx       # imm = 0xFFFFFF38
cmpl $-0x65, %edx
ja 0x78cd
movl %ecx, %edx
andl $0x4, %edx
shrl $0x2, %edx
andl $0x20000004, %ecx       # imm = 0x20000004
cmpl $0x20000000, %ecx       # imm = 0x20000000
sete %al
orb %al, %dl
jne 0x78cd
cmpq $-0x1, 0x8(%rdi)
sete %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/GangZhuo[P]dohclient/http-parser/http_parser.c
// Function: http_parser_init
void
http_parser_init (http_parser *parser, enum http_parser_type t)
{
  void *data = parser->data; /* preserve application data */
  memset(parser, 0, sizeof(*parser));
  parser->data = data;
  parser->type = t;
  parser->state = (t == HTTP_REQUEST ? s_start_req : (t == HTTP_RESPONSE ? s_start_res : s_start_req_or_res));
  parser->http_errno = HPE_OK;
}

// Assembly:
movq 0x18(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rax, 0x18(%rdi)
movl %esi, %eax
andl $0x3, %eax
xorl %ecx, %ecx
cmpl $0x1, %esi
sete %cl
shll $0xb, %ecx
addl $0x800, %ecx            # imm = 0x800
testl %esi, %esi
movl $0x4800, %edx           # imm = 0x4800
cmovnel %ecx, %edx
orl %eax, %edx
movl %edx, (%rdi)
andb $-0x80, 0x17(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/GangZhuo[P]dohclient/src/channel.c
// Function: channel_create
int channel_create(
	channel_t** pctx,
	const char* name,
    const char* args,
	const config_t* conf,
	const proxy_t* proxies,
	const int proxy_num,
	const chnroute_ctx chnr,
	const chnroute_ctx blacklist,
	void* data)
{
	channel_info_t* info;
	char chname[20] = {0};
	char *dot;

	dot = strchr(name, '.');
	if (dot) {
		memcpy(chname, name, MIN(dot - name, sizeof(chname) - 1));
	}
	else {
		strncpy(chname, name, sizeof(chname) - 1);
	}

	info = _infos;
	while (info) {

		if (strcmp(info->name, chname) == 0) {
			return info->create(pctx,
				name, args, conf,
				proxies, proxy_num,
				chnr, blacklist,
				data);
		}

		info++;
	}
	return CHANNEL_NO_EXIST;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
movq %rsi, %rdi
movl $0x2e, %esi
callq 0x3150
testq %rax, %rax
je 0x8381
subq %r13, %rax
cmpq $0x13, %rax
movl $0x13, %edx
cmovbq %rax, %rdx
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x32b0
jmp 0x8393
leaq 0x10(%rsp), %rdi
movl $0x13, %edx
movq %r13, %rsi
callq 0x31d0
leaq 0x248b6(%rip), %r14     # 0x2cc50
leaq 0x10(%rsp), %rbx
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x34e0
addq $0x10, %r14
testl %eax, %eax
jne 0x839f
subq $0x8, %rsp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x38(%rsp), %r8
movl 0x14(%rsp), %r9d
pushq 0x88(%rsp)
pushq 0x88(%rsp)
pushq 0x88(%rsp)
callq *-0x8(%r14)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_get
const ns_msg_t *cache_get(channel_t *ctx, const char *key)
{
	cache_t *c = (cache_t*)ctx;
	cache_item_t *item;
	struct rbnode_t *rbn;

	if (!key) {
		loge("invalid arguments\n");
		return NULL;
	}

	rbn = rbtree_lookup(&c->dic, key);
	if (!rbn) {
		loge("item not exists - %s\n", key);
		return NULL;
	}

	item = rbtree_container_of(rbn, cache_item_t, node);
	return item->msg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x865a
movq %rsi, %r14
addq $0x68, %rdi
callq 0x390c
testq %rax, %rax
je 0x8692
movq 0x38(%rax), %rbx
jmp 0x86cb
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x17d59
cmpl $0x3, (%rax)
jl 0x86cb
leaq 0x19fad(%rip), %rsi     # 0x2261c
leaq 0x19fba(%rip), %rdx     # 0x22630
leaq 0x19fbd(%rip), %r8      # 0x2263a
xorl %ebx, %ebx
movl $0x3, %edi
movl $0xc8, %ecx
xorl %eax, %eax
callq 0x17d92
jmp 0x86cb
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x17d59
cmpl $0x3, (%rax)
jl 0x86cb
leaq 0x19f75(%rip), %rsi     # 0x2261c
leaq 0x19f82(%rip), %rdx     # 0x22630
leaq 0x19f98(%rip), %r8      # 0x2264d
xorl %ebx, %ebx
movl $0x3, %edi
movl $0xce, %ecx
movq %r14, %r9
xorl %eax, %eax
callq 0x17d92
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_remove
int cache_remove(channel_t *ctx, const char *key)
{
	cache_t *c = (cache_t*)ctx;
	cache_item_t *item;
	struct rbnode_t *rbn;

	if (!key) {
		loge("invalid arguments\n");
		return -1;
	}

	rbn = rbtree_lookup(&c->dic, key);
	if (!rbn) {
		loge("item not exists - %s\n", key);
		return -1;
	}

	item = rbtree_container_of(rbn, cache_item_t, node);
	dllist_remove(&item->entry);
	rbtree_remove(&c->dic, &item->node);
	cache_item_destroy(item);
	logi("cache removed: %s\n", key);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x875b
movq %rsi, %rbx
movq %rdi, %r14
addq $0x68, %r14
movq %r14, %rdi
callq 0x390c
testq %rax, %rax
je 0x8794
movq %rax, %r15
movq 0x28(%rax), %rax
movq 0x30(%r15), %rcx
movq %rax, (%rcx)
movq 0x28(%r15), %rax
movq %rcx, 0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3946
movq %r15, %rdi
callq 0x87db
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x17d59
cmpl $0x6, (%rax)
jl 0x87ce
leaq 0x19edd(%rip), %rsi     # 0x2261c
leaq 0x19f1d(%rip), %rdx     # 0x22663
leaq 0x19f23(%rip), %r8      # 0x22670
xorl %ebp, %ebp
movl $0x6, %edi
movl $0xeb, %ecx
jmp 0x87c4
xorl %eax, %eax
callq 0x17d59
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x3, (%rax)
jl 0x87ce
leaq 0x19ea9(%rip), %rsi     # 0x2261c
leaq 0x19ee9(%rip), %rdx     # 0x22663
leaq 0x19eb9(%rip), %r8      # 0x2263a
movl $0x3, %edi
movl $0xdd, %ecx
xorl %eax, %eax
callq 0x17d92
jmp 0x87ce
xorl %eax, %eax
callq 0x17d59
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x3, (%rax)
jl 0x87ce
leaq 0x19e70(%rip), %rsi     # 0x2261c
leaq 0x19eb0(%rip), %rdx     # 0x22663
leaq 0x19e93(%rip), %r8      # 0x2264d
movl $0x3, %edi
movl $0xe3, %ecx
movq %rbx, %r9
xorl %eax, %eax
callq 0x17d92
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_item_destroy
static void cache_item_destroy(cache_item_t* item)
{
	if (item) {
		free(item->node.key);
		ns_msg_free(item->msg);
		free(item->msg);
		free(item);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x8807
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3450
movq 0x38(%rbx), %rdi
callq 0x1a1dd
movq 0x38(%rbx), %rdi
callq 0x3450
movq %rbx, %rdi
popq %rbx
jmp 0x3450
retq
// File: /workspace/github_c_makefile_star2_O1/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_item_add
static void cache_item_add(cache_t* c, cache_item_t* item)
{
	dlitem_t* cur, * nxt;
	cache_item_t* p;

	/* TODO: Use Heap Data Structure, see https://en.wikipedia.org/wiki/Heap_(data_structure) */
	dllist_foreach(&c->items, cur, nxt,
		cache_item_t, p, entry) {
		
		if (p->expire >= item->expire) {
			dllist_add_before(&p->entry, &item->entry);
			return;
		}
	}

	dllist_add(&c->items, &item->entry);
}

// Assembly:
leaq 0x58(%rdi), %rcx
movq %rcx, %rax
movq (%rax), %rax
cmpq %rcx, %rax
je 0x8b11
movq 0x18(%rax), %rdx
cmpq 0x40(%rsi), %rdx
jl 0x8ae3
leaq 0x28(%rsi), %rcx
movq %rax, 0x28(%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsi)
movq 0x8(%rax), %rdx
movq %rcx, (%rdx)
movq %rcx, 0x8(%rax)
retq
leaq 0x28(%rsi), %rax
movq %rcx, 0x28(%rsi)
movq 0x60(%rdi), %rcx
movq %rcx, 0x30(%rsi)
movq %rax, (%rcx)
movq %rax, 0x60(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_load_cachedbs
int cache_load_cachedbs(channel_t *ctx, const char *filenames, int override)
{
	char *s, *p, *saveptr = NULL;
	struct stat fstat = {0};

	if (!filenames || !*filenames) {
		loge("Invalid filenames: %s\n", filenames);
		return -1;
	}

	s = strdup(filenames);

	for (p = strtok_r(s, ",", &saveptr);
		p && *p;
		p = strtok_r(NULL, ",", &saveptr)) {

		if (stat(p, &fstat)) {
			logw("Failed to load cache: Failed to open the file - \"%s\"\n", p);
		}
		else if (cache_load_cachedb(ctx, p, override) == -1) {
			free(s);
			return -1;
		}
	}

	free(s);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x90, %edx
xorl %esi, %esi
callq 0x31e0
testq %r15, %r15
je 0x98d5
cmpb $0x0, (%r15)
je 0x98d5
movq %r15, %rdi
callq 0x3610
leaq 0x19073(%rip), %rsi     # 0x22898
leaq 0x10(%rsp), %rdx
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x3600
testq %rax, %rax
je 0x98c7
movq %rax, %r15
leaq 0x18(%rsp), %r12
leaq 0x19049(%rip), %r13     # 0x22898
leaq 0x10(%rsp), %rbp
cmpb $0x0, (%r15)
je 0x98c7
movq %r15, %rdi
movq %r12, %rsi
callq 0x32f0
testl %eax, %eax
je 0x98a0
xorl %eax, %eax
callq 0x17d59
cmpl $0x4, (%rax)
jl 0x98b2
movl $0x4, %edi
leaq 0x18d9b(%rip), %rsi     # 0x2261c
leaq 0x18fe5(%rip), %rdx     # 0x2286d
movl $0x269, %ecx            # imm = 0x269
leaq 0x19006(%rip), %r8      # 0x2289a
movq %r15, %r9
xorl %eax, %eax
callq 0x17d92
jmp 0x98b2
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x92da
cmpl $-0x1, %eax
je 0x9923
xorl %edi, %edi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x3600
movq %rax, %r15
testq %rax, %rax
jne 0x9854
movq 0x8(%rsp), %rdi
callq 0x3450
xorl %ebx, %ebx
jmp 0x990f
xorl %eax, %eax
callq 0x17d59
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x3, (%rax)
jl 0x990f
leaq 0x18d2f(%rip), %rsi     # 0x2261c
leaq 0x18f79(%rip), %rdx     # 0x2286d
leaq 0x18f86(%rip), %r8      # 0x22881
movl $0x3, %edi
movl $0x25e, %ecx            # imm = 0x25E
movq %r15, %r9
xorl %eax, %eax
callq 0x17d92
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdi
callq 0x3450
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x990f