LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/computational_geometry.c
// Function: FindEdge
static int FindEdge(const int v0, const int v1, const int n, int e[restrict][EVF])
{
    /* obtain a predefined order */
    const int vMax = (v0 > v1) ? v0 : v1;
    const int vMin = (v0 > v1) ? v1 : v0;
    /* binary search the edge list and return the edge index */
    int i = 0;
    int j = n - 1;
    int k = 0;
    while (i <= j) {
        k = (i + j) / 2;
        if ((vMax == e[k][0]) && (vMin == e[k][1])) {
            return k;
        } else {
            if ((vMax > e[k][0]) || ((vMax == e[k][0]) && (vMin > e[k][1]))) {
                i = k + 1;
            } else {
                j = k - 1;
            }
        }
    }
    /* target was not found */
    ShowError("finding edge failed...");
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x103c5
movl -0x8(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x103cb
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x103e1
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x103e7
movl -0x8(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jg 0x104b4
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x10456
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jne 0x10456
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x104c9
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jg 0x10499
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x104a4
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jle 0x104a4
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x104ad
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x104af
jmp 0x10404
leaq 0x17495(%rip), %rdi     # 0x27950
movb $0x0, %al
callq 0xbbd0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/computational_geometry.c
// Function: ComputeGeometricData
void ComputeGeometricData(const Real p[restrict], const int fid, const Polyhedron *poly,
        Real pi[restrict], Real pm[restrict], Real N[restrict])
{
    if (0 >= poly->faceN) { /* analytical polyhedron */
        Real dist = 0.0;
        N[X] = p[X] - poly->O[X];
        N[Y] = p[Y] - poly->O[Y];
        N[Z] = p[Z] - poly->O[Z];
        dist = Norm(N);
        Normalize(DIMS, dist, N);
        dist = poly->r - dist;
        pi[X] = p[X] + dist * N[X];
        pi[Y] = p[Y] + dist * N[Y];
        pi[Z] = p[Z] + dist * N[Z];
    } else { /* triangulated polyhedron */
        ComputeIntersection(p, fid, poly, pi, N);
    }
    pm[X] = pi[X] + pi[X] - p[X];
    pm[Y] = pi[Y] + pi[Y] - p[Y];
    pm[Z] = pi[Z] + pi[Z] - p[Z];
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jl 0x1060f
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x20(%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x28(%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
subsd 0x30(%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x30(%rbp), %rdi
callq 0x98e0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rsi
movl $0x3, %edi
callq 0x9c60
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movsd -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movsd -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0x10627
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xfcf0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
addsd (%rax), %xmm0
movq -0x8(%rbp), %rax
subsd (%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
addsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x8(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x20(%rbp), %rax
addsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/convective_flux.c
// Function: CharacteristicFlux
static void CharacteristicFlux(const Real Lambda[restrict], Real W[restrict][DIMU],
        const int start, const int wind, const int tot, Real H[restrict][DIMU])
{
    for (int n = start, m = 0; m < tot; n = n + wind, ++m) {
        for (int r = 0; r < DIMU; ++r) {
            H[m][r] = Lambda[r] * W[n][r];
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x10bea
movl $0x0, -0x34(%rbp)
cmpl $0x5, -0x34(%rbp)
jge 0x10bd4
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x10b86
jmp 0x10bd6
movl -0x2c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x10b77
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/convective_flux.c
// Function: InverseProjection
static void InverseProjection(Real R[restrict][DIMU], const Real HhatP[restrict],
        const Real HhatN[restrict], Real Fhat[restrict])
{
    for (int r = 0; r < DIMU; ++r) {
        Fhat[r] = 0.0;
        for (int c = 0; c < DIMU; ++c) {
            Fhat[r] = Fhat[r] + R[r][c] * (HhatP[c] + HhatN[c]);
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jge 0x10ca1
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x28(%rbp)
cmpl $0x5, -0x28(%rbp)
jge 0x10c91
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x10c2c
jmp 0x10c93
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10c0b
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/data_probe.c
// Function: WriteSurfaceForceData
void WriteSurfaceForceData(const Time *time, const Space *space, const Model *model)
{
    if (0 == time->dataN[PROFC]) {
        return;
    }
    FILE *fp = NULL;
    String fname = {'\0'};
    const Geometry *const geo = &(space->geo);
    const Polyhedron *poly = NULL;
    for (int n = 0; n < geo->totN; ++n) {
        poly = geo->poly + n;
        snprintf(fname, sizeof(fname), "%s%03d.csv", "surface_force_", n + 1);
        fp = Fopen(fname, "a");
        if (0 == time->stepC) { /* initialization step */
            fprintf(fp, "# time, Fpx, Fpy, Fpz, Fvx, Fvy, Fvz, Ttx, Tty, Ttz <model.mid=%d>\n", model->mid);
        }
        fprintf(fp, "%.6g, %.6g, %.6g, %.6g, %.6g, %.6g, %.6g, %.6g, %.6g, %.6g\n",
                time->now, poly->Fp[X], poly->Fp[Y], poly->Fp[Z],
                poly->Fv[X], poly->Fv[Y], poly->Fv[Z],
                poly->Tt[X], poly->Tt[Y], poly->Tt[Z]);
        fclose(fp);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl 0x18(%rcx), %eax
jne 0x11f37
jmp 0x120e5
movq $0x0, -0x20(%rbp)
leaq -0xf0(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x20d0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xf8(%rbp)
movq $0x0, -0x100(%rbp)
movl $0x0, -0x104(%rbp)
movl -0x104(%rbp), %eax
movq -0xf8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x120e3
movq -0xf8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x104(%rbp), %rcx
imulq $0x238, %rcx, %rcx      # imm = 0x238
addq %rcx, %rax
movq %rax, -0x100(%rbp)
leaq -0xf0(%rbp), %rdi
movl -0x104(%rbp), %r8d
addl $0x1, %r8d
movl $0xc8, %esi
leaq 0x1599b(%rip), %rdx     # 0x27967
leaq 0x15a55(%rip), %rcx     # 0x27a28
movb $0x0, %al
callq 0x20b0
leaq -0xf0(%rbp), %rdi
leaq 0x15997(%rip), %rsi     # 0x2797f
callq 0xbf90
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
jne 0x12015
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x24(%rax), %edx
leaq 0x15a29(%rip), %rsi     # 0x27a37
movb $0x0, %al
callq 0x2140
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x100(%rbp), %rax
movsd 0x158(%rax), %xmm1
movq -0x100(%rbp), %rax
movsd 0x160(%rax), %xmm2
movq -0x100(%rbp), %rax
movsd 0x168(%rax), %xmm3
movq -0x100(%rbp), %rax
movsd 0x170(%rax), %xmm4
movq -0x100(%rbp), %rax
movsd 0x178(%rax), %xmm5
movq -0x100(%rbp), %rax
movsd 0x180(%rax), %xmm6
movq -0x100(%rbp), %rax
movsd 0x188(%rax), %xmm7
movq -0x100(%rbp), %rax
movsd 0x190(%rax), %xmm9
movq -0x100(%rbp), %rax
movsd 0x198(%rax), %xmm8
leaq 0x15a4f(%rip), %rsi     # 0x27b01
movsd %xmm9, (%rsp)
movsd %xmm8, 0x8(%rsp)
movb $0x8, %al
callq 0x2140
movq -0x20(%rbp), %rdi
callq 0x2080
movl -0x104(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x104(%rbp)
jmp 0x11f76
jmp 0x120e5
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/data_stream.c
// Function: WriteSpaceData
static void WriteSpaceData(const Time *time, const Space *space, const Model *model)
{
    WriteFieldData(time, space, model);
    WriteGeometryData(time, &(space->geo));
    WriteStateData(time);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12850
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x12890
movq -0x8(%rbp), %rdi
callq 0x128d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/data_stream.c
// Function: WriteStateData
static void WriteStateData(const Time *time)
{
    const char *fname = "artracfd.log";
    FILE *fp = Fopen(fname, "w");
    fprintf(fp, "#------------------------------------------------------------------------------\n");
    fprintf(fp, "%d  # completion checkpoint\n", (time->now == time->end) || (time->stepC == time->stepN));
    fprintf(fp, "%d  # data checkpoint\n", time->dataC);
    fprintf(fp, "#------------------------------------------------------------------------------\n");
    fclose(fp);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x152f7(%rip), %rax     # 0x27bda
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1458a(%rip), %rsi     # 0x26e7c
callq 0xbf90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x121e8(%rip), %rsi     # 0x24aee
movb $0x0, %al
callq 0x2140
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq -0x8(%rbp), %rcx
movb $0x1, %al
ucomisd 0x40(%rcx), %xmm0
movb %al, -0x19(%rbp)
jne 0x12932
jp 0x12932
jmp 0x12946
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
sete %al
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rdi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
leaq 0x1528e(%rip), %rsi     # 0x27be7
movb $0x0, %al
callq 0x2140
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %edx
leaq 0x15292(%rip), %rsi     # 0x27c04
movb $0x0, %al
callq 0x2140
movq -0x18(%rbp), %rdi
leaq 0x1216a(%rip), %rsi     # 0x24aee
movb $0x0, %al
callq 0x2140
movq -0x18(%rbp), %rdi
callq 0x2080
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/diffusive_flux.c
// Function: ComputeFvhat
void ComputeFvhat(const int tn, const int s, const int k, const int j, const int i,
        const int partn[restrict], const Real dd[restrict], const Node *const node,
        const Model *model, Real Fvhat[restrict])
{
    const Real zero = 0.0;
    if (zero >= model->refMu) {
        memset(Fvhat, 0, DIMU * sizeof(*Fvhat));
        return;
    }
    ReconstructFvhat[s](tn, k, j, i, partn, dd, node, model, Fvhat);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x20(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd 0x38(%rax), %xmm0
jb 0x12ab5
movq 0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20d0
jmp 0x12af4
movslq -0x10(%rbp), %rcx
leaq 0x1c780(%rip), %rax     # 0x2f240
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq 0x10(%rbp), %r9
movq 0x18(%rbp), %rbx
movq 0x20(%rbp), %r11
movq 0x28(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *%rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_reader.c
// Function: ReadStructuredDataEnsight
void ReadStructuredDataEnsight(Time *time, Space *space, const Model *model)
{
    EnSet enSet = { /* initialize environment */
        .rname = "field",
        .bname = {'\0'},
        .fname = {'\0'},
        .str = {'\0'},
        .fmt = "%s%05d",
        .gtag = {'\0'},
        .vtag = "*****",
        .dtype = "block",
        .part = {PIO, PIO + 1},
        .scaN = 5,
        .sca = {"rho", "u", "v", "w", "p"},
        .vecN = 0,
        .vec = {{'\0'}},
    };
    snprintf(enSet.bname, sizeof(EnStr), enSet.fmt, enSet.rname, time->dataC);
    ReadCaseFile(time, &enSet);
    ReadStructuredData(space, model, &enSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x318(%rbp), %rdi
leaq 0x13067(%rip), %rsi     # 0x27dac
movl $0x300, %edx            # imm = 0x300
callq 0x2150
leaq -0x318(%rbp), %rdi
addq $0x50, %rdi
leaq -0x318(%rbp), %rdx
addq $0x140, %rdx            # imm = 0x140
leaq -0x318(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r8d
movl $0x50, %esi
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rdi
leaq -0x318(%rbp), %rsi
callq 0x14db0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x318(%rbp), %rdx
callq 0x14e70
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_reader.c
// Function: ReadCaseFile
static void ReadCaseFile(Time *time, EnSet *enSet)
{
    snprintf(enSet->fname, sizeof(EnStr), "%s.case", enSet->bname);
    FILE *fp = Fopen(enSet->fname, "r");
    ReadInLine(fp, "VARIABLE");
    Sread(fp, 1, ParseFormat("%*s %*s %*s %*s %lg"), &(time->now));
    Sread(fp, 1, "%*s %*s %*s %*s %d", &(time->stepC));
    fclose(fp);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
movq -0x10(%rbp), %rcx
addq $0x50, %rcx
movl $0x50, %esi
leaq 0x1370d(%rip), %rdx     # 0x284ec
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
leaq 0x129cb(%rip), %rsi     # 0x277c3
callq 0xbf90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x136e8(%rip), %rsi     # 0x284f4
callq 0xbe50
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x136dd(%rip), %rdi     # 0x284fd
callq 0xbbc0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movq -0x8(%rbp), %rcx
addq $0x48, %rcx
movl $0x1, %esi
movb $0x0, %al
callq 0xc1e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movl $0x1, %esi
leaq 0x136b9(%rip), %rdx     # 0x28511
movb $0x0, %al
callq 0xc1e0
movq -0x18(%rbp), %rdi
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_reader.c
// Function: ReadPolyDataEnsight
void ReadPolyDataEnsight(const Time *time, Geometry *const geo)
{
    if (0 != geo->sphN) {
        PointPolyDataReader(time, geo);
    }
    if (0 != geo->stlN) {
        PolygonPolyDataReader(time, geo);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0x4(%rcx), %eax
je 0x15378
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x153a0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
je 0x15390
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15430
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_reader.c
// Function: PointPolyDataReader
static void PointPolyDataReader(const Time *time, Geometry *const geo)
{
    EnSet enSet = { /* initialize environment */
        .rname = "geo_sph",
        .bname = {'\0'},
        .fname = {'\0'},
        .str = {'\0'},
        .fmt = "%s%05d",
        .gtag = "*****",
        .vtag = "*****",
        .dtype = "coordinates",
        .part = {0, 1},
        .scaN = 0,
        .sca = {{'\0'}},
        .vecN = 0,
        .vec = {{'\0'}},
    };
    snprintf(enSet.bname, sizeof(EnStr), enSet.fmt, enSet.rname, time->dataC);
    ReadPolyState(0, geo->sphN, geo, &enSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x310(%rbp), %rdi
leaq 0x12ceb(%rip), %rsi     # 0x280ac
movl $0x300, %edx            # imm = 0x300
callq 0x2150
leaq -0x310(%rbp), %rdi
addq $0x50, %rdi
leaq -0x310(%rbp), %rdx
addq $0x140, %rdx            # imm = 0x140
leaq -0x310(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r8d
movl $0x50, %esi
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x10(%rbp), %rdx
xorl %edi, %edi
leaq -0x310(%rbp), %rcx
callq 0x15610
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_reader.c
// Function: PolygonPolyDataReader
static void PolygonPolyDataReader(const Time *time, Geometry *const geo)
{
    EnSet enSet = { /* initialize environment */
        .rname = "geo_stl",
        .bname = {'\0'},
        .fname = {'\0'},
        .str = {'\0'},
        .fmt = "%s%05d",
        .gtag = "*****",
        .vtag = "*****",
        .dtype = "coordinates",
        .part = {geo->sphN, geo->totN},
        .scaN = 0,
        .sca = {{'\0'}},
        .vecN = 0,
        .vec = {{'\0'}},
    };
    snprintf(enSet.bname, sizeof(EnStr), enSet.fmt, enSet.rname, time->dataC);
    ReadPolygonPolyData(geo->sphN, geo->totN, geo, &enSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x310(%rbp), %rdi
leaq 0x12f5b(%rip), %rsi     # 0x283ac
movl $0x50, %edx
callq 0x2150
leaq -0x310(%rbp), %rdi
addq $0x50, %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x20d0
leaq -0x310(%rbp), %rdi
addq $0xa0, %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x20d0
leaq -0x310(%rbp), %rdi
addq $0xf0, %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x20d0
leaq -0x310(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
leaq 0x12f41(%rip), %rsi     # 0x283fc
movl $0x50, %edx
callq 0x2150
leaq -0x310(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
leaq 0x12f72(%rip), %rsi     # 0x2844c
movl $0x50, %edx
callq 0x2150
leaq -0x310(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
leaq 0x12f53(%rip), %rsi     # 0x2844c
movl $0x50, %edx
callq 0x2150
leaq -0x310(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
leaq 0x12f84(%rip), %rsi     # 0x2849c
movl $0x50, %edx
callq 0x2150
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x8c(%rbp)
movl $0x0, -0x88(%rbp)
leaq -0x310(%rbp), %rdi
addq $0x28c, %rdi            # imm = 0x28C
xorl %esi, %esi
movl $0x64, %edx
callq 0x20d0
movl $0x0, -0x20(%rbp)
leaq -0x310(%rbp), %rcx
addq $0x2f4, %rcx            # imm = 0x2F4
movb $0x0, -0x1c(%rbp)
movq %rcx, %rax
addq $0x1, %rax
addq $0xa, %rcx
movq %rcx, -0x320(%rbp)
movq %rax, -0x318(%rbp)
movq -0x318(%rbp), %rax
movq -0x320(%rbp), %rcx
movb $0x0, (%rax)
addq $0x1, %rax
cmpq %rcx, %rax
movq %rax, -0x318(%rbp)
jne 0x15591
leaq -0x310(%rbp), %rdi
addq $0x50, %rdi
leaq -0x310(%rbp), %rdx
addq $0x140, %rdx            # imm = 0x140
leaq -0x310(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r8d
movl $0x50, %esi
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rdx
leaq -0x310(%rbp), %rcx
callq 0x15690
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_reader.c
// Function: ReadPolyState
static void ReadPolyState(const int pm, const int pn, Geometry *const geo, EnSet *enSet)
{
    snprintf(enSet->fname, sizeof(EnStr), "%s.state", enSet->bname);
    FILE *fp = Fopen(enSet->fname, "r");
    ReadPolyStateData(pm, pn, fp, geo);
    fclose(fp);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
movq -0x18(%rbp), %rcx
addq $0x50, %rcx
movl $0x50, %esi
leaq 0x12ee8(%rip), %rdx     # 0x2852d
movb $0x0, %al
callq 0x20b0
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
leaq 0x12165(%rip), %rsi     # 0x277c3
callq 0xbf90
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x123f0
movq -0x20(%rbp), %rdi
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_writer.c
// Function: WriteStructuredDataEnsight
void WriteStructuredDataEnsight(const Time *time, const Space *space, const Model *model)
{
    EnSet enSet = { /* initialize environment */
        .rname = "field",
        .bname = {'\0'},
        .fname = {'\0'},
        .str = {'\0'},
        .fmt = "%s%05d",
        .gtag = {'\0'},
        .vtag = "*****",
        .dtype = "block",
        .part = {PIO, PIO + 1},
        .scaN = 7,
        .sca = {"rho", "u", "v", "w", "p", "T", "did"},
        .vecN = 1,
        .vec = {"Vel"},
    };
    snprintf(enSet.bname, sizeof(EnStr), enSet.fmt, enSet.rname, time->dataC);
    if (0 == time->stepC) { /* initialization step */
        InitializeTransientCaseFile(&enSet);
        WriteGeometryFile(space, &enSet);
    }
    WriteCaseFile(time, &enSet);
    WriteStructuredData(space, model, &enSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x318(%rbp), %rdi
leaq 0x12a5f(%rip), %rsi     # 0x28564
movl $0x300, %edx            # imm = 0x300
callq 0x2150
leaq -0x318(%rbp), %rdi
addq $0x50, %rdi
leaq -0x318(%rbp), %rdx
addq $0x140, %rdx            # imm = 0x140
leaq -0x318(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r8d
movl $0x50, %esi
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
jne 0x15b6a
leaq -0x318(%rbp), %rdi
callq 0x15ba0
movq -0x10(%rbp), %rdi
leaq -0x318(%rbp), %rsi
callq 0x15de0
movq -0x8(%rbp), %rdi
leaq -0x318(%rbp), %rsi
callq 0x162a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x318(%rbp), %rdx
callq 0x16590
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_writer.c
// Function: WritePolyDataEnsight
void WritePolyDataEnsight(const Time *time, const Geometry *const geo)
{
    if (0 != geo->sphN) {
        PointPolyDataWriter(time, geo);
    }
    if (0 != geo->stlN) {
        PolygonPolyDataWriter(time, geo);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0x4(%rcx), %eax
je 0x16ca8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16cd0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
je 0x16cc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16d80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_writer.c
// Function: PointPolyDataWriter
static void PointPolyDataWriter(const Time *time, const Geometry *const geo)
{
    EnSet enSet = { /* initialize environment */
        .rname = "geo_sph",
        .bname = {'\0'},
        .fname = {'\0'},
        .str = {'\0'},
        .fmt = "%s%05d",
        .gtag = "*****",
        .vtag = "*****",
        .dtype = "coordinates",
        .part = {0, 1},
        .scaN = 2,
        .sca = {"r", "did"},
        .vecN = 1,
        .vec = {"Vel"},
    };
    snprintf(enSet.bname, sizeof(EnStr), enSet.fmt, enSet.rname, time->dataC);
    if (0 == time->stepC) { /* initialization step */
        InitializeTransientCaseFile(&enSet);
    }
    WriteCaseFile(time, &enSet);
    WritePointPolyData(0, geo->sphN, geo, &enSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x310(%rbp), %rdi
leaq 0x11b73(%rip), %rsi     # 0x28864
movl $0x300, %edx            # imm = 0x300
callq 0x2150
leaq -0x310(%rbp), %rdi
addq $0x50, %rdi
leaq -0x310(%rbp), %rdx
addq $0x140, %rdx            # imm = 0x140
leaq -0x310(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r8d
movl $0x50, %esi
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
jne 0x16d46
leaq -0x310(%rbp), %rdi
callq 0x15ba0
movq -0x8(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x162a0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x10(%rbp), %rdx
xorl %edi, %edi
leaq -0x310(%rbp), %rcx
callq 0x16f90
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_writer.c
// Function: PolygonPolyDataWriter
static void PolygonPolyDataWriter(const Time *time, const Geometry *const geo)
{
    EnSet enSet = { /* initialize environment */
        .rname = "geo_stl",
        .bname = {'\0'},
        .fname = {'\0'},
        .str = {'\0'},
        .fmt = "%s%05d",
        .gtag = "*****",
        .vtag = "*****",
        .dtype = "coordinates",
        .part = {geo->sphN, geo->totN},
        .scaN = 0,
        .sca = {{'\0'}},
        .vecN = 0,
        .vec = {{'\0'}},
    };
    snprintf(enSet.bname, sizeof(EnStr), enSet.fmt, enSet.rname, time->dataC);
    if (0 == time->stepC) { /* initialization step */
        InitializeTransientCaseFile(&enSet);
    }
    WriteCaseFile(time, &enSet);
    WritePolygonPolyData(geo->sphN, geo->totN, geo, &enSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x310(%rbp), %rdi
leaq 0x11dc3(%rip), %rsi     # 0x28b64
movl $0x50, %edx
callq 0x2150
leaq -0x310(%rbp), %rdi
addq $0x50, %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x20d0
leaq -0x310(%rbp), %rdi
addq $0xa0, %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x20d0
leaq -0x310(%rbp), %rdi
addq $0xf0, %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x20d0
leaq -0x310(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
leaq 0x11da9(%rip), %rsi     # 0x28bb4
movl $0x50, %edx
callq 0x2150
leaq -0x310(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
leaq 0x11dda(%rip), %rsi     # 0x28c04
movl $0x50, %edx
callq 0x2150
leaq -0x310(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
leaq 0x11dbb(%rip), %rsi     # 0x28c04
movl $0x50, %edx
callq 0x2150
leaq -0x310(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
leaq 0x11dec(%rip), %rsi     # 0x28c54
movl $0x50, %edx
callq 0x2150
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x8c(%rbp)
movl $0x0, -0x88(%rbp)
leaq -0x310(%rbp), %rdi
addq $0x28c, %rdi            # imm = 0x28C
xorl %esi, %esi
movl $0x64, %edx
callq 0x20d0
movl $0x0, -0x20(%rbp)
leaq -0x310(%rbp), %rcx
addq $0x2f4, %rcx            # imm = 0x2F4
movb $0x0, -0x1c(%rbp)
movq %rcx, %rax
addq $0x1, %rax
addq $0xa, %rcx
movq %rcx, -0x320(%rbp)
movq %rax, -0x318(%rbp)
movq -0x318(%rbp), %rax
movq -0x320(%rbp), %rcx
movb $0x0, (%rax)
addq $0x1, %rax
cmpq %rcx, %rax
movq %rax, -0x318(%rbp)
jne 0x16ee1
leaq -0x310(%rbp), %rdi
addq $0x50, %rdi
leaq -0x310(%rbp), %rdx
addq $0x140, %rdx            # imm = 0x140
leaq -0x310(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x38(%rax), %r8d
movl $0x50, %esi
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
jne 0x16f4d
leaq -0x310(%rbp), %rdi
callq 0x15ba0
movq -0x8(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x162a0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rdx
leaq -0x310(%rbp), %rcx
callq 0x17860
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/ensight_writer.c
// Function: WritePolyState
static void WritePolyState(const int pm, const int pn, const Geometry *const geo, EnSet *enSet)
{
    snprintf(enSet->fname, sizeof(EnStr), "%s.state", enSet->bname);
    FILE *fp = Fopen(enSet->fname, "w");
    WritePolyStateData(pm, pn, fp, geo);
    fclose(fp);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
movq -0x18(%rbp), %rcx
addq $0x50, %rcx
movl $0x50, %esi
leaq 0x10d18(%rip), %rdx     # 0x2852d
movb $0x0, %al
callq 0x20b0
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
leaq 0xf64e(%rip), %rsi      # 0x26e7c
callq 0xbf90
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x12170
movq -0x20(%rbp), %rdi
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/fluid_dynamics.c
// Function: RungeKutta2
static void RungeKutta2(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 U(n+1) = LLLU = 1.0/2.0 * Un + 1.0/2.0 * LLU1 */
    LLLU(dt, 1.0/2.0, 1.0/2.0, TO, TN, TO, s, space, model);
    TreatBoundary(TO, space, model);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
xorps %xmm1, %xmm1
movsd 0xf5dd(%rip), %xmm2     # 0x27710
xorl %esi, %esi
movl $0x1, %edx
movl %esi, %edi
callq 0x18280
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %edi
callq 0x2320
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
movsd 0xf59d(%rip), %xmm2     # 0x27708
xorl %edx, %edx
movl $0x1, %esi
movaps %xmm2, %xmm1
movl %edx, %edi
callq 0x18280
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %edi, %edi
callq 0x2320
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
xorps %xmm1, %xmm1
movsd 0xf53d(%rip), %xmm2     # 0x27710
xorl %esi, %esi
movl $0x1, %edx
movl %esi, %edi
callq 0x18280
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %edi
callq 0x2320
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
movsd 0x10cfd(%rip), %xmm1    # 0x28f08
movsd 0xfa15(%rip), %xmm2     # 0x27c28
xorl %edi, %edi
movl $0x1, %esi
movl $0x2, %edx
callq 0x18280
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x2, %edi
callq 0x2320
movsd -0x8(%rbp), %xmm0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
movsd 0x10caa(%rip), %xmm1    # 0x28ef8
movsd 0x10caa(%rip), %xmm2    # 0x28f00
xorl %edx, %edx
movl $0x2, %esi
movl %edx, %edi
callq 0x18280
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %edi, %edi
callq 0x2320
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movl $0x1, %eax
cmpl -0x4(%rbp), %eax
jne 0x18b2d
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
je 0x18b2d
movl $0x0, -0x44(%rbp)
cmpl $0x5, -0x44(%rbp)
jge 0x18b2b
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x18(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movq -0x40(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x18ae1
jmp 0x18b9e
movl $0x0, -0x48(%rbp)
cmpl $0x5, -0x48(%rbp)
jge 0x18b9c
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rbp), %xmm1
movq -0x28(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm4
movsd -0x38(%rbp), %xmm3
movq -0x40(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm5
mulsd %xmm5, %xmm3
addsd %xmm4, %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x18b34
jmp 0x18b9e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/immersed_boundary.c
// Function: ComputeGeometricField
void ComputeGeometricField(Space *space, const Model *model)
{
    InitializeGeometricField(space);
    SetDomainField(space);
    SetInterfacialField(space, model);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18c60
movq -0x8(%rbp), %rdi
callq 0x18e10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19360
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/immersed_boundary.c
// Function: DoMethodOfImage
void DoMethodOfImage(const Real UoI[restrict], const Real UoO[restrict], Real UoG[restrict])
{
    /*
     * Apply the method of image.
     *  -- reflecting vectors over wall for slip and noslip as well as stationary
     *     and moving conditions is unified by linear interpolation.
     *  -- scalars are symmetrically reflected between image and ghost.
     *  -- other scalars are determined by equation of state.
     */
    UoG[1] = UoO[1] + UoO[1] - UoI[1];
    UoG[2] = UoO[2] + UoO[2] - UoI[2];
    UoG[3] = UoO[3] + UoO[3] - UoI[3];
    UoG[4] = UoI[4];
    UoG[5] = UoI[5];
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
addsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
addsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x10(%rbp), %rax
addsd 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd 0xccbe(%rip), %xmm0     # 0x27710
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x1aa6d
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0xcc9b(%rip), %xmm0     # 0x27710
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x6, -0x34(%rbp)
jge 0x1aacb
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1aa86
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/initialization.c
// Function: InitializeComputeDomain
void InitializeComputeDomain(Time *time, Space *space, const Model *model)
{
    if (0 == time->restart) { /* non restart */
        InitializeSpaceData(space, model);
    } else {
        ReadData(PROSD, time, space, model);
    }
    ComputeGeometryParameters(space->part.collapse, &(space->geo));
    WritePolyMassProperty(&(space->geo));
    ComputeGeometricField(space, model);
    TreatBoundary(TO, space, model);
    IdentifyGeometryState(&(space->geo));
    if (0 == time->restart) { /* non restart */
        WriteData(PROPT, time, space, model);
        WriteData(PROFC, time, space, model);
        WriteData(PROSD, time, space, model);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x1ab1d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1abd0
jmp 0x1ab33
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x4, %edi
callq 0x12130
movq -0x10(%rbp), %rax
movl 0x50(%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xd880
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1ac00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18c20
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %edi, %edi
callq 0x2320
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1ae50
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x1abc6
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %edi, %edi
callq 0x120f0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x3, %edi
callq 0x120f0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x4, %edi
callq 0x120f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/linear_system.c
// Function: SolveLinearSystem
int SolveLinearSystem(const int n, Real A[restrict][n], const int m,
        Real X[restrict][m], Real B[restrict][m])
{
    int permute[n]; /* record the permutation information */
    Real rhs[n]; /* transfer data into column vector */
    LUFactorization(n, A, permute);
    for (int col = 0; col < m; ++col) { /* solve column by column */
        for (int row = 0; row < n; ++row) {
            rhs[row] = B[row][col]; /* obtain each right hand side vector */
        }
        SolveFactorizedLinearSystem(n, A, A, rhs, rhs, permute);
        for (int row = 0; row < n; ++row) { /* save solution vector */
            X[row][col] = rhs[row];
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x4(%rbp), %eax
movl -0x14(%rbp), %ecx
movq %rcx, -0x70(%rbp)
movq %rcx, -0x68(%rbp)
movq %rsp, %rcx
movq %rcx, -0x30(%rbp)
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0x60(%rbp)
movq %rdx, %rsp
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %eax
leaq 0xf(,%rax,8), %rsi
andq $-0x10, %rsi
movq %rsp, %rcx
subq %rsi, %rcx
movq %rcx, -0x58(%rbp)
movq %rcx, %rsp
movq %rax, -0x40(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1be50
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1be34
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1bdc2
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rsi
movq -0x28(%rbp), %rcx
movslq -0x48(%rbp), %rdx
imulq %rsi, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movslq -0x44(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movslq -0x48(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x1bd82
movq -0x60(%rbp), %r9
movq -0x58(%rbp), %r8
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %r8, %rcx
callq 0x1c2c0
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1be24
movq -0x70(%rbp), %rdx
movq -0x58(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x4c(%rbp), %rcx
imulq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x44(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1bde4
jmp 0x1be26
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1bd6f
movq -0x30(%rbp), %rax
movq %rax, %rsp
xorl %eax, %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x550, %rsp            # imm = 0x550
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xcc18(%rip), %rax      # 0x29118
movq %rax, -0x20(%rbp)
movq 0xcc15(%rip), %rax      # 0x29120
movq %rax, -0x18(%rbp)
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x20d0
leaq -0x4b8(%rbp), %rdi
xorl %esi, %esi
movl $0x430, %edx            # imm = 0x430
callq 0x20d0
leaq -0x550(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x20d0
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x4b8(%rbp), %rcx
callq 0x1f700
leaq -0x88(%rbp), %rdi
leaq -0x4b8(%rbp), %rsi
leaq -0x550(%rbp), %rdx
callq 0x1f580
leaq -0x88(%rbp), %rdi
leaq -0x4b8(%rbp), %rsi
leaq -0x550(%rbp), %rdx
callq 0x22140
leaq -0x88(%rbp), %rdi
leaq -0x4b8(%rbp), %rsi
leaq -0x550(%rbp), %rdx
callq 0x1f380
xorl %edi, %edi
callq 0x21e0
nopw %cs:(%rax,%rax)
nop