LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/paraview_reader.c
// Function: ReadStructuredDataParaview
void ReadStructuredDataParaview(Time *time, Space *space, const Model *model)
{
    PvSet pvSet = { /* initialize environment */
        .rname = "field",
        .bname = {'\0'},
        .fname = {'\0'},
        .fext = ".vts",
        .fmt = "%s%05d",
        .intType = "Int32",
        .floatType = "Float32",
        .byteOrder = "LittleEndian",
        .scaN = 5,
        .sca = {"rho", "u", "v", "w", "p"},
        .vecN = 0,
        .vec = {{'\0'}},
    };
    snprintf(pvSet.bname, sizeof(PvStr), pvSet.fmt, pvSet.rname, time->dataC);
    ReadCaseFile(time, &pvSet);
    ReadStructuredData(space, model, &pvSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x310(%rbp), %rdi
leaq 0xc2ab(%rip), %rsi      # 0x291e0
movl $0x2f8, %edx            # imm = 0x2F8
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), %rdi
leaq -0x310(%rbp), %rsi
callq 0x1cfa0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x310(%rbp), %rdx
callq 0x1d060
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/paraview_reader.c
// Function: ReadCaseFile
static void ReadCaseFile(Time *time, PvSet *pvSet)
{
    snprintf(pvSet->fname, sizeof(PvStr), "%s.pvd", pvSet->bname);
    FILE *fp = Fopen(pvSet->fname, "r");
    ReadInLine(fp, "<!--");
    Sread(fp, 1, ParseFormat("%*s %lg"), &(time->now));
    Sread(fp, 1, "%*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 0xcaf9(%rip), %rdx      # 0x29ac8
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
leaq 0xa7db(%rip), %rsi      # 0x277c3
callq 0xbf90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xcad3(%rip), %rsi      # 0x29acf
callq 0xbe50
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xb4f9(%rip), %rdi      # 0x28509
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 0xb4d5(%rip), %rdx      # 0x2851d
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/paraview_reader.c
// Function: ReadPolyDataParaview
void ReadPolyDataParaview(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 0x1d4d8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d500
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
je 0x1d4f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d590
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/paraview_reader.c
// Function: PointPolyDataReader
static void PointPolyDataReader(const Time *time, Geometry *const geo)
{
    PvSet pvSet = { /* initialize environment */
        .rname = "geo_sph",
        .bname = {'\0'},
        .fname = {'\0'},
        .fext = ".vtp",
        .fmt = "%s%05d",
        .intType = "Int32",
        .floatType = "Float32",
        .byteOrder = "LittleEndian",
        .scaN = 0,
        .sca = {{'\0'}},
        .vecN = 0,
        .vec = {{'\0'}},
    };
    snprintf(pvSet.bname, sizeof(PvStr), pvSet.fmt, pvSet.rname, time->dataC);
    ReadPointPolyData(0, geo->sphN, geo, &pvSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x308(%rbp), %rdi
leaq 0xbfb7(%rip), %rsi      # 0x294d8
movl $0x2f8, %edx            # imm = 0x2F8
callq 0x2150
leaq -0x308(%rbp), %rdi
addq $0x50, %rdi
leaq -0x308(%rbp), %rdx
addq $0x140, %rdx            # imm = 0x140
leaq -0x308(%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 -0x308(%rbp), %rcx
callq 0x1d620
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/paraview_reader.c
// Function: PolygonPolyDataReader
static void PolygonPolyDataReader(const Time *time, Geometry *const geo)
{
    PvSet pvSet = { /* initialize environment */
        .rname = "geo_stl",
        .bname = {'\0'},
        .fname = {'\0'},
        .fext = ".vtp",
        .fmt = "%s%05d",
        .intType = "Int32",
        .floatType = "Float32",
        .byteOrder = "LittleEndian",
        .scaN = 0,
        .sca = {{'\0'}},
        .vecN = 0,
        .vec = {{'\0'}},
    };
    snprintf(pvSet.bname, sizeof(PvStr), pvSet.fmt, pvSet.rname, time->dataC);
    ReadPolygonPolyData(geo->sphN, geo->totN, geo, &pvSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x308(%rbp), %rdi
leaq 0xc21f(%rip), %rsi      # 0x297d0
movl $0x2f8, %edx            # imm = 0x2F8
callq 0x2150
leaq -0x308(%rbp), %rdi
addq $0x50, %rdi
leaq -0x308(%rbp), %rdx
addq $0x140, %rdx            # imm = 0x140
leaq -0x308(%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 -0x308(%rbp), %rcx
callq 0x1d6c0
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/paraview_reader.c
// Function: ReadPointPolyData
static void ReadPointPolyData(const int pm, const int pn, Geometry *const geo, PvSet *pvSet)
{
    snprintf(pvSet->fname, sizeof(PvStr), "%s%s", pvSet->bname, pvSet->fext);
    FILE *fp = Fopen(pvSet->fname, "r");
    ReadInLine(fp, "<!--");
    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
movq -0x18(%rbp), %r8
addq $0xf0, %r8
movl $0x50, %esi
leaq 0xc474(%rip), %rdx      # 0x29ad4
movb $0x0, %al
callq 0x20b0
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
leaq 0xa14a(%rip), %rsi      # 0x277c3
callq 0xbf90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xc442(%rip), %rsi      # 0x29acf
callq 0xbe50
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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/paraview_writer.c
// Function: WriteStructuredDataParaview
void WriteStructuredDataParaview(const Time *time, const Space *space, const Model *model)
{
    PvSet pvSet = { /* initialize environment */
        .rname = "field",
        .bname = {'\0'},
        .fname = {'\0'},
        .fext = ".vts",
        .fmt = "%s%05d",
        .intType = "Int32",
        .floatType = "Float32",
        .byteOrder = "LittleEndian",
        .scaN = 10,
        .sca = {"rho", "u", "v", "w", "p", "T", "did", "fid", "lid", "gst"},
        .vecN = 1,
        .vec = {"Vel"},
    };
    snprintf(pvSet.bname, sizeof(PvStr), pvSet.fmt, pvSet.rname, time->dataC);
    if (0 == time->stepC) { /* initialization step */
        InitializeTransientCaseFile(&pvSet);
    }
    WriteCaseFile(time, &pvSet);
    WriteStructuredData(space, model, &pvSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x310(%rbp), %rdi
leaq 0xbf5b(%rip), %rsi      # 0x29b30
movl $0x2f8, %edx            # imm = 0x2F8
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 0x1dc2a
leaq -0x310(%rbp), %rdi
callq 0x1dc60
movq -0x8(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x1dd20
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x310(%rbp), %rdx
callq 0x1df40
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/paraview_writer.c
// Function: InitializeTransientCaseFile
static void InitializeTransientCaseFile(PvSet *pvSet)
{
    snprintf(pvSet->fname, sizeof(PvStr), "%s.pvd", pvSet->rname);
    FILE *fp = Fopen(pvSet->fname, "w");
    fprintf(fp, "<?xml version=\"1.0\"?>\n");
    fprintf(fp, "<VTKFile type=\"Collection\" version=\"1.0\" byte_order=\"%s\">\n", pvSet->byteOrder);
    fprintf(fp, "  <Collection>\n");
    fprintf(fp, "  </Collection>\n");
    fprintf(fp, "</VTKFile>\n");
    fclose(fp);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
movq -0x8(%rbp), %rcx
movl $0x50, %esi
leaq 0xbe41(%rip), %rdx      # 0x29ac8
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
leaq 0x91dc(%rip), %rsi      # 0x26e7c
callq 0xbf90
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xc764(%rip), %rsi      # 0x2a418
movb $0x0, %al
callq 0x2140
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x230, %rdx            # imm = 0x230
leaq 0xc75e(%rip), %rsi      # 0x2a42f
movb $0x0, %al
callq 0x2140
movq -0x10(%rbp), %rdi
leaq 0xc787(%rip), %rsi      # 0x2a46a
movb $0x0, %al
callq 0x2140
movq -0x10(%rbp), %rdi
leaq 0xc785(%rip), %rsi      # 0x2a47a
movb $0x0, %al
callq 0x2140
movq -0x10(%rbp), %rdi
leaq 0xc784(%rip), %rsi      # 0x2a48b
movb $0x0, %al
callq 0x2140
movq -0x10(%rbp), %rdi
callq 0x2080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/paraview_writer.c
// Function: WritePolyDataParaview
void WritePolyDataParaview(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 0x1e758
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e780
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
je 0x1e770
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e830
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/paraview_writer.c
// Function: PointPolyDataWriter
static void PointPolyDataWriter(const Time *time, const Geometry *const geo)
{
    PvSet pvSet = { /* initialize environment */
        .rname = "geo_sph",
        .bname = {'\0'},
        .fname = {'\0'},
        .fext = ".vtp",
        .fmt = "%s%05d",
        .intType = "Int32",
        .floatType = "Float32",
        .byteOrder = "LittleEndian",
        .scaN = 2,
        .sca = {"r", "did"},
        .vecN = 1,
        .vec = {"Vel"},
    };
    snprintf(pvSet.bname, sizeof(PvStr), pvSet.fmt, pvSet.rname, time->dataC);
    if (0 == time->stepC) { /* initialization step */
        InitializeTransientCaseFile(&pvSet);
    }
    WriteCaseFile(time, &pvSet);
    WritePointPolyData(0, geo->sphN, geo, &pvSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x308(%rbp), %rdi
leaq 0xb687(%rip), %rsi      # 0x29e28
movl $0x2f8, %edx            # imm = 0x2F8
callq 0x2150
leaq -0x308(%rbp), %rdi
addq $0x50, %rdi
leaq -0x308(%rbp), %rdx
addq $0x140, %rdx            # imm = 0x140
leaq -0x308(%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 0x1e7f6
leaq -0x308(%rbp), %rdi
callq 0x1dc60
movq -0x8(%rbp), %rdi
leaq -0x308(%rbp), %rsi
callq 0x1dd20
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x10(%rbp), %rdx
xorl %edi, %edi
leaq -0x308(%rbp), %rcx
callq 0x1e8e0
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/paraview_writer.c
// Function: PolygonPolyDataWriter
static void PolygonPolyDataWriter(const Time *time, const Geometry *const geo)
{
    PvSet pvSet = { /* initialize environment */
        .rname = "geo_stl",
        .bname = {'\0'},
        .fname = {'\0'},
        .fext = ".vtp",
        .fmt = "%s%05d",
        .intType = "Int32",
        .floatType = "Float32",
        .byteOrder = "LittleEndian",
        .scaN = 0,
        .sca = {{'\0'}},
        .vecN = 0,
        .vec = {{'\0'}},
    };
    snprintf(pvSet.bname, sizeof(PvStr), pvSet.fmt, pvSet.rname, time->dataC);
    if (0 == time->stepC) { /* initialization step */
        InitializeTransientCaseFile(&pvSet);
    }
    WriteCaseFile(time, &pvSet);
    WritePolygonPolyData(geo->sphN, geo->totN, geo, &pvSet);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp            # imm = 0x310
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x308(%rbp), %rdi
leaq 0xb8cf(%rip), %rsi      # 0x2a120
movl $0x2f8, %edx            # imm = 0x2F8
callq 0x2150
leaq -0x308(%rbp), %rdi
addq $0x50, %rdi
leaq -0x308(%rbp), %rdx
addq $0x140, %rdx            # imm = 0x140
leaq -0x308(%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 0x1e8a6
leaq -0x308(%rbp), %rdi
callq 0x1dc60
movq -0x8(%rbp), %rdi
leaq -0x308(%rbp), %rsi
callq 0x1dd20
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rdx
leaq -0x308(%rbp), %rcx
callq 0x1eeb0
addq $0x310, %rsp            # imm = 0x310
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/postprocess.c
// Function: Postprocess
int Postprocess(Time *time, Space *space, Model *model)
{
    ShowInfo("Postprocessing...\n");
    ShowInfo("  releasing memory...\n");
    ReleaseProgramMemory(time, space, model);
    ShowInfo("  computing finished, successfully exit.\n");
    ShowInfo("Session");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xb5a0(%rip), %rdi      # 0x2a93b
movb $0x0, %al
callq 0xbcf0
leaq 0xb5a5(%rip), %rdi      # 0x2a94e
movb $0x0, %al
callq 0xbcf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f3f0
leaq 0xb59d(%rip), %rdi      # 0x2a965
movb $0x0, %al
callq 0xbcf0
leaq 0x51aa(%rip), %rdi      # 0x24580
movb $0x0, %al
callq 0xbcf0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/postprocess.c
// Function: ReleaseProgramMemory
static void ReleaseProgramMemory(Time *time, Space *space, Model *model)
{
    /* geometry related */
    Geometry *const geo = &(space->geo);
    Polyhedron *poly = NULL;
    for (int n = geo->sphN; n < geo->totN; ++n) {
        poly = geo->poly + n;
        RetrieveStorage(poly->f);
        RetrieveStorage(poly->Nf);
        RetrieveStorage(poly->e);
        RetrieveStorage(poly->Ne);
        RetrieveStorage(poly->v);
        RetrieveStorage(poly->Nv);
    }
    RetrieveStorage(geo->poly);
    RetrieveStorage(geo->col);
    /* space related */
    Partition *const part = &(space->part);
    RetrieveStorage(part->typeBC);
    RetrieveStorage(part->N);
    RetrieveStorage(part->varBC);
    RetrieveStorage(part->typeIC);
    RetrieveStorage(part->posIC);
    RetrieveStorage(part->varIC);
    RetrieveStorage(space->node);
    /* time related */
    RetrieveStorage(time->lp);
    RetrieveStorage(time->pp);
    /* model related */
    RetrieveStorage(model->mat);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1f4b9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x238, %rcx, %rcx      # imm = 0x238
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x200(%rax), %rdi
callq 0xbe20
movq -0x28(%rbp), %rax
movq 0x208(%rax), %rdi
callq 0xbe20
movq -0x28(%rbp), %rax
movq 0x210(%rax), %rdi
callq 0xbe20
movq -0x28(%rbp), %rax
movq 0x218(%rax), %rdi
callq 0xbe20
movq -0x28(%rbp), %rax
movq 0x220(%rax), %rdi
callq 0xbe20
movq -0x28(%rbp), %rax
movq 0x228(%rax), %rdi
callq 0xbe20
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1f422
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xbe20
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xbe20
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x390(%rax), %rdi
callq 0xbe20
movq -0x38(%rbp), %rax
movq 0x398(%rax), %rdi
callq 0xbe20
movq -0x38(%rbp), %rax
movq 0x3a0(%rax), %rdi
callq 0xbe20
movq -0x38(%rbp), %rax
movq 0x3b0(%rax), %rdi
callq 0xbe20
movq -0x38(%rbp), %rax
movq 0x3b8(%rax), %rdi
callq 0xbe20
movq -0x38(%rbp), %rax
movq 0x3c0(%rax), %rdi
callq 0xbe20
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbe20
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0xbe20
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xbe20
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0xbe20
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/preprocess.c
// Function: Preprocess
int Preprocess(Time *time, Space *space, Model *model)
{
    ShowInfo("Session");
    ShowInfo("Preprocessing...\n");
    ShowInfo("  loading case data...\n");
    LoadCaseData(time, space, model);
    ShowInfo("  computing parameters...\n");
    ComputeParameters(time, space, model);
    ShowInfo("  partitioning domain...\n");
    PartitionDomain(space);
    ShowInfo("  allocating memory...\n");
    AllocateProgramMemory(space, model);
    ShowInfo("Session");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x4fe5(%rip), %rdi      # 0x24580
movb $0x0, %al
callq 0xbcf0
leaq 0xb3e6(%rip), %rdi      # 0x2a98f
movb $0x0, %al
callq 0xbcf0
leaq 0xb3ea(%rip), %rdi      # 0x2a9a1
movb $0x0, %al
callq 0xbcf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5fa0
leaq 0xb3e3(%rip), %rdi      # 0x2a9b9
movb $0x0, %al
callq 0xbcf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb280
leaq 0xb3df(%rip), %rdi      # 0x2a9d4
movb $0x0, %al
callq 0xbcf0
movq -0x10(%rbp), %rdi
callq 0x14570
leaq 0xb3e2(%rip), %rdi      # 0x2a9ee
movb $0x0, %al
callq 0xbcf0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f640
leaq 0x4f59(%rip), %rdi      # 0x24580
movb $0x0, %al
callq 0xbcf0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/preprocess.c
// Function: AllocateProgramMemory
static void AllocateProgramMemory(Space *space, Model *model)
{
    Partition *const part = &(space->part);
    Geometry *const geo = &(space->geo);
    const int totN = part->n[X] * part->n[Y] * part->n[Z];
    space->node = AssignStorage(totN * sizeof(*space->node));
    if (0 != geo->totN) {
        geo->col = AssignStorage(geo->totN * sizeof(*geo->col));
        geo->poly = AssignStorage(geo->totN * sizeof(*geo->poly));
    }
    model->mat = AssignStorage(sizeof(*model->mat));
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
imull 0x10(%rcx), %eax
movq -0x18(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rax
imulq $0x88, %rax, %rdi
callq 0xbdd0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1f6df
movq -0x20(%rbp), %rax
movslq (%rax), %rdi
shlq $0x4, %rdi
callq 0xbdd0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movslq (%rax), %rax
imulq $0x238, %rax, %rdi      # imm = 0x238
callq 0xbdd0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x8, %edi
callq 0xbdd0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/program_entrance.c
// Function: ConfigureProgram
static void ConfigureProgram(Control *control, Space *space)
{
    Partition *const part = &(space->part);
    switch (control->runMode) {
        case 'i': /* gui mode */
            ShowPreamble(control);
            /* fall through */
        case 's': /* serial mode */
            part->proc[X] = 1;
            part->proc[Y] = 1;
            part->proc[Z] = 1;
            part->procN = 1;
            break;
        case 'o': /* omp mode */
            /* fall through */
        case 'm': /* mpi mode */
            part->proc[X] = control->proc[X];
            part->proc[Y] = control->proc[Y];
            part->proc[Z] = control->proc[Z];
            part->procN = control->proc[X] *
                control->proc[Y] * control->proc[Z];
            break;
        case 'g': /* gpu mode */
            break;
        default:
            break;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
addl $-0x67, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xc, %eax
ja 0x1fa44
movq -0x20(%rbp), %rax
leaq 0xb068(%rip), %rcx      # 0x2aa08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x1fa50
movq -0x18(%rbp), %rax
movl $0x1, 0x3f8(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x3fc(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x400(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x404(%rax)
jmp 0x1fa46
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x3f8(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x3fc(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x400(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x404(%rax)
jmp 0x1fa46
jmp 0x1fa46
jmp 0x1fa46
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/program_entrance.c
// Function: ShowManual
static void ShowManual(void)
{
    ShowInfo("\n            ArtraCFD User Manual\n");
    ShowInfo("SYNOPSIS:\n");
    ShowInfo("        artracfd [-m runmode] [-n nprocessors]\n");
    ShowInfo("OPTIONS:\n");
    ShowInfo("        -m runmode        run mode: gui, serial, omp, mpi, gpu\n");
    ShowInfo("        -n nprocessors    processors per dimension: nx*ny*nz\n");
    ShowInfo("NOTES:\n");
    ShowInfo("        default run mode is gui\n");
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xaf59(%rip), %rdi      # 0x2ac34
movb $0x0, %al
callq 0xbcf0
leaq 0xaf6e(%rip), %rdi      # 0x2ac57
movb $0x0, %al
callq 0xbcf0
leaq 0xaf6b(%rip), %rdi      # 0x2ac62
movb $0x0, %al
callq 0xbcf0
leaq 0xaf8d(%rip), %rdi      # 0x2ac92
movb $0x0, %al
callq 0xbcf0
leaq 0xaf89(%rip), %rdi      # 0x2ac9c
movb $0x0, %al
callq 0xbcf0
leaq 0xafbb(%rip), %rdi      # 0x2acdc
movb $0x0, %al
callq 0xbcf0
leaq 0xafeb(%rip), %rdi      # 0x2ad1a
movb $0x0, %al
callq 0xbcf0
leaq 0xafe5(%rip), %rdi      # 0x2ad22
movb $0x0, %al
callq 0xbcf0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/solid_dynamics.c
// Function: EvolveSolidDynamics
void EvolveSolidDynamics(const Real now, const Real dt, Space *space, const Model *model)
{
    IntegrateSurfaceForce(space, model);
    ApplyKinematics(now, dt, space);
    if (1 != model->psi) {
        ApplyCollision(space);
    }
    ApplyMotion(dt, space);
    ComputeGeometricField(space, model);
    TreatImmersedBoundary(TO, space, model);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1fde0
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movq -0x18(%rbp), %rdi
callq 0x20b90
movq -0x20(%rbp), %rcx
movl $0x1, %eax
cmpl 0x1c(%rcx), %eax
je 0x1fda1
movq -0x18(%rbp), %rdi
callq 0x21000
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rdi
callq 0x21c90
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x18c20
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %edi, %edi
callq 0x197d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/solid_dynamics.c
// Function: DetectColState
static void DetectColState(const int k, const int j, const int i, const int did,
        const int end, const int path[restrict][DIMS], const Node *const node,
        const Partition *const part, Geometry *const geo)
{
    /* search around the specified node to find colliding objects */
    int idx = 0; /* linear array index math variable */
    int ih = 0, jh = 0, kh = 0; /* neighbouring node */
    for (int n = 0; n < end; ++n) {
        kh = k + path[n][Z];
        jh = j + path[n][Y];
        ih = i + path[n][X];
        if (!InPartBox(kh, jh, ih, part->ns[PIN])) {
            continue;
        }
        idx = IndexNode(kh, jh, ih, part->n[Y], part->n[X]);
        if (0 == node[idx].did) { /* a fluid node is not valid */
            continue;
        }
        if (did != node[idx].did) { /* a heterogeneous node on the path */
            AddColObject(path[n], node[idx].did, geo);
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movq %r9, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2202d
movl -0x4(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x34(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
addl 0x8(%rcx), %eax
movl %eax, -0x30(%rbp)
movl -0x8(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x34(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
addl 0x4(%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
movslq -0x34(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
addl (%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
movl -0x28(%rbp), %edx
movq 0x18(%rbp), %rcx
addq $0x68, %rcx
callq 0x9530
cmpl $0x0, %eax
jne 0x21f9e
jmp 0x2201f
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
movl -0x28(%rbp), %edx
movq 0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq 0x18(%rbp), %rax
movl 0xc(%rax), %r8d
callq 0x9500
movl %eax, -0x24(%rbp)
movq 0x10(%rbp), %rcx
movslq -0x24(%rbp), %rax
imulq $0x88, %rax, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x21fd8
jmp 0x2201f
movl -0x10(%rbp), %eax
movq 0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
imulq $0x88, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
je 0x2201d
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movq 0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
movq 0x20(%rbp), %rdx
callq 0x22040
jmp 0x2201f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x21f2b
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/solid_dynamics.c
// Function: AddColObject
static void AddColObject(const int N[restrict], const int did, Geometry *const geo)
{
    Collision *col = NULL;
    /* search the object list, if already exist, adjust the line of impact */
    for (int n = 0; n < geo->colN; ++n) {
        col = geo->col + n;
        if (did == col->gid) {
            col->N[X] = col->N[X] + N[X];
            col->N[Y] = col->N[Y] + N[Y];
            col->N[Z] = col->N[Z] + N[Z];
            return;
        }
    }
    /* otherwise, add to the collision list */
    col = geo->col + geo->colN;
    col->gid = did;
    col->N[X] = N[X];
    col->N[Y] = N[Y];
    col->N[Z] = N[Z];
    ++(geo->colN);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x220d9
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x220cc
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
addl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x22133
jmp 0x220ce
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2205e
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0xc(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/solve.c
// Function: Solve
int Solve(Time *time, Space *space, const Model *model)
{
    ShowInfo("Solving...\n");
    ShowInfo("  initializing...\n");
    InitializeComputeDomain(time, space, model);
    ShowInfo("  time marching...\n");
    EvolveSolution(time, space, model);
    ShowInfo("Session");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x8c0d(%rip), %rdi      # 0x2ad68
movb $0x0, %al
callq 0xbcf0
leaq 0x8c0b(%rip), %rdi      # 0x2ad74
movb $0x0, %al
callq 0xbcf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1aaf0
leaq 0x8bff(%rip), %rdi      # 0x2ad87
movb $0x0, %al
callq 0xbcf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x221c0
leaq 0x23d9(%rip), %rdi      # 0x24580
movb $0x0, %al
callq 0xbcf0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/source_term.c
// Function: ComputePhi
void ComputePhi(const int tn, const int k, const int j, const int i,
        const int partn[restrict], const Node *const node,
        const Model *model, Real Phi[restrict])
{
    if (0 == model->sState) {
        memset(Phi, 0, DIMU * sizeof(*Phi));
        return;
    }
    const int idx = IndexNode(k, j, i, partn[Y], partn[X]);
    const Real *restrict U = node[idx].U[tn];
    const RealVec V = {U[1] / U[0], U[2] / U[0], U[3] / U[0]};
    const RealVec fb = {U[0] * model->g[X], U[0] * model->g[Y], U[0] * model->g[Z]};
    Phi[0] = 0.0;
    Phi[1] = fb[X];
    Phi[2] = fb[Y];
    Phi[3] = fb[Z];
    Phi[4] = Dot(fb, V);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq 0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0x2c(%rcx), %eax
jne 0x22b44
movq 0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20d0
jmp 0x22c5d
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl (%rax), %r8d
callq 0x9500
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rax
movslq -0x4(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x30(%rbp), %rax
divsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x30(%rbp), %rax
divsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x30(%rbp), %rax
divsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movq 0x10(%rbp), %rax
mulsd 0x78(%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movq 0x10(%rbp), %rax
mulsd 0x80(%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movq 0x10(%rbp), %rax
mulsd 0x88(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq 0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movsd -0x70(%rbp), %xmm0
movq 0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x68(%rbp), %xmm0
movq 0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x60(%rbp), %xmm0
movq 0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9880
movq 0x18(%rbp), %rax
movsd %xmm0, 0x20(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mohuangrui[P]ArtraCFD/timer.c
// Function: TockTime
double TockTime(const Timer *tm)
{
    Timer tc; /* store current time at now */
    gettimeofday(&tc, NULL);
    return (double)(tc.tv_sec - tm->tv_sec) +
        (double)(tc.tv_usec - tm->tv_usec) / 1000000.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20c0
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq (%rcx), %rax
cvtsi2sd %rax, %xmm0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x8(%rcx), %rax
cvtsi2sd %rax, %xmm1
movsd 0x7a4e(%rip), %xmm2     # 0x2ae60
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/monoclock/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct timeval tv_wall, tv_cpu;
	double timer_resolution;

	WARNP_INIT;

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

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

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

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

	/* Success! */
	exit(0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x125c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x16b0
jmp 0x125e
leaq -0x20(%rbp), %rdi
callq 0x1390
cmpl $0x0, %eax
je 0x12a8
jmp 0x126e
callq 0x1060
cmpl $0x0, (%rax)
je 0x1293
leaq 0xd85(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1770
callq 0x1060
movl $0x0, (%rax)
jmp 0x12a1
leaq 0xd6a(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x19c0
jmp 0x12a3
jmp 0x137f
leaq -0x30(%rbp), %rdi
callq 0x14c0
cmpl $0x0, %eax
je 0x12f2
jmp 0x12b8
callq 0x1060
cmpl $0x0, (%rax)
je 0x12dd
leaq 0xd4b(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1770
callq 0x1060
movl $0x0, (%rax)
jmp 0x12eb
leaq 0xd30(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x19c0
jmp 0x12ed
jmp 0x137f
leaq -0x38(%rbp), %rdi
callq 0x1580
cmpl $0x0, %eax
je 0x1339
jmp 0x1302
callq 0x1060
cmpl $0x0, (%rax)
je 0x1327
leaq 0xd19(%rip), %rdi       # 0x202c
movb $0x0, %al
callq 0x1770
callq 0x1060
movl $0x0, (%rax)
jmp 0x1335
leaq 0xcfe(%rip), %rdi       # 0x202c
movb $0x0, %al
callq 0x19c0
jmp 0x1337
jmp 0x137f
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0xcf7(%rip), %rdi       # 0x203f
movb $0x0, %al
callq 0x1090
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0xd14(%rip), %rdi       # 0x2072
movb $0x0, %al
callq 0x1090
movsd -0x38(%rbp), %xmm0
leaq 0xd3b(%rip), %rdi       # 0x20ac
movb $0x1, %al
callq 0x1090
xorl %edi, %edi
callq 0x1100
movl $0x1, %edi
callq 0x1100
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_06/scanf.c
// Function: main
int main(void)
{
	char *str; 
	int ret; 

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

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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe5e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
callq 0x1040
movl $0x0, (%rax)
leaq 0xe55(%rip), %rdi       # 0x2014
leaq -0x10(%rbp), %rsi
movb $0x0, %al
callq 0x1080
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0x1213
callq 0x1040
cmpl $0x0, (%rax)
je 0x11f2
leaq 0xe38(%rip), %rdi       # 0x201c
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1235
movq 0x2dff(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe1f(%rip), %rsi       # 0x2022
movb $0x0, %al
callq 0x1060
movl $0x0, -0x4(%rbp)
jmp 0x1235
movq -0x10(%rbp), %rsi
leaq 0xe1c(%rip), %rdi       # 0x203a
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/yurrriq[P]knrc/src/trimlines.c
// Function: trim_line
size_t trim_line(char line[], size_t len)
{
    while (line[--len] == ' ' || line[len] == '\t' || line[len] == '\n') {
        if (len == 0) {
            return 0;
        } else {
            line[len] = '\0';
        }
    }

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

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movsbl -0x1(%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x19(%rbp)
je 0x11a9
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x19(%rbp)
je 0x11a9
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x11b2
jmp 0x11d1
cmpq $0x0, -0x18(%rbp)
jne 0x11c3
movq $0x0, -0x8(%rbp)
jmp 0x11f1
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x115c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $0xa, 0x1(%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/yurrriq[P]knrc/src/trimlines.c
// Function: main
int main()
{
    size_t len;
    char line[MAXLINE];

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

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x90(%rbp), %rdi
movl $0x78, %esi
callq 0x1270
cltq
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jbe 0x125d
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1150
cmpq $0x0, %rax
jbe 0x125b
leaq -0x90(%rbp), %rdi
movq 0x2d8d(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1030
jmp 0x1212
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/numa.c
// Function: exit_all
void exit_all(int *pids)
{
    int i;

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

    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0x12a9
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl $0xf, %esi
callq 0x10d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1283
xorl %edi, %edi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/numa.c
// Function: child_reader
static void child_reader(int fd, volatile uint64_t *result)
{
    int size = 100 * MB;
    char *buf = malloc(size);
    uint64_t bytes = 0;

    memset(buf, '\0', size);
    while (1) {
        bytes += read(fd, buf, size);
        *result = bytes;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x6400000, -0x14(%rbp) # imm = 0x6400000
movslq -0x14(%rbp), %rdi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rdx
xorl %esi, %esi
callq 0x1070
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x10a0
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x177a
nop
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/numa.c
// Function: child_writer
static void child_writer(int fd)
{
    int size = 100 * MB;
    char *buf = malloc(size);

    while (1) {
        memset(buf, ' ', size);
        write(fd, buf, size);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x6400000, -0x8(%rbp)  # imm = 0x6400000
movslq -0x8(%rbp), %rdi
callq 0x10e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x8(%rbp), %rdx
movl $0x20, %esi
callq 0x1070
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x8(%rbp), %rdx
callq 0x1040
jmp 0x17bf
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/test/mock-test.c
// Function: print_response
void print_response(const char *osc, void *vv)
{
    char type = rtosc_type(osc, 0);
    //printf("[callback] got a message '%s':%c data=%p...\n", osc, type, v);

    rtosc_arg_t arg = rtosc_argument(osc, 0);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8830
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x9e40
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x69, %eax
jne 0xb9a3
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0xba2a
movsbl -0x11(%rbp), %eax
cmpl $0x54, %eax
jne 0xb9b5
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
jmp 0xba28
movsbl -0x11(%rbp), %eax
cmpl $0x46, %eax
jne 0xb9c7
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0xba26
movsbl -0x11(%rbp), %eax
cmpl $0x66, %eax
jne 0xba24
movq -0x8(%rbp), %rdi
callq 0x9770
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x9e00
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb9fc
jmp 0xba22
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x98a0
movss -0x50(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x26f5(%rip), %rdi      # 0xe10e
movb $0x1, %al
callq 0x20e0
jmp 0xb9e1
jmp 0xba24
jmp 0xba26
jmp 0xba28
jmp 0xba2a
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/test/mock-test.c
// Function: test_options
void test_options(schema_t schema, bridge_t *bridge)
{
    (void) bridge;
    printf("#Grabbing filter type...\n"); 
    uri_t uri = "/part3/kit8/adpars/VoicePar3/FMSmp/Pfiltertype";
    schema_handle_t handle = sm_get(schema, uri);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x234c(%rip), %rdi      # 0xe22a
movb $0x0, %al
callq 0x20e0
movq -0x70(%rbp), %rax
leaq 0x2354(%rip), %rcx      # 0xe244
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x8260
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x50(%rax)
movups -0x28(%rbp), %xmm0
movups %xmm0, 0x40(%rax)
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups -0x48(%rbp), %xmm2
movups -0x38(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x8700
movl %eax, %edi
leaq 0x21e9(%rip), %rsi      # 0xe143
movl $0x93, %edx
callq 0xaf50
movq -0x60(%rbp), %rax
movl 0x10(%rax), %esi
movl $0xe, %edi
leaq 0x22fc(%rip), %rdx      # 0xe273
movl $0x94, %ecx
callq 0xae00
movq -0x60(%rbp), %rax
movq (%rax), %rax
movl 0x1c(%rax), %esi
movl $0x7, %edi
leaq 0x22f5(%rip), %rdx      # 0xe28c
movl $0x95, %ecx
callq 0xae00
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rsi
leaq 0x22f2(%rip), %rdi      # 0xe2a6
leaq 0x22ef(%rip), %rdx      # 0xe2aa
movl $0x96, %ecx
callq 0xb030
addq $0xd0, %rsp
popq %rbp
retq
nop