LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/case_loader.c
// Function: ReadConsecutiveData
static void ReadConsecutiveData(FILE *fp, const int n, const char *fmt,
        Real *preal, char pstr[][VARSTR])
{
    if (NULL != preal) {
        for (int m = 0; m < n; ++m) {
            Sread(fp, 1, fmt, preal + m);
        }
    } else {
        String str = {'\0'};
        for (int m = 0; m < n; ++m) {
            ParseCommand(fgets(str, sizeof str, fp));
            strncpy(pstr[m], str, sizeof pstr[m]);
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x8065
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8063
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movl $0x1, %esi
movb $0x0, %al
callq 0xc1e0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x802d
jmp 0x80e0
leaq -0x100(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x20d0
movl $0x0, -0x104(%rbp)
movl -0x104(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x80de
leaq -0x100(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0xc8, %esi
callq 0x2110
movq %rax, %rdi
callq 0xb940
movq -0x28(%rbp), %rdi
movslq -0x104(%rbp), %rax
imulq $0x64, %rax, %rax
addq %rax, %rdi
leaq -0x100(%rbp), %rsi
movl $0x64, %edx
callq 0x2040
movl -0x104(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x104(%rbp)
jmp 0x8082
jmp 0x80e0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: Eigenvalue
void Eigenvalue(const int s, const Real Uo[restrict], Real Lambda[restrict])
{
    Lambda[0] = Uo[s+1] - Uo[5];
    Lambda[1] = Uo[s+1];
    Lambda[2] = Uo[s+1];
    Lambda[3] = Uo[s+1];
    Lambda[4] = Uo[s+1] + Uo[5];
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
subsd 0x28(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
addsd 0x28(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: EigenvectorL
void EigenvectorL(const int s, const Real gamma, const Real Uo[restrict], Real L[restrict][DIMU])
{
    const Real u = Uo[1];
    const Real v = Uo[2];
    const Real w = Uo[3];
    const Real c = Uo[5];
    const Real q = 0.5 * (u * u + v * v + w * w);
    const Real b = (gamma - 1.0) / (2.0 * c * c);
    const Real d = 1.0 / (2.0 * c);
    ComputeEigenvectorL[s](u, v, w, q, b, d, L);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x1e7f2(%rip), %xmm0    # 0x27708
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x1e7e4(%rip), %xmm1    # 0x27710
subsd %xmm1, %xmm0
movsd 0x1e7e8(%rip), %xmm1    # 0x27720
mulsd -0x40(%rbp), %xmm1
mulsd -0x40(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x1e7cd(%rip), %xmm1    # 0x27720
mulsd -0x40(%rbp), %xmm1
movsd 0x1e7b0(%rip), %xmm0    # 0x27710
divsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x261bc(%rip), %rax     # 0x2f130
movq (%rax,%rcx,8), %rax
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x48(%rbp), %xmm3
movsd -0x50(%rbp), %xmm4
movsd -0x58(%rbp), %xmm5
movq -0x20(%rbp), %rdi
callq *%rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: EigenvectorR
void EigenvectorR(const int s, const Real Uo[restrict], Real R[restrict][DIMU])
{
    const Real u = Uo[1];
    const Real v = Uo[2];
    const Real w = Uo[3];
    const Real hT = Uo[4];
    const Real c = Uo[5];
    const Real q = 0.5 * (u * u + v * v + w * w);
    ComputeEigenvectorR[s](u, v, w, hT, c, q, R);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x1e6c9(%rip), %xmm0    # 0x27708
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x260fd(%rip), %rax     # 0x2f150
movq (%rax,%rcx,8), %rax
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm3
movsd -0x40(%rbp), %xmm4
movsd -0x48(%rbp), %xmm5
movq -0x18(%rbp), %rdi
callq *%rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: ConvectiveFlux
void ConvectiveFlux(const int s, const Real gamma, const Real U[restrict], Real F[restrict])
{
    const Real rho = U[0];
    const Real u = U[1] / U[0];
    const Real v = U[2] / U[0];
    const Real w = U[3] / U[0];
    const Real eT = U[4] / U[0];
    const Real p = ComputePressure(gamma, U);
    ComputeConvectiveFlux[s](rho, u, v, w, eT, p, F);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
divsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
divsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
divsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x18(%rbp), %rax
divsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x9160
movsd %xmm0, -0x50(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x26045(%rip), %rax     # 0x2f170
movq (%rax,%rcx,8), %rax
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movsd -0x40(%rbp), %xmm3
movsd -0x48(%rbp), %xmm4
movsd -0x50(%rbp), %xmm5
movq -0x20(%rbp), %rdi
callq *%rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: MapPrimitive
void MapPrimitive(const Real gamma, const Real gasR, const Real U[restrict], Real Uo[restrict])
{
    Uo[0] = U[0];
    Uo[1] = U[1] / U[0];
    Uo[2] = U[2] / U[0];
    Uo[3] = U[3] / U[0];
    Uo[4] = (U[4] - 0.5 * (U[1] * U[1] + U[2] * U[2] + U[3] * U[3]) / U[0]) * (gamma - 1.0);
    Uo[5] = Uo[4] / (Uo[0] * gasR);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
divsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
divsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
divsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm3
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm2
movq -0x18(%rbp), %rax
mulsd 0x10(%rax), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm3
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd 0x1e3ed(%rip), %xmm1    # 0x27708
mulsd %xmm2, %xmm1
movq -0x18(%rbp), %rax
divsd (%rax), %xmm1
subsd %xmm1, %xmm0
movsd -0x8(%rbp), %xmm1
movsd 0x1e3d8(%rip), %xmm2    # 0x27710
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x20(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
mulsd -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x28(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: MapConservative
void MapConservative(const Real gamma, const Real Uo[restrict], Real U[restrict])
{
    U[0] = Uo[0];
    U[1] = Uo[0] * Uo[1];
    U[2] = Uo[0] * Uo[2];
    U[3] = Uo[0] * Uo[3];
    U[4] = 0.5 * Uo[0] * (Uo[1] * Uo[1] + Uo[2] * Uo[2] + Uo[3] * Uo[3]) + Uo[4] / (gamma - 1.0);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
movsd 0x1e28d(%rip), %xmm0    # 0x27708
mulsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm3
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm2
movq -0x10(%rbp), %rax
mulsd 0x10(%rax), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm3
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm1
movsd -0x8(%rbp), %xmm3
movsd 0x1e235(%rip), %xmm4    # 0x27710
subsd %xmm4, %xmm3
divsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: InPartBox
int InPartBox(const int k, const int j, const int i, const int pbox[restrict][LIMIT])
{
    return
        (pbox[Z][MIN] <= k) && (pbox[Z][MAX] > k) &&
        (pbox[Y][MIN] <= j) && (pbox[Y][MAX] > j) &&
        (pbox[X][MIN] <= i) && (pbox[X][MAX] > i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x19(%rbp)
jg 0x95a5
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x19(%rbp)
jle 0x95a5
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x19(%rbp)
jg 0x95a5
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x19(%rbp)
jle 0x95a5
movq -0x18(%rbp), %rax
movl (%rax), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x19(%rbp)
jg 0x95a5
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
setg %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: EqualReal
int EqualReal(const Real x, const Real y)
{
    const Real epsilon = DBL_EPSILON;
    const Real diffMax = FLT_MIN;
    const Real diff = fabs(x - y);
    if (diff <= diffMax) {
        return 1;
    }
    const Real absx = fabs(x);
    const Real absy = fabs(y);
    const Real absMax = (absx > absy) ? absx : absy;
    return (diff <= epsilon * absMax);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd 0x1dfea(%rip), %xmm0    # 0x27750
movsd %xmm0, -0x20(%rbp)
movsd 0x1dfd5(%rip), %xmm0    # 0x27748
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movaps 0x1ade7(%rip), %xmm1    # 0x24570
pand %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x1dfae(%rip), %xmm0    # 0x27748
ucomisd -0x30(%rbp), %xmm0
jb 0x97aa
movl $0x1, -0x4(%rbp)
jmp 0x9821
movsd -0x10(%rbp), %xmm0
movaps 0x1adba(%rip), %xmm1    # 0x24570
pand %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movaps 0x1ada5(%rip), %xmm1    # 0x24570
pand %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0x97ec
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0x97f6
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm1
movsd 0x1df43(%rip), %xmm0    # 0x27750
mulsd -0x48(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: Sign
int Sign(const Real x)
{
    const Real zero = 0.0;
    if (zero < x) {
        return 1;
    }
    if (zero > x) {
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9858
movl $0x1, -0x4(%rbp)
jmp 0x9872
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x986b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9872
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: Cross
void Cross(const Real V1[restrict], const Real V2[restrict], Real V[restrict])
{
    V[X] = V1[Y] * V2[Z] - V1[Z] * V2[Y];
    V[Y] = V1[Z] * V2[X] - V1[X] * V2[Z];
    V[Z] = V1[X] * V2[Y] - V1[Y] * V2[X];
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm2
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x10(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: OrthogonalSpace
void OrthogonalSpace(const Real N[restrict], Real Ta[restrict], Real Tb[restrict])
{
    int mark = Z; /* default mark for minimum component */
    if (fabs(N[mark]) > fabs(N[Y])) {
        mark = Y;
    }
    if (fabs(N[mark]) > fabs(N[X])) {
        mark = X;
    }
    if (X == mark) {
        Ta[X] = 0.0;
        Ta[Y] = -N[Z];
        Ta[Z] = N[Y];
    } else {
        if (Y == mark) {
            Ta[X] = N[Z];
            Ta[Y] = 0.0;
            Ta[Z] = -N[X];
        } else {
            Ta[X] = -N[Y];
            Ta[Y] = N[X];
            Ta[Z] = 0.0;
        }
    }
    Normalize(DIMS, Norm(Ta), Ta);
    Cross(Ta, N, Tb);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x2, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0x1aa91(%rip), %xmm1    # 0x24570
pand %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movaps 0x1aa7d(%rip), %xmm2    # 0x24570
pand %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9b04
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0x1aa58(%rip), %xmm1    # 0x24570
pand %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movaps 0x1aa45(%rip), %xmm2    # 0x24570
pand %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9b3c
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
jne 0x9b8e
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0x9c26
movl $0x1, %eax
cmpl -0x1c(%rbp), %eax
jne 0x9bdf
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0x9c24
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0x9c26
movq -0x10(%rbp), %rdi
callq 0x98e0
movq -0x10(%rbp), %rsi
movl $0x3, %edi
callq 0x9c60
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x99b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: LocalLaxFriedrichs
static void LocalLaxFriedrichs(const Real Lambda[restrict],
        Real LambdaP[restrict], Real LambdaN[restrict])
{
    /* set local maximum as (|Vs| + c) */
    const Real lambdaStar = fabs(Lambda[2]) + Lambda[4] - Lambda[2];
    for (int r = 0; r < DIMU; ++r) {
        LambdaP[r] = 0.5 * (Lambda[r] + lambdaStar);
        LambdaN[r] = 0.5 * (Lambda[r] - lambdaStar);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movaps 0x1a8a0(%rip), %xmm1    # 0x24570
pand %xmm1, %xmm0
movq -0x8(%rbp), %rax
addsd 0x20(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jge 0x9d59
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
addsd -0x20(%rbp), %xmm1
movsd 0x1d9f6(%rip), %xmm0    # 0x27708
mulsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
subsd -0x20(%rbp), %xmm1
movsd 0x1d9cb(%rip), %xmm0    # 0x27708
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9cf2
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: StegerWarming
static void StegerWarming(const Real Lambda[restrict],
        Real LambdaP[restrict], Real LambdaN[restrict])
{
    const Real epsilon = 1.0e-3;
    for (int r = 0; r < DIMU; ++r) {
        LambdaP[r] = 0.5 * (Lambda[r] + sqrt(Lambda[r] * Lambda[r] + epsilon * epsilon));
        LambdaN[r] = 0.5 * (Lambda[r] - sqrt(Lambda[r] * Lambda[r] + epsilon * epsilon));
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd 0x1d9dc(%rip), %xmm0    # 0x27758
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jge 0x9e66
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1d996(%rip), %xmm1    # 0x27760
addsd %xmm1, %xmm0
callq 0x2200
movsd -0x38(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd 0x1d924(%rip), %xmm0    # 0x27708
mulsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1d933(%rip), %xmm1    # 0x27760
addsd %xmm1, %xmm0
callq 0x2200
movsd -0x30(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd 0x1d8c1(%rip), %xmm0    # 0x27708
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9d88
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/cfd_commons.c
// Function: ConvectiveFluxX
static void ConvectiveFluxX(const Real rho, const Real u, const Real v, const Real w,
        const Real eT, const Real p, Real F[restrict])
{
    F[0] = rho * u;
    F[1] = rho * u * u + p;
    F[2] = rho * u * v;
    F[3] = rho * u * w;
    F[4] = (rho * eT + p) * u;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm5, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x8(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x8(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x8(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movsd -0x8(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd -0x10(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/commons.c
// Function: ShowError
void ShowError(const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    verror("error", fmt, args);
    va_end(args);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xbc05
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq 0x1bb66(%rip), %rdi     # 0x277c5
callq 0xbc80
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/commons.c
// Function: verror
void verror(const char *prefix, const char *fmt, va_list args)
{
    fprintf(stderr, "%s: ", prefix);
    vfprintf(stderr, fmt, args);
    fprintf(stderr, "\n");
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x2335d(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1bb2a(%rip), %rsi     # 0x277d3
movb $0x0, %al
callq 0x2140
movq 0x23341(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x21b0
movq 0x2332a(%rip), %rax     # 0x2eff8
movq (%rax), %rdi
leaq 0x1d08b(%rip), %rsi     # 0x28d63
movb $0x0, %al
callq 0x2140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/commons.c
// Function: ShowInfo
void ShowInfo(const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    if (0 == strcmp(fmt, "Session")) {
        fprintf(stdout, "************************************************************\n");
    } else {
        vfprintf(stdout, fmt, args);
    }
    va_end(args);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xbd25
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x18805(%rip), %rsi     # 0x24580
callq 0x2120
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xbda2
movq 0x23241(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
leaq 0x1ba3f(%rip), %rsi     # 0x277d8
movb $0x0, %al
callq 0x2140
jmp 0xbdb9
movq 0x23227(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x21b0
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/commons.c
// Function: AssignStorage
void *AssignStorage(size_t size)
{
    void *pointer = malloc(size);
    if (NULL == pointer) {
        ShowError("memory allocation failed");
    }
    memset(pointer, 0, size);
    return pointer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2170
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0xbdff
leaq 0x1ba1e(%rip), %rdi     # 0x27816
movb $0x0, %al
callq 0xbbd0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x20d0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/commons.c
// Function: ReadInLine
void ReadInLine(FILE *fp, const char *line)
{
    String str = {'\0'}; /* store the current read line */
    while (NULL != fgets(str, sizeof str, fp)) {
        ParseCommand(str);
        if (0 == strncmp(str, line, sizeof str)) {
            fseek(fp, 0, SEEK_CUR); /* update offset */
            break;
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x20d0
leaq -0xe0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0xc8, %esi
callq 0x2110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xbed4
leaq -0xe0(%rbp), %rdi
callq 0xb940
leaq -0xe0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xc8, %edx
callq 0x2050
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xbed2
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x2180
jmp 0xbed4
jmp 0xbe76
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/commons.c
// Function: WriteToLine
void WriteToLine(FILE *fp, const char *line)
{
    String str = {'\0'}; /* store the current read line */
    fpos_t pos; /* store position indicator */
    /* find the offset */
    fgetpos(fp, &pos);
    while (NULL != fgets(str, sizeof str, fp)) {
        ParseCommand(str);
        if (0 == strncmp(str, line, sizeof str)) {
            fsetpos(fp, &pos); /* redirect to the target line */
            break;
        }
        fgetpos(fp, &pos);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x20d0
movq -0x8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x20a0
leaq -0xe0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0xc8, %esi
callq 0x2110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0xbf82
leaq -0xe0(%rbp), %rdi
callq 0xb940
leaq -0xe0(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xc8, %edx
callq 0x2050
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0xbf70
movq -0x8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x21d0
jmp 0xbf82
movq -0x8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x20a0
jmp 0xbf16
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/commons.c
// Function: Fopen
FILE *Fopen(const char *fname, const char *mode)
{
    FILE *fp = fopen(fname, mode);
    if (NULL == fp) {
        ShowError("failed to open file: %s, mode: %s", fname, mode);
    }
    return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21a0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0xbfcf
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x1b867(%rip), %rdi     # 0x2782f
movb $0x0, %al
callq 0xbbd0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/commons.c
// Function: Fscanf
void Fscanf(FILE *stream, const int n, const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    if ((n != vfscanf(stream, fmt, args)) && (0 < n)) {
        ShowError("vfscanf failed: n: %d, fmt: %s", n, fmt);
    }
    va_end(args);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xc078
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movl -0xc(%rbp), %eax
movl %eax, -0xe4(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2090
movl %eax, %ecx
movl -0xe4(%rbp), %eax
cmpl %ecx, %eax
je 0xc0fe
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jge 0xc0fe
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq 0x1b778(%rip), %rdi     # 0x2786f
movb $0x0, %al
callq 0xbbd0
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/commons.c
// Function: Sscanf
void Sscanf(const char *str, const int n, const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    if ((n != vsscanf(str, fmt, args)) && (0 < n)) {
        ShowError("vsscanf failed: str: %s, fmt: %s", str, fmt);
    }
    va_end(args);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xc148
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movl -0xc(%rbp), %eax
movl %eax, -0xe4(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2160
movl %eax, %ecx
movl -0xe4(%rbp), %eax
cmpl %ecx, %eax
je 0xc1cf
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jge 0xc1cf
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1b6c6(%rip), %rdi     # 0x2788e
movb $0x0, %al
callq 0xbbd0
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/commons.c
// Function: Sread
void Sread(FILE *stream, const int n, const char *fmt, ...)
{
    String str = {'\0'};
    if (NULL == fgets(str, sizeof str, stream))
    {
        ShowWarning("fgets return a NULL");
    }
    if (0 == n) {
        return;
    }
    va_list args;
    va_start(args, fmt);
    if ((n != vsscanf(str, fmt, args)) && (0 < n)) {
        ShowError("vsscanf failed: str: %s, fmt: %s", str, fmt);
    }
    va_end(args);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
testb %al, %al
je 0xc227
movaps %xmm0, -0x180(%rbp)
movaps %xmm1, -0x170(%rbp)
movaps %xmm2, -0x160(%rbp)
movaps %xmm3, -0x150(%rbp)
movaps %xmm4, -0x140(%rbp)
movaps %xmm5, -0x130(%rbp)
movaps %xmm6, -0x120(%rbp)
movaps %xmm7, -0x110(%rbp)
movq %r9, -0x188(%rbp)
movq %r8, -0x190(%rbp)
movq %rcx, -0x198(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x20d0
leaq -0xe0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0xc8, %esi
callq 0x2110
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0xc287
leaq 0x1b62f(%rip), %rdi     # 0x278af
movb $0x0, %al
callq 0xbb20
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jne 0xc290
jmp 0xc30a
leaq -0x100(%rbp), %rax
leaq -0x1b0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x1b4(%rbp)
leaq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0x2160
movl %eax, %ecx
movl -0x1b4(%rbp), %eax
cmpl %ecx, %eax
je 0xc303
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jge 0xc303
leaq -0xe0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1b592(%rip), %rdi     # 0x2788e
movb $0x0, %al
callq 0xbbd0
leaq -0x100(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/computational_geometry.c
// Function: AllocatePolyhedronMemory
void AllocatePolyhedronMemory(const int vertN, const int edgeN,
        const int faceN, Polyhedron *poly)
{
    poly->f = AssignStorage(faceN * sizeof(*poly->f));
    poly->Nf = AssignStorage(faceN * sizeof(*poly->Nf));
    poly->e = AssignStorage(edgeN * sizeof(*poly->e));
    poly->Ne = AssignStorage(edgeN * sizeof(*poly->Ne));
    poly->v = AssignStorage(vertN * sizeof(*poly->v));
    poly->Nv = AssignStorage(vertN * sizeof(*poly->Nv));
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movslq -0xc(%rbp), %rax
imulq $0xc, %rax, %rdi
callq 0xbdd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x200(%rax)
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rdi
callq 0xbdd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x208(%rax)
movslq -0x8(%rbp), %rdi
shlq $0x4, %rdi
callq 0xbdd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x210(%rax)
movslq -0x8(%rbp), %rax
imulq $0x18, %rax, %rdi
callq 0xbdd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x218(%rax)
movslq -0x4(%rbp), %rax
imulq $0x18, %rax, %rdi
callq 0xbdd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x220(%rax)
movslq -0x4(%rbp), %rax
imulq $0x18, %rax, %rdi
callq 0xbdd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x228(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/computational_geometry.c
// Function: AddVertex
static int AddVertex(const Real v[restrict], Polyhedron *poly)
{
    /* search the vertex list, if already exist, return the index */
    for (int n = 0; n < poly->vertN; ++n) {
        if ((v[X] == poly->v[n][X]) && (v[Y] == poly->v[n][Y]) &&
                (v[Z] == poly->v[n][Z])) {
            return n;
        }
    }
    /* otherwise, add to the vertex list */
    poly->v[poly->vertN][X] = v[X];
    poly->v[poly->vertN][Y] = v[Y];
    poly->v[poly->vertN][Z] = v[Z];
    ++(poly->vertN); /* increase pointer */
    return (poly->vertN - 1); /* return index */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xc744
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movq 0x220(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
ucomisd (%rax), %xmm0
jne 0xc734
jp 0xc734
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movq 0x220(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
ucomisd 0x8(%rax), %xmm0
jne 0xc734
jp 0xc734
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movq 0x220(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
ucomisd 0x10(%rax), %xmm0
jne 0xc734
jp 0xc734
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc7d4
jmp 0xc736
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc6a3
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/computational_geometry.c
// Function: AddEdge
void AddEdge(const int v0, const int v1, const int f, Polyhedron *poly)
{
    /* insert by a predefined order */
    const int vMax = (v0 > v1) ? v0 : v1;
    const int vMin = (v0 > v1) ? v1 : v0;
    /* search the edge list, if already exist, add the second face index */
    for (int n = 0; n < poly->edgeN; ++n) {
        if ((vMax == poly->e[n][0]) && (vMin == poly->e[n][1])) {
            poly->e[n][3] = f;
            return;
        }
    }
    /* otherwise, add to the edge list */
    poly->e[poly->edgeN][0] = vMax;
    poly->e[poly->edgeN][1] = vMin;
    poly->e[poly->edgeN][2] = f;
    ++(poly->edgeN); /* increase pointer */
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0xc801
movl -0x4(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xc807
movl -0x8(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0xc81d
movl -0x8(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0xc823
movl -0x4(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xc8a2
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x210(%rcx), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0xc895
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x210(%rcx), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jne 0xc895
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0x210(%rax), %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
jmp 0xc90e
jmp 0xc897
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc830
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0x210(%rax), %rax
movq -0x18(%rbp), %rdx
movslq 0x4(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0x210(%rax), %rax
movq -0x18(%rbp), %rdx
movslq 0x4(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0x210(%rax), %rax
movq -0x18(%rbp), %rdx
movslq 0x4(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/computational_geometry.c
// Function: TransformNormal
static void TransformNormal(const Real matrix[restrict][DIMS],
        const int normalN, Real N[restrict][DIMS])
{
    RealVec tmp = {0.0};
    for (int n = 0; n < normalN; ++n) {
        tmp[X] = N[n][X];
        tmp[Y] = N[n][Y];
        tmp[Z] = N[n][Z];
        N[n][X] = Dot(matrix[X], tmp);
        N[n][Y] = Dot(matrix[Y], tmp);
        N[n][Z] = Dot(matrix[Z], tmp);
        /* normalization is needed if anisotropic transformation happens */
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20d0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xd788
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9880
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
callq 0x9880
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
leaq -0x30(%rbp), %rsi
callq 0x9880
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd6ba
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/computational_geometry.c
// Function: ComputeGeometryParameters
void ComputeGeometryParameters(const int collapse, Geometry *const geo)
{
    for (int n = 0; n < geo->sphN; ++n) {
        ComputeParametersSphere(collapse, geo->poly + n);
    }
    for (int n = geo->sphN; n < geo->totN; ++n) {
        ComputeParametersPolyhedron(collapse, geo->poly + n);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xd8cb
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x14(%rbp), %rax
imulq $0x238, %rax, %rax      # imm = 0x238
addq %rax, %rsi
callq 0xd910
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd896
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xd909
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x18(%rbp), %rax
imulq $0x238, %rax, %rax      # imm = 0x238
addq %rax, %rsi
callq 0xdb10
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd8d5
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/computational_geometry.c
// Function: BuildTriangle
void BuildTriangle(const int fid, const Polyhedron *poly, Real v0[restrict],
        Real v1[restrict], Real v2[restrict], Real e01[restrict], Real e02[restrict])
{
    for (int s = 0; s < DIMS; ++s) {
        /* vertices */
        v0[s] = poly->v[poly->f[fid][0]][s];
        v1[s] = poly->v[poly->f[fid][1]][s];
        v2[s] = poly->v[poly->f[fid][2]][s];
        /* edge vectors */
        e01[s] = v1[s] - v0[s];
        e02[s] = v2[s] - v0[s];
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x3, -0x34(%rbp)
jge 0xedf1
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x200(%rcx), %rcx
movslq -0x4(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x200(%rcx), %rcx
movslq -0x4(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movslq 0x4(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x200(%rcx), %rcx
movslq -0x4(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movslq 0x8(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq 0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xecc6
popq %rbp
retq
nopw %cs:(%rax,%rax)