LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/fluid_dynamics.c
// Function: RungeKutta3
static void RungeKutta3(const Real dt, const int s, Space *space, const Model *model)
{
    /* solve U1 = LLLU = 0.0 * Un + 1.0 * LLUn */
    LLLU(dt, 0.0, 1.0, TO, TO, TN, s, space, model);
    TreatBoundary(TN, space, model);
    /* solve U2 = LLLU = 3.0/4.0 * Un + 1.0/4.0 * LLU1 */
    LLLU(dt, 3.0/4.0, 1.0/4.0, TO, TN, TM, s, space, model);
    TreatBoundary(TM, space, model);
    /* solve U(n+1) = LLLU = 1.0/3.0 * Un + 2.0/3.0 * LLU2 */
    LLLU(dt, 1.0/3.0, 2.0/3.0, TO, TM, TO, s, space, model);
    TreatBoundary(TO, space, model);
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movsd %xmm0, 0x8(%rsp)
movsd 0x8126(%rip), %xmm2     # 0x18008
pushq $0x1
popq %r15
xorps %xmm1, %xmm1
xorl %edi, %edi
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0xff85
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x233c
movsd 0xd0d7(%rip), %xmm1     # 0x1cfe8
movsd 0xbb17(%rip), %xmm2     # 0x1ba30
pushq $0x2
popq %r12
movsd 0x8(%rsp), %xmm0
movl %r15d, %edi
movl %r12d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0xff85
movl %r12d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x233c
movsd 0xd0a4(%rip), %xmm1     # 0x1cff0
movsd 0xd0a4(%rip), %xmm2     # 0x1cff8
movsd 0x8(%rsp), %xmm0
movl %r12d, %edi
xorl %esi, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0xff85
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x233c
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/fluid_dynamics.c
// Function: SolveOperator
static void SolveOperator(const int p, const int s, const Real coeA, const Real coeB,
        const Real Uo[restrict], const Real Un[restrict], Real Um[restrict], const Real r,
        const Real Phi[restrict])
{
    /* accumulation step for operator-by-operator approximation */
    if ((OPTBYOPT == p) && (X != s)) {
        for (int n = 0; n < DIMU; ++n) {
            Um[n] = Um[n] + coeB * r * Phi[n];
        }
        return;
    }
    /* solve step for the solution operator */
    for (int n = 0; n < DIMU; ++n) {
        Um[n] = coeA * Uo[n] + coeB * (Un[n] + r * Phi[n]);
    }
    return;
}

// Assembly:
cmpl $0x1, %edi
sete %al
testl %esi, %esi
setne %sil
testb %sil, %al
je 0x104c3
mulsd %xmm2, %xmm1
xorl %eax, %eax
cmpq $0x5, %rax
je 0x104f6
movsd (%r9,%rax,8), %xmm0
mulsd %xmm1, %xmm0
addsd (%r8,%rax,8), %xmm0
movsd %xmm0, (%r8,%rax,8)
incq %rax
jmp 0x104a2
xorl %eax, %eax
cmpq $0x5, %rax
je 0x104f6
movsd (%r9,%rax,8), %xmm3
mulsd %xmm2, %xmm3
addsd (%rcx,%rax,8), %xmm3
mulsd %xmm1, %xmm3
movsd (%rdx,%rax,8), %xmm4
mulsd %xmm0, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%r8,%rax,8)
incq %rax
jmp 0x104c5
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/immersed_boundary.c
// Function: GetInterState
static int GetInterState(const int sid, const int k, const int j, const int i, const int did,
        const int end, const int path[restrict][DIMS], const Node *const node, const Partition *const part)
{
    /* search around the specified node to check interfacial state */
    int idx = 0; /* linear array index math variable */
    int ih = 0, jh = 0, kh = 0; /* neighbouring node */
    int flag = 0; /* control flag */
    for (int n = 0; n < end; ++n) {
        kh = k + path[n][Z];
        jh = j + path[n][Y];
        ih = i + path[n][X];
        if (!InPartBox(kh, jh, ih, part->ns[PIN])) {
            continue;
        }
        idx = IndexNode(kh, jh, ih, part->n[Y], part->n[X]);
        switch (sid) {
            case INTERL:
                if (did != node[idx].did) { /* a heterogeneous node on the path */
                    flag = 1;
                }
                break;
            case INTERG:
                if (did == node[idx].did) { /* a computational node on the path */
                    flag = 1;
                }
                break;
            default:
                break;
        }
        if (1 == flag) { /* return the layer number */
            for (int r = 1; r <= part->gl; ++r) {
                if (part->pathSep[r] > n) {
                    return r;
                }
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0x8(%rsp)
movl %ecx, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edi, 0x4(%rsp)
movq 0x70(%rsp), %rcx
xorl %eax, %eax
testl %r9d, %r9d
cmovlel %eax, %r9d
movq %r9, 0x20(%rsp)
leaq 0x68(%rcx), %rax
movq %rax, 0x18(%rsp)
xorl %ebp, %ebp
xorl %r12d, %r12d
cmpq 0x20(%rsp), %rbp
je 0x11a3d
imulq $0xc, %rbp, %rax
movq 0x60(%rsp), %rcx
movl 0x8(%rcx,%rax), %r13d
addl 0xc(%rsp), %r13d
movl 0x4(%rcx,%rax), %r14d
addl 0x10(%rsp), %r14d
movl (%rcx,%rax), %r15d
addl 0x14(%rsp), %r15d
movl %r13d, %edi
movl %r14d, %esi
movl %r15d, %edx
movq 0x18(%rsp), %rcx
callq 0x75f9
testl %eax, %eax
je 0x11a22
cmpl $0x0, 0x4(%rsp)
sete %bl
movq 0x70(%rsp), %rax
movl 0xc(%rax), %r8d
movl 0x10(%rax), %ecx
movl %r13d, %edi
movl %r14d, %esi
movl %r15d, %edx
callq 0x75ec
cltq
imulq $0x88, %rax, %rax
movl 0x8(%rsp), %ecx
movq 0x68(%rsp), %rdx
cmpl %ecx, (%rdx,%rax)
sete %al
xorb %bl, %al
cmpl $0x1, %r12d
sete %cl
orb %al, %cl
xorl %r12d, %r12d
cmpb $0x1, %cl
jne 0x11a22
movq 0x70(%rsp), %rsi
movl 0x24(%rsi), %eax
testl %eax, %eax
movl $0x0, %ecx
cmovlel %ecx, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x11a1e
movslq 0x384(%rsi,%rcx,4), %rdx
cmpq %rdx, %rbp
jl 0x11a2a
incq %rcx
jmp 0x11a07
pushq $0x1
popq %r12
incq %rbp
jmp 0x1195e
incl %ecx
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x11a2e
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/immersed_boundary.c
// Function: ApplyWeighting
static void ApplyWeighting(const Real Uoh[restrict], const Real tiny, Real weight,
        Real weightSum[restrict], Real Uo[restrict])
{
    const Real one = 1.0;
    if (tiny > weight) { /* avoid overflow of too small weight */
        weight = tiny;
    }
    weight = one / weight; /* compute weight */
    for (int n = 0; n < DIMUo; ++n) {
        Uo[n] = Uo[n] + Uoh[n] * weight;
    }
    *weightSum = *weightSum + weight; /* accumulate normalizer */
    return;
}

// Assembly:
maxsd %xmm1, %xmm0
movsd 0x65bb(%rip), %xmm1     # 0x18008
divsd %xmm0, %xmm1
xorl %eax, %eax
cmpq $0x6, %rax
je 0x11a71
movsd (%rdi,%rax,8), %xmm0
mulsd %xmm1, %xmm0
addsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%rdx,%rax,8)
incq %rax
jmp 0x11a53
addsd (%rsi), %xmm1
movsd %xmm1, (%rsi)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/main.c
// Function: main
int main(int argc, char *argv[])
{
    /* declare and initialize variables */
    Control control = {
        .runMode = 'i',
        .proc = {0}};
    Time time = {0};
    Space space = {0};
    Model model = {0};
    /* perform computation */
    EnterProgram(argc, argv, &control, &space);
    Preprocess(&time, &space, &model);
    Solve(&time, &space, &model);
    Postprocess(&time, &space, &model);
    exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x548, %rsp            # imm = 0x548
movq %rsi, %r15
movl %edi, %ebp
movups 0xa69f(%rip), %xmm0     # 0x1d1f8
movq %rsp, %r12
movaps %xmm0, (%r12)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
andq $0x0, 0x60(%rbx)
leaq 0x118(%rsp), %r14
movl $0x430, %edx            # imm = 0x430
movq %r14, %rdi
xorl %esi, %esi
callq 0x20d0
leaq 0x80(%rsp), %r13
movl $0x98, %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x20d0
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x15018
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x14f20
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x16a50
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x14ddc
xorl %edi, %edi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O2/mohuangrui[P]ArtraCFD/paraview_writer.c
// Function: InitializeTransientCaseFile
static void InitializeTransientCaseFile(PvSet *pvSet)
{
    snprintf(pvSet->fname, sizeof(PvStr), "%s.pvd", pvSet->rname);
    FILE *fp = Fopen(pvSet->fname, "w");
    fprintf(fp, "<?xml version=\"1.0\"?>\n");
    fprintf(fp, "<VTKFile type=\"Collection\" version=\"1.0\" byte_order=\"%s\">\n", pvSet->byteOrder);
    fprintf(fp, "  <Collection>\n");
    fprintf(fp, "  </Collection>\n");
    fprintf(fp, "</VTKFile>\n");
    fclose(fp);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0xa0(%rdi), %rbx
leaq 0x9a97(%rip), %rdx      # 0x1dba8
pushq $0x50
popq %rsi
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x20b0
leaq 0x6af0(%rip), %rsi      # 0x1ac18
movq %rbx, %rdi
callq 0x8820
movq %rax, %rbx
leaq 0xa3be(%rip), %rdi      # 0x1e4f8
pushq $0x16
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
movq %rax, %rcx
callq 0x2210
addq $0x230, %r15            # imm = 0x230
leaq 0xa3b5(%rip), %rsi      # 0x1e50f
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2160
leaq 0xa3dc(%rip), %rdi      # 0x1e54a
pushq $0xf
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2210
leaq 0xa3d7(%rip), %rdi      # 0x1e55a
pushq $0x10
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2210
leaq 0xa3d3(%rip), %rdi      # 0x1e56b
pushq $0xb
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2210
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O2/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 0x9c24(%rip), %rdi      # 0x1ea1b
xorl %eax, %eax
callq 0x8643
leaq 0x9c29(%rip), %rdi      # 0x1ea2e
xorl %eax, %eax
callq 0x8643
movslq 0xc(%r15), %r13
imulq $0x238, %r13, %rbp      # imm = 0x238
addq $0x228, %rbp            # imm = 0x228
movslq 0x8(%r15), %rax
movq 0x18(%r15), %r12
cmpq %rax, %r13
jge 0x14e72
movq -0x28(%r12,%rbp), %rdi
callq 0x872b
movq -0x20(%r12,%rbp), %rdi
callq 0x872b
movq -0x18(%r12,%rbp), %rdi
callq 0x872b
movq -0x10(%r12,%rbp), %rdi
callq 0x872b
movq -0x8(%r12,%rbp), %rdi
callq 0x872b
movq (%r12,%rbp), %rdi
callq 0x872b
incq %r13
addq $0x238, %rbp            # imm = 0x238
jmp 0x14e1e
movq %r12, %rdi
callq 0x872b
movq 0x20(%r15), %rdi
callq 0x872b
movq 0x3b8(%r15), %rdi
callq 0x872b
movq 0x3c0(%r15), %rdi
callq 0x872b
movq 0x3c8(%r15), %rdi
callq 0x872b
movq 0x3d8(%r15), %rdi
callq 0x872b
movq 0x3e0(%r15), %rdi
callq 0x872b
movq 0x3e8(%r15), %rdi
callq 0x872b
movq (%r15), %rdi
callq 0x872b
movq 0x60(%r14), %rdi
callq 0x872b
movq 0x58(%r14), %rdi
callq 0x872b
movq 0x90(%rbx), %rdi
callq 0x872b
leaq 0x9b4d(%rip), %rdi      # 0x1ea45
xorl %eax, %eax
callq 0x8643
leaq 0x341f(%rip), %rdi      # 0x18325
xorl %eax, %eax
callq 0x8643
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x33f0(%rip), %rdi      # 0x18325
xorl %eax, %eax
callq 0x8643
leaq 0x9b2c(%rip), %rdi      # 0x1ea6f
xorl %eax, %eax
callq 0x8643
leaq 0x9b30(%rip), %rdi      # 0x1ea81
xorl %eax, %eax
callq 0x8643
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x511c
leaq 0x9b2c(%rip), %rdi      # 0x1ea99
xorl %eax, %eax
callq 0x8643
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x80e0
leaq 0x9b2b(%rip), %rdi      # 0x1eab4
xorl %eax, %eax
callq 0x8643
movq %r14, %rdi
callq 0xd7e8
leaq 0x9b2f(%rip), %rdi      # 0x1eace
xorl %eax, %eax
callq 0x8643
movslq 0x34(%r14), %rax
movslq 0x38(%r14), %rcx
imulq %rax, %rcx
movslq 0x3c(%r14), %rax
imulq %rcx, %rax
imulq $0x88, %rax, %rdi
callq 0x870a
movq %rax, (%r14)
movslq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x14ff3
shlq $0x4, %rdi
callq 0x870a
movq %rax, 0x20(%r14)
movslq 0x8(%r14), %rax
imulq $0x238, %rax, %rdi      # imm = 0x238
callq 0x870a
movq %rax, 0x18(%r14)
pushq $0x8
popq %rdi
callq 0x870a
movq %rax, 0x90(%rbx)
leaq 0x331c(%rip), %rdi      # 0x18325
xorl %eax, %eax
callq 0x8643
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1710f
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 0x75ec
cltq
movslq %ebp, %rcx
imulq $0x88, %rax, %rax
addq %rax, %rbx
imulq $0x28, %rcx, %rax
movsd 0x10(%rax,%rbx), %xmm0
movupd 0x18(%rax,%rbx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm2, %xmm1
leaq 0x20(%rsp), %rsi
movapd %xmm1, (%rsi)
movsd 0x28(%rax,%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsi)
movupd 0x78(%r15), %xmm1
mulpd %xmm2, %xmm1
movq %rsp, %rdi
movapd %xmm1, (%rdi)
mulsd 0x88(%r15), %xmm0
andq $0x0, (%r14)
movsd %xmm0, 0x10(%rdi)
movupd %xmm1, 0x8(%r14)
movsd %xmm0, 0x18(%r14)
callq 0x76cc
movsd %xmm0, 0x20(%r14)
jmp 0x17123
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%r14)
movupd %xmm0, (%r14)
andq $0x0, 0x20(%r14)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x789c(%rip), %xmm0     # 0x1ef30
addsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
movapd 0x7896(%rip), %xmm0     # 0x1ef40
movapd 0x789e(%rip), %xmm1     # 0x1ef50
movsd 0x78a6(%rip), %xmm2     # 0x1ef60
movsd 0x3dee(%rip), %xmm3     # 0x1b4b0
cmpq $0x5, %rax
je 0x17754
movsd (%rdi,%rax,8), %xmm7
movsd 0x28(%rdi,%rax,8), %xmm4
movsd 0x50(%rdi,%rax,8), %xmm5
movapd %xmm4, %xmm6
unpcklpd %xmm5, %xmm6            # xmm6 = xmm6[0],xmm5[0]
movapd %xmm4, %xmm8
mulsd %xmm2, %xmm8
subsd %xmm7, %xmm8
unpcklpd %xmm4, %xmm7            # xmm7 = xmm7[0],xmm4[0]
subpd %xmm7, %xmm6
mulpd %xmm6, %xmm6
addpd %xmm0, %xmm6
mulpd %xmm6, %xmm6
movapd %xmm1, %xmm7
divpd %xmm6, %xmm7
movapd %xmm7, %xmm6
unpckhpd %xmm7, %xmm6            # xmm6 = xmm6[1],xmm7[1]
movapd %xmm7, %xmm9
addsd %xmm6, %xmm9
divsd %xmm9, %xmm7
divsd %xmm9, %xmm6
mulsd %xmm3, %xmm8
mulsd %xmm7, %xmm8
addsd %xmm5, %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm6, %xmm4
addsd %xmm8, %xmm4
movsd %xmm4, (%rsi,%rax,8)
incq %rax
jmp 0x176c2
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x126e
callq 0x1554
leaq 0x20(%rsp), %rdi
callq 0x1358
testl %eax, %eax
jne 0x12e3
leaq 0x10(%rsp), %rdi
callq 0x141c
testl %eax, %eax
jne 0x12f6
leaq 0x8(%rsp), %rdi
callq 0x14a9
testl %eax, %eax
jne 0x1315
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0xd96(%rip), %rdi       # 0x203f
xorl %eax, %eax
callq 0x1090
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0xdb1(%rip), %rdi       # 0x2072
xorl %eax, %eax
callq 0x1090
movsd 0x8(%rsp), %xmm0
leaq 0xdd7(%rip), %rdi       # 0x20ac
movb $0x1, %al
callq 0x1090
xorl %edi, %edi
callq 0x1120
callq 0x1060
cmpl $0x0, (%rax)
jne 0x1309
leaq 0xd10(%rip), %rdi       # 0x2004
jmp 0x1326
callq 0x1060
cmpl $0x0, (%rax)
jne 0x132f
leaq 0xd0d(%rip), %rdi       # 0x2014
jmp 0x1326
movq %rax, %rbx
leaq 0xcf1(%rip), %rdi       # 0x2004
jmp 0x1345
callq 0x1060
cmpl $0x0, (%rax)
jne 0x133b
leaq 0xd06(%rip), %rdi       # 0x202c
xorl %eax, %eax
callq 0x1760
jmp 0x134f
movq %rax, %rbx
leaq 0xcdb(%rip), %rdi       # 0x2014
jmp 0x1345
movq %rax, %rbx
leaq 0xce7(%rip), %rdi       # 0x202c
xorl %eax, %eax
callq 0x15d1
andl $0x0, (%rbx)
pushq $0x1
popq %rdi
callq 0x1120
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xe6d(%rip), %rdi       # 0x2004
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1050
callq 0x1040
movq %rax, %r14
andl $0x0, (%rax)
leaq 0xe62(%rip), %rdi       # 0x2014
movq %rsp, %rsi
xorl %eax, %eax
callq 0x1070
cmpl $0x1, %eax
jne 0x11e6
movq (%rsp), %rsi
leaq 0xe6e(%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 0x120c
movq 0x2e05(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xe25(%rip), %rdi       # 0x2022
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x1080
xorl %ebx, %ebx
jmp 0x11dc
leaq 0xe09(%rip), %rdi       # 0x201c
callq 0x1060
pushq $-0x1
popq %rbx
jmp 0x11dc
// File: /workspace/github_c_makefile_star2_O2/agraf[P]kvmbench/numa.c
// Function: exit_all
void exit_all(int *pids)
{
    int i;

    for (i = 0; i < NR_CHILDREN; i++) {
        kill(pids[i], SIGTERM);
    }

    exit(0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0xf
popq %rbp
cmpq $0x64, %r14
je 0x12af
movl (%rbx,%r14,4), %edi
movl %ebp, %esi
callq 0x10f0
incq %r14
jmp 0x1299
xorl %edi, %edi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %rbx
xorl %esi, %esi
callq 0x611e
movl %eax, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6b4e
movq (%r15), %rcx
cmpb $0x46, %r14b
je 0x7ba0
movzbl %r14b, %edx
cmpl $0x54, %edx
je 0x7b4a
cmpl $0x66, %edx
je 0x7b4f
cmpl $0x69, %edx
jne 0x7ba3
movl %eax, (%rcx)
jmp 0x7ba3
movb $0x1, (%rcx)
jmp 0x7ba3
movq %rbx, %rdi
callq 0x6881
movq %rax, %rdi
movq %rdx, %rsi
leaq -0x28(%rbp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
leaq -0x40(%rbp), %r14
leaq 0x22e2(%rip), %r15      # 0x9e55
callq 0x6b34
testl %eax, %eax
jne 0x7ba3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68f3
cvtss2sd -0x38(%rbp), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x20f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
jmp 0x7b73
movb $0x0, (%rcx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2590(%rip), %rdi      # 0xa15c
callq 0x2080
movq 0x20(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps 0x10(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x21f5(%rip), %r14      # 0x9dde
leaq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e09
pushq $0xb
popq %r12
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x6098
leaq 0x224f(%rip), %rsi      # 0x9e63
pushq $0x61
popq %rdx
movl %eax, %edi
callq 0x73d8
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x602d
leaq 0x21af(%rip), %rdi      # 0x9de5
leaq 0x2241(%rip), %rdx      # 0x9e7e
pushq $0x65
popq %rcx
movq %rax, %rsi
callq 0x744d
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x6045
leaq 0x2245(%rip), %rdi      # 0x9ea5
leaq 0x2242(%rip), %rdx      # 0x9ea9
pushq $0x67
popq %rcx
movq %rax, %rsi
callq 0x744d
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x605d
leaq 0x2241(%rip), %rdi      # 0x9ecb
leaq 0x2246(%rip), %rdx      # 0x9ed7
pushq $0x69
popq %rcx
movq %rax, %rsi
callq 0x744d
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x6075
leaq 0x16f8(%rip), %rdi      # 0x93ac
leaq 0x2235(%rip), %rdx      # 0x9ef0
pushq $0x6b
popq %rcx
movq %rax, %rsi
callq 0x744d
pushq $0x8
popq %r15
movq %r15, %rdi
callq 0x21f0
movq %rax, %r12
movq %r15, %rdi
callq 0x21f0
movq %rax, %r15
leaq 0x54a9(%rip), %rax      # 0xd190
movq %rax, (%r12)
leaq 0x54a2(%rip), %rax      # 0xd194
movq %rax, (%r15)
leaq -0x1f9(%rip), %r13      # 0x7b03
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x33c4
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x33c4
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x2436(%rip), %rdi      # 0xa182
callq 0x2080
movq 0x20(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps 0x10(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x2084(%rip), %r14      # 0x9ded
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e09
pushq $0xb
popq %r12
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x6098
leaq 0x20cf(%rip), %rsi      # 0x9e63
pushq $0x7c
popq %rdx
movl %eax, %edi
callq 0x73d8
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x602d
leaq 0x203e(%rip), %rdi      # 0x9df4
leaq 0x20c1(%rip), %rdx      # 0x9e7e
pushq $0x7e
popq %rcx
movq %rax, %rsi
callq 0x744d
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x6045
leaq 0x213b(%rip), %rdi      # 0x9f1b
leaq 0x20c2(%rip), %rdx      # 0x9ea9
movq %rax, %rsi
movl $0x80, %ecx
callq 0x744d
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x605d
leaq 0x210a(%rip), %rdi      # 0x9f16
leaq 0x20c4(%rip), %rdx      # 0x9ed7
movq %rax, %rsi
movl $0x82, %ecx
callq 0x744d
movq %r12, %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x6075
leaq 0x1574(%rip), %rdi      # 0x93ac
leaq 0x20b1(%rip), %rdx      # 0x9ef0
movq %rax, %rsi
movl $0x84, %ecx
callq 0x744d
pushq $0x8
popq %rdi
callq 0x21f0
leaq 0x597d(%rip), %rcx      # 0xd7d8
movq %rcx, (%rax)
leaq -0x362(%rip), %rdx      # 0x7b03
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x33c4
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2313(%rip), %rdi      # 0xa1a9
callq 0x2080
movq 0x20(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps 0x10(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x206f(%rip), %rsi      # 0x9f22
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x5e09
pushq $0xb
popq %rcx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x6098
leaq 0x1f8c(%rip), %rsi      # 0x9e63
movl %eax, %edi
movl $0x93, %edx
callq 0x73d8
movq 0x8(%rbx), %rax
movl 0x10(%rax), %esi
leaq 0x2060(%rip), %rdx      # 0x9f51
pushq $0xe
popq %rdi
movl $0x94, %ecx
callq 0x72e4
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl 0x1c(%rax), %esi
leaq 0x205b(%rip), %rdx      # 0x9f6a
pushq $0x7
popq %rdi
movl $0x95, %ecx
callq 0x72e4
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rsi
leaq 0x2055(%rip), %rdi      # 0x9f84
leaq 0x2052(%rip), %rdx      # 0x9f88
movl $0x96, %ecx
callq 0x744d
addq $0xb8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1e6b(%rip), %r14      # 0x9dff
leaq 0x200a(%rip), %rcx      # 0x9fa5
leaq -0x420(%rbp), %r15
movsd 0x1c6e(%rip), %xmm0     # 0x9c18
movsd 0x1c6e(%rip), %xmm1     # 0x9c20
movsd 0x1c6e(%rip), %xmm2     # 0x9c28
movsd 0x1c6e(%rip), %xmm3     # 0x9c30
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movq %r14, %rdx
movb $0x4, %al
callq 0x617b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x244c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x244c
pushq $0x8
popq %rdi
callq 0x21f0
leaq 0x5197(%rip), %rcx      # 0xd190
movq %rcx, (%rax)
leaq -0x500(%rip), %rdx      # 0x7b03
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x33c4
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13a9
movq 0x10(%r14), %rdi
callq 0x11a0
movl %eax, %r15d
xorl %edi, %edi
callq 0x1ad0
cmpl $-0x1, %eax
je 0x13c6
movl %eax, %ebx
callq 0x1070
movslq %eax, %rdx
leaq 0xcfc(%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 0x1d5b
movq %rax, %r14
cmpq $-0x1, %rax
je 0x13d7
cmpq $-0x1, %r14
sete %r14b
movl %ebx, %edi
callq 0x13e8
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 0x2c48(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xc47(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1120
jmp 0x13d2
leaq 0xc58(%rip), %rdi       # 0x2025
callq 0x1190
pushq $0x1
popq %rax
jmp 0x1399
leaq 0xc6c(%rip), %rdi       # 0x204a
callq 0x1190
jmp 0x137e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
cmpl $0x2, %edi
jne 0x1240
movq 0x8(%rsi), %rdi
leaq 0xe85(%rip), %rsi       # 0x2040
callq 0x1070
testq %rax, %rax
je 0x1271
movq %rax, %rbx
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1060
cmpl $-0x1, %eax
je 0x1218
movl %eax, %r15d
movsbl %r15b, %edi
callq 0x1030
callq 0x1090
movq (%rax), %rcx
movslq %r15d, %rdx
xorl %eax, %eax
testb $0x8, 0x1(%rcx,%rdx,2)
je 0x120b
imull $0xa, %r12d, %ecx
addl %r15d, %ecx
addl $-0x30, %ecx
jmp 0x1210
xorl %ecx, %ecx
movl %r12d, %eax
addl %eax, %r14d
movl %ecx, %r12d
jmp 0x11d2
leaq 0xe3c(%rip), %rdi       # 0x205b
xorl %r15d, %r15d
movl %r14d, %esi
xorl %eax, %eax
callq 0x1050
movq %rbx, %rdi
callq 0x1040
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2db1(%rip), %r14      # 0x3ff8
movq (%r14), %rcx
leaq 0xdb3(%rip), %rdi       # 0x2004
pushq $0x28
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1080
movq (%r14), %rcx
leaq 0xdc4(%rip), %rdi       # 0x202d
pushq $0x12
popq %rsi
movq %rbx, %rdx
jmp 0x1288
movq 0x2d80(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xdc0(%rip), %rdi       # 0x2042
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x1080
pushq $0x1
popq %r15
jmp 0x1234
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movl %edi, %r12d
xorl %eax, %eax
callq 0x1fa0
movq %rax, %rbx
movq 0x31d2(%rip), %rax      # 0x7fd8
movq (%rax), %r14
cmpl $0x2, %r12d
jl 0x4e33
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x4e33
leaq 0x2af(%rip), %rsi       # 0x50ce
movq %r15, %rdi
callq 0x1180
movq %rax, %r14
testq %rax, %rax
je 0x4eca
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2238
movl 0x4(%rbx), %esi
leaq 0x92e(%rip), %rdi       # 0x5776
xorl %eax, %eax
callq 0x10b0
movq %rbx, %rdi
callq 0x2474
leaq 0x925(%rip), %rdi       # 0x5783
movl %eax, %esi
xorl %eax, %eax
callq 0x10b0
movzbl 0xd(%rbx), %esi
andl $0x1, %esi
leaq 0x919(%rip), %rdi       # 0x578e
xorl %eax, %eax
callq 0x10b0
movzbl 0xd(%rbx), %esi
shrl %esi
andl $0x1, %esi
leaq 0x914(%rip), %rdi       # 0x57a0
xorl %eax, %eax
callq 0x10b0
movl (%rbx), %esi
leaq 0x917(%rip), %rdi       # 0x57b3
xorl %eax, %eax
callq 0x10b0
movq %rbx, %rdi
callq 0x20a0
movq 0x311e(%rip), %rax      # 0x7fd0
cmpq (%rax), %r14
je 0x4ebf
movq %r14, %rdi
callq 0x1090
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3127(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x1dc(%rip), %rsi       # 0x50b7
movq %r15, %rdx
xorl %eax, %eax
callq 0x1120
pushq $0x1
popq %rdi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O2/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
orl $-0x1, (%rdx)
leaq 0x10(%rsp), %rcx
orq $-0x1, (%rcx)
leaq 0x8(%rsp), %r8
orq $-0x1, (%r8)
callq 0x13857
movq %rax, %r12
testq %rax, %rax
setne %al
testq %r14, %r14
setne %cl
xorb %al, %cl
jne 0x5b41
testq %r14, %r14
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x5b0f
movq %r12, %rdi
movq %r14, %rsi
callq 0x46c0
testl %eax, %eax
jne 0x5b41
testq %r14, %r14
je 0x5b1a
cmpl %ebp, 0x4(%rsp)
jne 0x5b41
testq %r14, %r14
je 0x5b26
cmpq %rbx, 0x10(%rsp)
jne 0x5b41
testq %r14, %r14
je 0x5b32
cmpq %r13, 0x8(%rsp)
jne 0x5b41
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %r14, %r14
leaq 0x6b502(%rip), %r10     # 0x7104d
cmoveq %r10, %r14
testq %r12, %r12
movq 0x91487(%rip), %rax     # 0x96fe0
movq (%rax), %rdi
cmovneq %r12, %r10
movl 0x4(%rsp), %r11d
subq $0x8, %rsp
leaq 0x6b494(%rip), %rsi     # 0x71004
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
pushq $0x1
popq %rdi
callq 0x45e0
// File: /workspace/github_c_makefile_star2_O2/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 %rsp, %rbx
imulq $0xff, %rax, %rax
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
movq %rbx, %rdx
callq 0x11bc
leaq 0xd38(%rip), %rdi       # 0x2004
movq %rbx, %rsi
callq 0x1050
testl %eax, %eax
je 0x12eb
leaq 0xd29(%rip), %rdi       # 0x2008
movq %rbx, %rsi
callq 0x1050
testl %eax, %eax
jne 0x1363
leaq 0xff(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
testl %eax, %eax
jne 0x1348
leaq -0xa0(%rbp), %rsi
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
js 0x1351
addq $0x1fe, %rbx            # imm = 0x1FE
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1090
testl %eax, %eax
js 0x135a
leaq 0xd0d(%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 0xcc0(%rip), %rdi       # 0x200f
jmp 0x136a
leaq 0xcc9(%rip), %rdi       # 0x2021
jmp 0x136a
leaq 0xccd(%rip), %rdi       # 0x202e
jmp 0x136a
leaq 0xce5(%rip), %rdi       # 0x204f
callq 0x1080
jmp 0x133d
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movl (%rdi), %ebx
leaq 0xdc7(%rip), %rdi       # 0x2004
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
leaq 0x2e63(%rip), %r14      # 0x40b0
leaq 0xdce(%rip), %r15       # 0x2022
pushq $0x2
popq %r12
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1110
movl 0x2e70(%rip), %edx      # 0x40d8
cmpl 0x2e6e(%rip), %edx      # 0x40dc
jge 0x12a0
incl %edx
movl %edx, 0x2e60(%rip)      # 0x40d8
incl %ebp
movq %r15, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movq %r14, %rdi
callq 0x1070
callq 0x1120
cltd
idivl %r12d
movl %edx, %edi
callq 0x1100
jmp 0x125a
leaq 0x2e09(%rip), %rdi      # 0x40b0
callq 0x1070
leaq 0xd88(%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_O2/zpole[P]IICV/src/generic-driver.h
// Function: vl_file_meta_get_double
VL_INLINE int
vl_file_meta_get_double (VlFileMeta *self, double *x)
{
  int err ;
  size_t n ;
  double y ;

  switch (self -> protocol) {

  case VL_PROT_ASCII :
    err = fscanf (self -> file, " ") ;
    if (err == EOF) return VL_ERR_EOF ;
    err = fscanf (self -> file, "%lg", x) ;
    if (err == EOF) return VL_ERR_EOF ;
    if (err <  1  ) return VL_ERR_BAD_ARG ;
    break ;

  case VL_PROT_BINARY :
    n = fread (&y, sizeof(double), 1, self -> file) ;
    if (n < 1) return VL_ERR_BAD_ARG ;
    vl_swap_host_big_endianness_8 (x, &y) ;
    break ;

  default :
    abort() ;
  }

  return VL_ERR_OK ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x404(%rdi), %eax
cmpl $0x2, %eax
je 0x3d85
cmpl $0x1, %eax
jne 0x3dd8
movq 0x808(%r14), %rdi
leaq 0x28d3(%rip), %rsi      # 0x6626
xorl %eax, %eax
callq 0x2060
pushq $0x5
popq %rbp
cmpl $-0x1, %eax
je 0x3dcd
movq 0x808(%r14), %rdi
leaq 0x2d6f(%rip), %rsi      # 0x6adf
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2060
cmpl $-0x1, %eax
je 0x3dcd
testl %eax, %eax
jg 0x3dc6
jmp 0x3dca
movq 0x808(%r14), %rcx
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0x20a0
testq %rax, %rax
je 0x3dca
movq 0x8(%rsp), %xmm0
pxor %xmm1, %xmm1
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
pshuflw $0x1b, %xmm0, %xmm0     # xmm0 = xmm0[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,7,6,5,4]
packuswb %xmm0, %xmm0
movq %xmm0, (%rbx)
xorl %ebp, %ebp
jmp 0x3dcd
pushq $0x3
popq %rbp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2040
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/src/generic-driver.h
// Function: vl_file_meta_put_double
VL_INLINE int
vl_file_meta_put_double (VlFileMeta * self, double x)
{
  int err ;
  size_t n ;
  double y ;

  switch (self -> protocol) {

  case VL_PROT_ASCII :
    err = fprintf (self -> file, "%g ", x) ;
    break ;

  case VL_PROT_BINARY :
    vl_swap_host_big_endianness_8 (&y, &x) ;
    n = fwrite (&y, sizeof(double), 1, self -> file) ;
    err = n < 1 ;
    break ;

  default :
    abort() ;
  }

  return err ? VL_ERR_ALLOC : VL_ERR_OK ;
}

// Assembly:
pushq %rax
movl 0x404(%rdi), %eax
cmpl $0x2, %eax
je 0x3e23
cmpl $0x1, %eax
jne 0x3e48
movq 0x808(%rdi), %rdi
leaq 0x2cf2(%rip), %rsi      # 0x6b0d
movb $0x1, %al
popq %rcx
jmp 0x2140
movq %xmm0, %rcx
bswapq %rcx
movq %rsp, %rax
movq %rcx, (%rax)
movq 0x808(%rdi), %rcx
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x2280
popq %rax
retq
callq 0x2040
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r12
leaq 0xe9a(%rip), %r14       # 0x2004
cmpq %r12, %r15
je 0x1182
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
incq %r12
jmp 0x116a
pushq $0xa
popq %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq