LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: reflection(double, double, privariables const*, pointxy const*, privariables*)
void reflection(double hr, double hg,const JBBL *jbu, const PXYZ *nxyz, JBBL *jbugst)
{
    double tx,ty,nx,ny;
    nx=nxyz->x;
    ny=nxyz->y;
    tx=ny;
    ty=-nx;
    Vec2D ndir(nx,ny);
    Vec2D tdir(tx,ty);
    Vec2D ur(jbu->u,jbu->v);
    double un1,ut1,un2,ut2;
    un1=ur.dot(ndir);
    ut1=ur.dot(tdir);
    un2=-(hg/hr)*un1;
    ut2=ut1;

    jbugst->q = jbu->q;
    jbugst->p = jbu->p;
    jbugst->u = (ny * ut2 - ty * un2)/(tx * ny - nx * ty);
    jbugst->v = (tx * un2 - nx * ut2)/(tx * ny - nx * ty);			
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movaps %xmm1, 0x40(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd (%rsi), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x8(%rsi), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, %xmm2
xorps 0xb524(%rip), %xmm2     # 0x1b0a0
movaps %xmm2, 0x20(%rsp)
leaq 0x70(%rsp), %r15
movq %r15, %rdi
callq 0xc11c
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
callq 0xc11c
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
leaq 0x50(%rsp), %r13
movq %r13, %rdi
callq 0xc11c
movq %r13, %rdi
movq %r15, %rsi
callq 0xc126
movsd %xmm0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0xc126
movapd 0x40(%rsp), %xmm3
xorpd 0xb4b9(%rip), %xmm3     # 0x1b0a0
divsd 0x8(%rsp), %xmm3
mulsd (%rsp), %xmm3
movsd (%r14), %xmm1
movsd %xmm1, (%rbx)
movsd 0x18(%r14), %xmm1
movsd %xmm1, 0x18(%rbx)
movapd 0x30(%rsp), %xmm4
movapd %xmm4, %xmm1
mulsd %xmm4, %xmm1
movapd 0x10(%rsp), %xmm5
movapd %xmm5, %xmm2
mulsd %xmm5, %xmm2
addsd %xmm1, %xmm2
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
unpcklpd %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0]
unpcklpd 0x20(%rsp), %xmm3       # xmm3 = xmm3[0],mem[0]
mulpd %xmm4, %xmm3
movapd %xmm5, %xmm1
unpcklpd %xmm5, %xmm1            # xmm1 = xmm1[0],xmm5[0]
mulpd %xmm0, %xmm1
addpd %xmm3, %xmm1
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
movupd %xmm1, 0x8(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: getInterAB(pointxy const*, pointxy const*, pointxy const*, pointxy*)
void getInterAB(const PXYZ *gst, const PXYZ *pA, const PXYZ *pB, PXYZ *jiaodian)
{
    double ls1;
    double ls2;
    double b1, b2, xjd, yjd, jl;

    if(fabs(pB->y-pA->y) < 1e-10)
    {
        jiaodian->x = gst->x;
        jiaodian->y = pA->y;
    }
    else if(fabs(pA->x - pB->x) < 1e-10)
    {
        jiaodian->x = pA->x;
        jiaodian->y = gst->y;
    }
    else
    {
        ls1 = (pA->y-pB->y)/(pA->x-pB->x);
        ls2 = - 1.0/ls1;
        b1 = pA->y - ls1 * pA->x;
        b2 = gst->y - ls2 * gst->x;

        xjd = (b2 - b1)/(ls1-ls2);
        yjd = ls1 * xjd + b1;

        jiaodian->x = xjd;
        jiaodian->y = yjd;
    }
}

// Assembly:
movsd 0x8(%rdx), %xmm1
movsd 0x8(%rsi), %xmm0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
andpd 0xb172(%rip), %xmm2     # 0x1b240
movsd 0xb38a(%rip), %xmm4     # 0x1b460
ucomisd %xmm2, %xmm4
jbe 0x100e6
movsd (%rdi), %xmm1
movsd %xmm1, (%rcx)
jmp 0x10164
movsd (%rsi), %xmm2
movapd %xmm2, %xmm3
subsd (%rdx), %xmm3
movapd 0xb146(%rip), %xmm5     # 0x1b240
andpd %xmm3, %xmm5
ucomisd %xmm5, %xmm4
jbe 0x1010f
movsd %xmm2, (%rcx)
movsd 0x8(%rdi), %xmm0
jmp 0x10164
movsd 0x8(%rdi), %xmm4
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
subsd %xmm1, %xmm0
divsd %xmm3, %xmm0
movsd 0xb2d8(%rip), %xmm1     # 0x1b400
divsd %xmm0, %xmm1
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movsd (%rdi), %xmm5
unpcklpd %xmm2, %xmm5            # xmm5 = xmm5[0],xmm2[0]
mulpd %xmm1, %xmm5
subpd %xmm5, %xmm4
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1            # xmm1 = xmm1[1],xmm4[1]
subsd %xmm1, %xmm4
divsd %xmm3, %xmm4
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
movsd %xmm4, (%rcx)
movsd %xmm0, 0x8(%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: getRadius(pointxy const*, pointxy const*, pointxy const*)
double getRadius(const PXYZ *pt1, const PXYZ *pt2,const PXYZ *pt3)
{
    double rd,dls1,dls2,dls3,dls4;
    double a1,b1,a2,b2;
    dls1=(pt1->x-pt2->x)*(pt1->x-pt2->x)+(pt1->y-pt2->y)*(pt1->y-pt2->y);
    dls2=(pt1->x-pt3->x)*(pt1->x-pt3->x)+(pt1->y-pt3->y)*(pt1->y-pt3->y);
    dls3=(pt2->x-pt3->x)*(pt2->x-pt3->x)+(pt2->y-pt3->y)*(pt2->y-pt3->y);
    dls4=2.0*(pt3->x * (pt2->y - pt1->y) + pt2->x * (pt1->y - pt3->y) 
        + pt1->x * (pt3->y-pt2->y));
    a1=pt2->x-pt1->x;
    b1=pt2->y-pt1->y;

    a2=pt3->x-pt1->x;
    b2=pt3->y-pt1->y;
    rd = sqrt(dls1*dls2*dls3)/(fabs(dls4)+1.0e-18);
    if(fabs(a1*b2-b1*a2)<1.0e-12) rd=1.0e15;
    return rd;
}

// Assembly:
subq $0x58, %rsp
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm2
movsd (%rsi), %xmm8
movsd 0x8(%rsi), %xmm10
movsd (%rdx), %xmm9
movsd 0x8(%rdx), %xmm11
movapd %xmm8, %xmm1
unpcklpd %xmm9, %xmm1            # xmm1 = xmm1[0],xmm9[0]
movapd %xmm10, %xmm4
unpcklpd %xmm11, %xmm4           # xmm4 = xmm4[0],xmm11[0]
movapd %xmm10, %xmm3
subsd %xmm11, %xmm3
movapd %xmm11, %xmm12
subsd %xmm10, %xmm12
subsd %xmm2, %xmm10
subsd %xmm2, %xmm11
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
subpd %xmm4, %xmm2
movapd %xmm2, %xmm4
movapd %xmm8, %xmm5
subsd %xmm9, %xmm5
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulsd %xmm8, %xmm2
movapd %xmm9, %xmm6
mulsd %xmm0, %xmm12
subsd %xmm0, %xmm8
subsd %xmm0, %xmm9
movapd %xmm0, %xmm7
unpcklpd %xmm0, %xmm7            # xmm7 = xmm7[0],xmm0[0]
subpd %xmm1, %xmm7
mulpd %xmm4, %xmm4
mulpd %xmm7, %xmm7
addpd %xmm4, %xmm7
mulsd %xmm3, %xmm3
mulsd %xmm5, %xmm5
addsd %xmm3, %xmm5
mulsd %xmm10, %xmm6
addsd %xmm2, %xmm6
addsd %xmm6, %xmm12
addsd %xmm12, %xmm12
movapd %xmm7, %xmm0
unpckhpd %xmm7, %xmm0            # xmm0 = xmm0[1],xmm7[1]
mulsd %xmm7, %xmm0
mulsd %xmm5, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x10808
sqrtsd %xmm0, %xmm0
jmp 0x10851
movapd %xmm8, 0x40(%rsp)
movapd %xmm9, 0x30(%rsp)
movapd %xmm10, 0x20(%rsp)
movapd %xmm11, 0x10(%rsp)
movapd %xmm12, (%rsp)
callq 0x3180
movapd (%rsp), %xmm12
movapd 0x10(%rsp), %xmm11
movapd 0x20(%rsp), %xmm10
movapd 0x30(%rsp), %xmm9
movapd 0x40(%rsp), %xmm8
movapd 0xa9e7(%rip), %xmm1     # 0x1b240
andpd %xmm1, %xmm12
addsd 0xb021(%rip), %xmm12    # 0x1b888
divsd %xmm12, %xmm0
mulsd %xmm10, %xmm9
mulsd %xmm11, %xmm8
subsd %xmm9, %xmm8
andpd %xmm1, %xmm8
cmpltsd 0xb006(%rip), %xmm8     # 0x1b890
movsd 0xb006(%rip), %xmm1     # 0x1b898
andpd %xmm8, %xmm1
andnpd %xmm0, %xmm8
orpd %xmm1, %xmm8
movapd %xmm8, %xmm0
addq $0x58, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: findPointInCell(pointxy const*, bodygridclass*)
OctCell *findPointInCell(const PXYZ *point, OctCell *cellflow)
{
    int m;
    //double plevel,hc;
    double hcx, hcy;
    OctCell *incell = NULL;

    if(cellflow->reflag == 0)	
    {	          	    
        //	plevel=cellflow->level;		           
        //	hc=h/pow(2.0,plevel);
        hcx=cellflow->dx;
        hcy=cellflow->dy;

        if(point->x < cellflow->xc1 + 0.5 * hcx + ERRS
            && point->x > cellflow->xc1 - 0.5 * hcx - ERRS
            && point->y < cellflow->yc1 + 0.5 * hcy + ERRS
            && point->y > cellflow->yc1 - 0.5 * hcy - ERRS)				
        {					
            incell=cellflow;   
       //     return incell;
        } 
      //  else
        //    return NULL;			
    }
    else
    {
        for(m=0; m<4; ++m)
        {
            incell = findPointInCell(point, cellflow->children[m]);
            if(incell!=NULL)break;//2008.2.22��
        }
    }

    return incell;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpw $0x0, 0x1fc(%rsi)
je 0x10e22
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x10ebd
movq 0x258(%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x10de0
incq %r15
testq %rax, %rax
je 0x10df8
movq %rax, %rbx
jmp 0x10ebf
movsd 0x278(%rbx), %xmm2
movsd 0x288(%rbx), %xmm0
movsd (%r14), %xmm1
movsd 0xa339(%rip), %xmm3     # 0x1b178
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
addsd 0xa331(%rip), %xmm3     # 0x1b180
ucomisd %xmm1, %xmm3
jbe 0x10ebd
mulsd 0xa313(%rip), %xmm0     # 0x1b170
addsd %xmm2, %xmm0
addsd 0xaa37(%rip), %xmm0     # 0x1b8a0
ucomisd %xmm0, %xmm1
jbe 0x10ebd
movsd 0x290(%rbx), %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x280(%rbx), %xmm2
movsd 0xa2eb(%rip), %xmm3     # 0x1b178
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
addsd 0xa2e3(%rip), %xmm3     # 0x1b180
ucomisd %xmm1, %xmm3
jbe 0x10ebd
mulsd 0xa2c5(%rip), %xmm0     # 0x1b170
addsd %xmm2, %xmm0
addsd 0xa9e9(%rip), %xmm0     # 0x1b8a0
ucomisd %xmm0, %xmm1
ja 0x10ebf
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: insert_cell(bodygridclass*, std::set<bodygridclass*, std::less<bodygridclass*>, std::allocator<bodygridclass*>>&)
void insert_cell(OctCell *pp, set<OctCell*> &grid)
{
    if(pp->reflag==0){
        grid.insert(pp);
    }
    else {
        for(int m=0; m<4;++m) 
            insert_cell(pp->children[m], grid);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
cmpw $0x0, 0x1fc(%rdi)
je 0x11708
movq %rdi, %r14
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x11715
movq 0x258(%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x116cc
incq %r15
jmp 0x116ed
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6a56
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: chazhi4smtrictPshbl(std::vector<bodygridclass*, std::allocator<bodygridclass*>>&, pointxy const&, privariables&)
void chazhi4smtrictPshbl(vector< OctCell * > &grid, const PXYZ &smtrict, JBBL &jbu )
{
    double distance;
    vector<double> expMinusR;
    double sumR = 0.0; 
    int nmc1=grid.size();  

    SHBL shu;
    for(int i=0; i < nmc1; ++i) {
        distance=sqrt( (smtrict.x-grid[i]->xc1) * (smtrict.x-grid[i]->xc1) 
            + (smtrict.y-grid[i]->yc1) * (smtrict.y-grid[i]->yc1));
        // expMinusR.push_back(exp(-distance));
        expMinusR.push_back(1.0/(1.0e-18+distance));
        sumR += expMinusR[i];

    }

    for(int i = 0; i < nmc1; ++i)
    {
        shu.q += expMinusR[i] * grid[i]->dof[0][0]/sumR;
        shu.qu += expMinusR[i] * grid[i]->dof[1][0]/sumR;
        shu.qv += expMinusR[i] * grid[i]->dof[2][0]/sumR;
        shu.te += expMinusR[i] * grid[i]->dof[3][0]/sumR;
    }

    shblToJbbl(&shu,&jbu);   
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r14
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %r12
andq $0x0, 0x10(%r12)
movapd %xmm0, (%r12)
movq 0x8(%rdi), %rbp
subq (%rdi), %rbp
shrq $0x3, %rbp
movapd %xmm0, 0x40(%rsp)
movapd %xmm0, 0x30(%rsp)
xorl %eax, %eax
testl %ebp, %ebp
cmovlel %eax, %ebp
xorpd %xmm4, %xmm4
leaq 0x8(%rsp), %r13
xorl %ebx, %ebx
cmpq %rbx, %rbp
je 0x12010
movapd %xmm4, 0x50(%rsp)
movq (%r14), %rax
movq (%rax,%rbx,8), %rax
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
subsd 0x278(%rax), %xmm0
subsd 0x280(%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
addsd 0x98aa(%rip), %xmm0     # 0x1b888
movsd 0x923a(%rip), %xmm1     # 0x1b220
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x13216
movq 0x10(%rsp), %rax
movapd 0x50(%rsp), %xmm4
addsd (%rax,%rbx,8), %xmm4
incq %rbx
jmp 0x11f99
movq (%r14), %rcx
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
xorpd %xmm0, %xmm0
xorl %edx, %edx
xorpd %xmm1, %xmm1
cmpq %rdx, %rbp
je 0x12076
movq (%rcx,%rdx,8), %rsi
movsd (%rax,%rdx,8), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movsd 0x30(%rsi), %xmm3
movhpd 0x60(%rsi), %xmm3       # xmm3 = xmm3[0],mem[0]
mulpd %xmm2, %xmm3
divpd %xmm4, %xmm3
addpd %xmm3, %xmm0
movapd %xmm0, 0x30(%rsp)
movsd 0x90(%rsi), %xmm3
movhpd 0xc0(%rsi), %xmm3       # xmm3 = xmm3[0],mem[0]
mulpd %xmm2, %xmm3
divpd %xmm4, %xmm3
addpd %xmm3, %xmm1
movapd %xmm1, 0x40(%rsp)
incq %rdx
jmp 0x12021
leaq 0x30(%rsp), %rdi
movq (%rsp), %rsi
callq 0xdcdc
leaq 0x10(%rsp), %rdi
callq 0xa73a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa73a
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: form_inter_cell_set()
void form_inter_cell_set()
{
    BndryNode *current;
    OctCell *lsbl;
    current =HeadFaceCell;
    interface_cell_set.clear();
    OctCell *pp[8]={NULL};
    while(current != NULL)
    {
        lsbl=current->cell;
        find_sol_refp(pp,bodygrid+lsbl->NOparent);
        insert_cell2(bodygrid+lsbl->NOparent,interface_cell_set);
        for(int i=0;i<8;++i)
            insert_cell2(pp[i],interface_cell_set);

        current = current->next;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq 0x15b77(%rip), %rax     # 0x28618
movq (%rax), %r15
leaq 0x23aa5(%rip), %rbx     # 0x36550
movq %rbx, %rdi
callq 0x6a28
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
leaq 0x1080d(%rip), %r12     # 0x232e0
testq %r15, %r15
je 0x12b2f
movq (%r15), %r13
movl 0x200(%r13), %eax
imulq $0x360, %rax, %rsi      # imm = 0x360
addq (%r12), %rsi
movq %r14, %rdi
callq 0x18fcf
movl 0x200(%r13), %eax
imulq $0x360, %rax, %rdi      # imm = 0x360
addq (%r12), %rdi
movq %rbx, %rsi
callq 0x1a094
xorl %r13d, %r13d
cmpq $0x8, %r13
je 0x12b29
movq (%rsp,%r13,8), %rdi
movq %rbx, %rsi
callq 0x1a094
incq %r13
jmp 0x12b12
movq 0x8(%r15), %r15
jmp 0x12ad3
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: wherePoint(pointxy*, bodygridclass*&)
void wherePoint(PXYZ *xy, ptrOctCell &incell)
{
    double xc1,yc1, dx1,dy1;

    OctCell *lsbl;
    for(set<OctCell*>::iterator itset=interface_cell_set.begin();
        itset!=interface_cell_set.end();++itset){
        lsbl =*itset;

        xc1=lsbl->xc1;
        yc1=lsbl->yc1;
        dx1=lsbl->dx;
        dy1=lsbl->dy;

        if(xy->x >= xc1-0.5*dx1-1e-10 && xy->x <= xc1+0.5*dx1+1e-10 
            && xy->y >= yc1-0.5*dy1-1e-10 && xy->y <= yc1+0.5*dy1+1e-10)
        {
            incell=lsbl;
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x23a19(%rip), %rax     # 0x36568
leaq 0x23a02(%rip), %r15     # 0x36558
cmpq %r15, %rax
je 0x12c0e
movq 0x20(%rax), %rcx
movsd 0x278(%rcx), %xmm2
movsd 0x288(%rcx), %xmm0
movsd (%r14), %xmm1
movapd %xmm0, %xmm3
mulsd 0x85ec(%rip), %xmm3     # 0x1b170
addsd %xmm2, %xmm3
addsd 0x8d18(%rip), %xmm3     # 0x1b8a8
ucomisd %xmm3, %xmm1
jb 0x12bfe
mulsd 0x85da(%rip), %xmm0     # 0x1b178
addsd %xmm2, %xmm0
addsd 0x88b6(%rip), %xmm0     # 0x1b460
ucomisd %xmm1, %xmm0
jb 0x12bfe
movsd 0x280(%rcx), %xmm2
movsd 0x290(%rcx), %xmm0
movsd 0x8(%r14), %xmm1
movapd %xmm0, %xmm3
mulsd 0x859e(%rip), %xmm3     # 0x1b170
addsd %xmm2, %xmm3
addsd 0x8cca(%rip), %xmm3     # 0x1b8a8
ucomisd %xmm3, %xmm1
jb 0x12bfe
mulsd 0x858c(%rip), %xmm0     # 0x1b178
addsd %xmm2, %xmm0
addsd 0x8868(%rip), %xmm0     # 0x1b460
ucomisd %xmm1, %xmm0
jae 0x12c0b
movq %rax, %rdi
callq 0x3220
jmp 0x12b56
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: wherePointAll()
void wherePointAll()
{
    int i;

    for (int jj=0; jj<N_BODY;++jj){
        for(i=0; i < NWallPts[jj]; i++)
        {
            wherePoint(&MultiCircle[jj][i],MultiCompany[jj][i].incell );
        }
        MultiCompany[jj][NWallPts[jj]]=MultiCompany[jj][0];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x105dd(%rip), %rax     # 0x23200
movslq (%rax), %r15
xorl %r12d, %r12d
testl %r15d, %r15d
cmovgl %r15d, %r12d
leaq 0x10749(%rip), %rbx     # 0x23380
leaq 0x15e6a(%rip), %r14     # 0x28aa8
subq $0x1, %r12
jb 0x12c59
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12b3d
addq $0x10, %rbx
addq $0x38, %r14
jmp 0x12c3e
imulq $0x38, %r15, %rdi
leaq 0x15e2c(%rip), %rsi     # 0x28a90
addq %rsi, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x131e2
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: computeNormalArea()
void computeNormalArea()
{
    int i=0;

    for (int jj=0; jj<N_BODY;++jj){
        for(i=0; i<NWallPts[jj]; i++)
        {
            MultiCompany[jj][i].normS[0]= MultiCircle[jj][i+1].y-MultiCircle[jj][i].y;
            MultiCompany[jj][i].normS[1]= MultiCircle[jj][i].x-MultiCircle[jj][i+1].x;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x106f6(%rip), %r14     # 0x23380
addq $0x18, %r14
leaq 0x15dfb(%rip), %rbx     # 0x28a90
xorl %r15d, %r15d
leaq 0x10561(%rip), %r12     # 0x23200
pushq $0x1
popq %rbp
movslq (%r12), %rax
cmpq %rax, %r15
jge 0x12d03
incq %r15
movsd (%r14), %xmm0
subsd -0x10(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc3aa
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%r14), %xmm0
subsd -0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0xc3aa
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x38, %rbx
addq $0x10, %r14
jmp 0x12ca2
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/rk.cpp
// Function: dof2dof0()
void dof2dof0()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag % 2 == 0 ) {
            for(int im=0;im<4; ++im)
                for(int jm=0;jm<nDOF; ++jm)
                    pcell0->dof0[im][jm]=pcell0->dof[im][jm];
        }        
        current = current->next;
    }
}

// Assembly:
leaq 0x152f5(%rip), %rax     # 0x28610
movq (%rax), %rax
testq %rax, %rax
je 0x13369
movq 0x8(%rax), %rcx
testb $0x1, 0x1b0(%rcx)
jne 0x13363
addq $0xf0, %rcx
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x13363
xorl %esi, %esi
cmpq $0x6, %rsi
je 0x1335a
movsd -0xc0(%rcx,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
jmp 0x13341
incq %rdx
addq $0x30, %rcx
jmp 0x13339
addq $0x10, %rax
jmp 0x1331b
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/rk.cpp
// Function: fn_RKTVD(bodygridclass*, int, int)
void fn_RKTVD(OctCell *unp, int nstp, int rkstp)
{
    int im,jm;
#ifdef LOCAL_TIME 
    double dt=unp->dt1;
#endif
    if(nstp<NpreTimeStp){
        dt=small_dt;
    }

    switch(rkstp){
    case 0:
        for(im=0; im<4; im++) {
            for(jm=0; jm<nDOF; jm++) {
                unp->dof[im][jm]=unp->dof0[im][jm]
                    - dt*unp->invM[jm] * unp->residual[im][jm];
            }
        }
        break;
    case 1:
        for(im=0; im<4; im++) {
            for(jm=0; jm<nDOF; jm++) {
                unp->dof[im][jm]=0.75*unp->dof0[im][jm]
                    + 0.25*(unp->dof[im][jm]- dt*unp->invM[jm]
                        * unp->residual[im][jm]);
            }
        }
        break;
    case 2:
        for(im=0; im<4; im++) {
            for(jm=0; jm<nDOF; jm++) {
                unp->dof[im][jm]=1.0/3.0*unp->dof0[im][jm] 
                    + 2.0/3.0*(unp->dof[im][jm]
                        - dt*unp->invM[jm] * unp->residual[im][jm]);
            }
        }
        break;
    }
    unp->bAvg=true;
}

// Assembly:
cmpl $-0x1a, %esi
jg 0x13383
leaq 0x1539a(%rip), %rax     # 0x28710
movabsq $0x3f40624dd2f1a9fc, %rcx # imm = 0x3F40624DD2F1A9FC
movq %rcx, (%rax)
testl %edx, %edx
je 0x13493
cmpl $0x1, %edx
je 0x13418
cmpl $0x2, %edx
jne 0x134e8
pushq $0x30
popq %rax
xorl %ecx, %ecx
leaq 0x15367(%rip), %rdx     # 0x28710
movsd 0x85b7(%rip), %xmm0     # 0x1b968
movsd 0x85b7(%rip), %xmm1     # 0x1b970
cmpq $0x4, %rcx
je 0x134e8
leaq (%rdi,%rax), %rsi
xorl %r8d, %r8d
cmpq $0x6, %r8
je 0x1340f
movsd (%rdi,%r8,8), %xmm2
mulsd (%rdx), %xmm2
mulsd 0x270(%rsi,%r8,8), %xmm2
movsd (%rsi,%r8,8), %xmm3
subsd %xmm2, %xmm3
mulsd %xmm0, %xmm3
movsd 0xc0(%rsi,%r8,8), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
movsd %xmm2, (%rsi,%r8,8)
incq %r8
jmp 0x133ca
incq %rcx
addq $0x30, %rax
jmp 0x133b9
pushq $0x30
popq %rax
xorl %ecx, %ecx
leaq 0x152ec(%rip), %rdx     # 0x28710
movsd 0x8404(%rip), %xmm0     # 0x1b830
movsd 0x8544(%rip), %xmm1     # 0x1b978
cmpq $0x4, %rcx
je 0x134e8
leaq (%rdi,%rax), %rsi
xorl %r8d, %r8d
cmpq $0x6, %r8
je 0x1348a
movsd (%rdi,%r8,8), %xmm2
mulsd (%rdx), %xmm2
mulsd 0x270(%rsi,%r8,8), %xmm2
movsd (%rsi,%r8,8), %xmm3
subsd %xmm2, %xmm3
mulsd %xmm0, %xmm3
movsd 0xc0(%rsi,%r8,8), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
movsd %xmm2, (%rsi,%r8,8)
incq %r8
jmp 0x13445
incq %rcx
addq $0x30, %rax
jmp 0x13434
pushq $0x30
popq %rax
xorl %ecx, %ecx
leaq 0x15271(%rip), %rdx     # 0x28710
cmpq $0x4, %rcx
je 0x134e8
leaq (%rdi,%rax), %rsi
xorl %r8d, %r8d
cmpq $0x6, %r8
je 0x134df
movsd (%rdi,%r8,8), %xmm0
mulsd (%rdx), %xmm0
mulsd 0x270(%rsi,%r8,8), %xmm0
movsd 0xc0(%rsi,%r8,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%r8,8)
incq %r8
jmp 0x134ac
incq %rcx
addq $0x30, %rax
jmp 0x1349f
movb $0x1, 0x206(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/rk.cpp
// Function: fn_RKTVDAll(int, int)
void fn_RKTVDAll(int tstp, int rkstp)
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag == 0 && current->flg<=2 ) {
            fn_RKTVD(pcell0,tstp, rkstp);
        }        
        current = current->next;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
leaq 0x15111(%rip), %r14     # 0x28610
movq (%r14), %r14
testq %r14, %r14
je 0x1352b
movq 0x8(%r14), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x13525
cmpw $0x2, (%r14)
jg 0x13525
movl %ebp, %esi
movl %ebx, %edx
callq 0x1336a
addq $0x10, %r14
jmp 0x134ff
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/farfield_boundary.cpp
// Function: inlet_outletBndry()
void inlet_outletBndry()
{
    for(vector<OctCell *> ::size_type isz=0; isz<InletBndry.size();++isz){
        getInletOutletBndry(InletBndry[isz], 0);
    }

    for(vector<OctCell *> ::size_type isz=0; isz<OutletBndry.size();++isz){
        getInletOutletBndry(OutletBndry[isz], 1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
leaq 0x14462(%rip), %r14     # 0x28638
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rbx
jae 0x141f9
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
callq 0x13fee
incq %rbx
jmp 0x141d6
xorl %r14d, %r14d
leaq 0x1444d(%rip), %r15     # 0x28650
pushq $0x1
popq %rbx
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jae 0x14229
movq (%rax,%r14,8), %rdi
movl %ebx, %esi
callq 0x13fee
incq %r14
jmp 0x14206
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/time_step.cpp
// Function: getTimeStep(bodygridclass*)
void getTimeStep(OctCell *unp)
{

	double u, v;

	double dx,dy;

	double a;
	JBBL jbu;
	SHBL shu;

	dx=unp->dx;
	dy=unp->dy;
	shu.q=unp->dof[0][0];
	shu.qu=unp->dof[1][0];
	shu.qv=unp->dof[2][0];
	shu.te=unp->dof[3][0];	
			
	shblToJbbl(&shu,&jbu);

	u = jbu.u;
	v = jbu.v; 

	a = sqrt(GAMMA * jbu.p / jbu.q);

    	unp->dt1 = CFL * dx * dy/ ((fabs(u) + a)*dy + (fabs(v) + a)*dx);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movsd 0x288(%rdi), %xmm5
movsd 0x290(%rdi), %xmm4
movsd 0x30(%rdi), %xmm1
movsd 0x60(%rdi), %xmm3
movsd 0x90(%rdi), %xmm6
divsd %xmm1, %xmm3
divsd %xmm1, %xmm6
movapd %xmm6, %xmm0
mulsd %xmm6, %xmm0
movapd %xmm3, %xmm2
mulsd %xmm3, %xmm2
addsd %xmm0, %xmm2
movsd 0x577d(%rip), %xmm0     # 0x1b170
mulsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
addsd 0xc0(%rdi), %xmm0
mulsd 0x581d(%rip), %xmm0     # 0x1b228
mulsd 0x581d(%rip), %xmm0     # 0x1b230
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x15a27
sqrtsd %xmm0, %xmm0
jmp 0x15a5a
movapd %xmm3, 0x20(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm5, (%rsp)
movapd %xmm6, 0x10(%rsp)
callq 0x3180
movapd 0x10(%rsp), %xmm6
movsd (%rsp), %xmm5
movsd 0x8(%rsp), %xmm4
movapd 0x20(%rsp), %xmm3
leaq 0xd7bf(%rip), %rax      # 0x23220
movsd (%rax), %xmm1
mulsd %xmm5, %xmm1
mulsd %xmm4, %xmm1
movapd 0x57cb(%rip), %xmm2     # 0x1b240
andpd %xmm2, %xmm3
addsd %xmm0, %xmm3
andpd %xmm2, %xmm6
addsd %xmm0, %xmm6
mulsd %xmm5, %xmm6
mulsd %xmm4, %xmm3
addsd %xmm6, %xmm3
divsd %xmm3, %xmm1
movsd %xmm1, 0x298(%rbx)
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/time_step.cpp
// Function: timestep()
void timestep()
{		
  Node *current;
  current = HeadListAllGrid;  
  OctCell *pcell0;
  
  dt=2000.0;			
  current = HeadListAllGrid;     
  while(current != NULL)
  {		
    pcell0 = current->cell;
    if(pcell0->flag == 0 && current->flg<=2 ) {
        getTimeStep(pcell0);
#ifndef LOCAL_TIME         
       getMinTimeStep(pcell0); 
#endif       
     }
    current = current->next;
  }			
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x12c62(%rip), %rax     # 0x28710
movabsq $0x409f400000000000, %rcx # imm = 0x409F400000000000
movq %rcx, (%rax)
leaq 0x12b4e(%rip), %r14     # 0x28610
movq (%r14), %r14
testq %r14, %r14
je 0x15af5
movq 0x8(%r14), %rbx
cmpw $0x0, 0x1b0(%rbx)
jne 0x15aef
cmpw $0x2, (%r14)
jg 0x15aef
movq %rbx, %rdi
callq 0x159a5
movq %rbx, %rdi
callq 0x1597c
addq $0x10, %r14
jmp 0x15ac2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/initial_data.cpp
// Function: left_shock_sol(double, double, double, double, double&, double&, double&)
void left_shock_sol(double qr,double ur, double pr,double Ms,
	double &ql, double &ul, double &pl)//Ms shock wave Mach number
{
	double Mr;
	double ar;
	double gr;
	double mrs2;
	gr=GAMMA;
	ar=sqrt(gr*pr/qr);
	Mr=ur/ar;
	mrs2=(Mr-Ms)*(Mr-Ms);
	ql=qr*(gr+1)*mrs2/((gr-1)*mrs2+2.0);
	pl=pr*(2.0*gr*mrs2-(gr-1))/(gr+1);
	ul=(1.0-qr/ql)*Ms*ar+ur*qr/ql;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movapd %xmm0, %xmm5
movsd 0x5712(%rip), %xmm0     # 0x1b230
mulsd %xmm2, %xmm0
divsd %xmm5, %xmm0
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
jb 0x15b36
sqrtsd %xmm0, %xmm0
jmp 0x15b69
movsd %xmm5, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x3180
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm5
movapd %xmm1, %xmm6
divsd %xmm0, %xmm6
subsd %xmm3, %xmm6
mulsd %xmm6, %xmm6
movsd 0x5e2e(%rip), %xmm8     # 0x1b9b0
movapd %xmm5, %xmm7
mulsd %xmm8, %xmm7
mulsd %xmm6, %xmm7
movsd 0x5691(%rip), %xmm4     # 0x1b228
mulsd %xmm6, %xmm4
addsd 0x551d(%rip), %xmm4     # 0x1b0c0
divsd %xmm4, %xmm7
movsd %xmm7, (%r15)
mulsd 0x5e04(%rip), %xmm6     # 0x1b9b8
addsd 0x5e04(%rip), %xmm6     # 0x1b9c0
mulsd %xmm2, %xmm6
divsd %xmm8, %xmm6
movsd %xmm6, (%r14)
movsd (%r15), %xmm4
movapd %xmm5, %xmm2
divsd %xmm4, %xmm2
movsd 0x5641(%rip), %xmm6     # 0x1b220
subsd %xmm2, %xmm6
mulsd %xmm3, %xmm6
mulsd %xmm1, %xmm5
divsd %xmm4, %xmm5
mulsd %xmm0, %xmm6
addsd %xmm5, %xmm6
movsd %xmm6, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/initial_data.cpp
// Function: right_shock_sol(double, double, double, double, double&, double&, double&)
void right_shock_sol(double ql,double ul, double pl,double Ms,
	double &qr, double &ur, double &pr)//Ms shock wave Mach number
{
	double Ml;
	double al;
	double gr;
	double mrs2;
	gr=GAMMA;
	al=sqrt(gr*pl/ql);
	Ml=ul/al;
	mrs2=(Ml-Ms)*(Ml-Ms);
	qr=ql*(gr+1)*mrs2/((gr-1)*mrs2+2.0);
	pr=pl*(2.0*gr*mrs2-(gr-1))/(gr+1);
	ur=(1.0-ql/qr)*Ms*al+ul*ql/qr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movapd %xmm0, %xmm5
movsd 0x560d(%rip), %xmm0     # 0x1b230
mulsd %xmm2, %xmm0
divsd %xmm5, %xmm0
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
jb 0x15c3b
sqrtsd %xmm0, %xmm0
jmp 0x15c6e
movsd %xmm5, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x3180
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm5
movapd %xmm1, %xmm6
divsd %xmm0, %xmm6
subsd %xmm3, %xmm6
mulsd %xmm6, %xmm6
movsd 0x5d29(%rip), %xmm8     # 0x1b9b0
movapd %xmm5, %xmm7
mulsd %xmm8, %xmm7
mulsd %xmm6, %xmm7
movsd 0x558c(%rip), %xmm4     # 0x1b228
mulsd %xmm6, %xmm4
addsd 0x5418(%rip), %xmm4     # 0x1b0c0
divsd %xmm4, %xmm7
movsd %xmm7, (%r15)
mulsd 0x5cff(%rip), %xmm6     # 0x1b9b8
addsd 0x5cff(%rip), %xmm6     # 0x1b9c0
mulsd %xmm2, %xmm6
divsd %xmm8, %xmm6
movsd %xmm6, (%r14)
movsd (%r15), %xmm4
movapd %xmm5, %xmm2
divsd %xmm4, %xmm2
movsd 0x553c(%rip), %xmm6     # 0x1b220
subsd %xmm2, %xmm6
mulsd %xmm3, %xmm6
mulsd %xmm1, %xmm5
divsd %xmm4, %xmm5
mulsd %xmm0, %xmm6
addsd %xmm5, %xmm6
movsd %xmm6, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/tvbm_limiter4all.cpp
// Function: minmod3n(double, double, double)
double minmod3n(double a1, double a2, double a3)
{

    double tmp;
    if(a1>0.0 && a2>0.0 && a3>0.0) 
        tmp=min3(a1,a2,a3);
    else if(a1<0.0 && a2 < 0.0 && a3<0.0)
        tmp=max3(a1,a2,a3);
    else 
        tmp=0.0;
    return tmp;

}

// Assembly:
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jbe 0x163b0
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
jbe 0x163b0
ucomisd %xmm4, %xmm2
jbe 0x163b0
minsd %xmm1, %xmm0
minsd %xmm2, %xmm0
jmp 0x163ce
ucomisd %xmm0, %xmm3
jbe 0x163d2
xorpd %xmm4, %xmm4
ucomisd %xmm1, %xmm4
jbe 0x163d2
ucomisd %xmm2, %xmm4
jbe 0x163d2
maxsd %xmm1, %xmm0
maxsd %xmm2, %xmm0
movapd %xmm0, %xmm3
movapd %xmm3, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/tvbm_limiter4all.cpp
// Function: tvdm_limiter4all()
void tvdm_limiter4all()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag == 0 && current->flg<=2 ) {
#ifdef KXRCF_LIM
            if(pcell0->trb==true)
#endif
            tvbm_limiter(pcell0);
        }        
        current = current->next;
    }
}

// Assembly:
pushq %rbx
leaq 0x114ef(%rip), %rbx     # 0x28610
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x17151
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x1714b
cmpw $0x2, (%rbx)
jg 0x1714b
cmpb $0x1, 0x210(%rdi)
jne 0x1714b
callq 0x163fe
addq $0x10, %rbx
jmp 0x17121
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/tvbm_limiter4all.cpp
// Function: pos_limiter4all()
void pos_limiter4all()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag == 0 && current->flg<=2 ) {
            pos_limiter(pcell0);
        }        
        current = current->next;
    }
}

// Assembly:
pushq %rbx
leaq 0x10e3a(%rip), %rbx     # 0x28610
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x177fd
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x177f7
cmpw $0x2, (%rbx)
jg 0x177f7
callq 0x17153
addq $0x10, %rbx
jmp 0x177d6
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: parent_avg(bodygridclass*)
void parent_avg(OctCell *pcell)
{
    int lev=pcell->level;

    OctCell *parent;
    parent=pcell->parent;
    int isum=0;

    // while(lev>=0) { //>0 or >=0 ?? TODO
    while(parent!=NULL) {
        if(parent->bAvg!=true){
            if(parent->children[0]->bAvg== true 
                && parent->children[1]->bAvg== true
                && parent->children[2]->bAvg== true 
                && parent->children[3]->bAvg== true){
                limit_cell_avg(parent); //由儿子的单元平均获得父亲的单元平均
            }
            else{
                break;
            }

        }   
        ++isum;
        if(isum>back_para) break;
        parent=parent->parent;

    }        
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x5
popq %rbp
movq 0x250(%rbx), %rbx
testq %rbx, %rbx
je 0x178fe
cmpb $0x0, 0x206(%rbx)
jne 0x178fa
movq 0x258(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x178fe
movq 0x260(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x178fe
movq 0x268(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x178fe
movq 0x270(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x178fe
movq %rbx, %rdi
callq 0x17905
decl %ebp
jne 0x1789d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: limit_cell_avg(bodygridclass*)
void limit_cell_avg(OctCell *pcell)
{
    pcell->bAvg=true;

    for(int i=0; i<4;++i) {
        pcell->dof[i][0]=0.25*(pcell->children[0]->dof[i][0] 
            + pcell->children[1]->dof[i][0] 
            + pcell->children[2]->dof[i][0] +pcell->children[3]->dof[i][0] );
    }
}

// Assembly:
movb $0x1, 0x206(%rdi)
movq 0x258(%rdi), %rax
movq 0x260(%rdi), %rcx
movq 0x268(%rdi), %rdx
movq 0x270(%rdi), %rsi
pushq $0x30
popq %r8
movsd 0x3efc(%rip), %xmm0     # 0x1b830
cmpq $0xf0, %r8
je 0x17965
movsd (%rax,%r8), %xmm1
addsd (%rcx,%r8), %xmm1
addsd (%rdx,%r8), %xmm1
addsd (%rsi,%r8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%r8)
addq $0x30, %r8
jmp 0x17934
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: tree_0bAvg()
void tree_0bAvg()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    short lev0;
    OctCell *pnbr[4]={NULL};
    short levnbr[4];

    current = HeadListAllGrid;     
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag%2 == 0 && current->flg<=2 ) {
            lev0=pcell0->level;

            pnbr[0]=EastNeighbor(pcell0);
            pnbr[1]=SouthNeighbor(pcell0);
            pnbr[2]=WestNeighbor(pcell0);
            pnbr[3]=NorthNeighbor(pcell0);

            for(int i=0;i<4;++i){
                levnbr[i]=pnbr[i]->level;
              //  reflg0[i]=pnbr[i]->reflag;
                if(lev0>levnbr[i]){
                    parent0bAvg(pcell0);     
                    //for(int j=0;j<4;++j){
                    //    parent0bAvg(pnbr[j]);     
                    //}
                    break;
                }
            }
        }
        current = current->next;
    }			
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x10c9b(%rip), %r14     # 0x28610
movq (%r14), %r14
testq %r14, %r14
je 0x179f1
movq 0x8(%r14), %rbx
testb $0x1, 0x1b0(%rbx)
jne 0x179eb
cmpw $0x2, (%r14)
jg 0x179eb
movzwl 0x1f8(%rbx), %ebp
movq %rbx, %rdi
callq 0x858f
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x8610
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x850c
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x8488
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x4, %rax
je 0x179eb
movq (%rsp,%rax,8), %rcx
incq %rax
cmpw 0x1f8(%rcx), %bp
jle 0x179cd
movq %rbx, %rdi
callq 0x17830
addq $0x10, %r14
jmp 0x17975
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: tree_avg()
void tree_avg()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    OctCell *pnbr[4]={NULL};
    short levnbr[4]={0};
   // short reflgnbr[4]={0};
    short lev0;
    //short reflg0;

    current = HeadListAllGrid;     
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag%2 == 0 && current->flg<=2 ) {
            lev0=pcell0->level;
           // reflg0=pcell0->reflag;

            pnbr[0]=EastNeighbor(pcell0);
            pnbr[1]=SouthNeighbor(pcell0);
            pnbr[2]=WestNeighbor(pcell0);
            pnbr[3]=NorthNeighbor(pcell0);
            for(int i=0;i<4;++i){
                levnbr[i]=pnbr[i]->level;
              //  reflg0[i]=pnbr[i]->reflag;
                if(lev0>levnbr[i]){
                    parent_avg(pcell0);     
                    // for(int j=0;j<4;++j){
                   //   parent_avg(pnbr[j]);     
                     //}
                    break;
                }
            }
        }
        current = current->next;
    }			
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x10c07(%rip), %r14     # 0x28610
movq (%r14), %r14
testq %r14, %r14
je 0x17a85
movq 0x8(%r14), %rbx
testb $0x1, 0x1b0(%rbx)
jne 0x17a7f
cmpw $0x2, (%r14)
jg 0x17a7f
movzwl 0x1f8(%rbx), %ebp
movq %rbx, %rdi
callq 0x858f
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x8610
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x850c
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x8488
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x4, %rax
je 0x17a7f
movq (%rsp,%rax,8), %rcx
incq %rax
cmpw 0x1f8(%rcx), %bp
jle 0x17a61
movq %rbx, %rdi
callq 0x17894
addq $0x10, %r14
jmp 0x17a09
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: getAllVorM()
void getAllVorM()
{
    solveGradient();

    Node *current;
    current = HeadListAllGrid;  
    OctCell *lsbl;

    Vec2D tpvec;
    double jl0,jl1,jl2,jl3;
    double maxhxy;
    maxhxy=max2(hx,hy);
    sumVorM=0.0;

    while(current != NULL)
    {		
        lsbl = current->cell;
        if(lsbl->flag == 0 && current->flg==0
            //   && lsbl->xc1<xOutlet-1.0*hx
            //    && lsbl->xc1>xInlet+1.0*hx
            //   && lsbl->yc1>ExtPnt1[1]+1.0*hy
            //   && lsbl->yc1<ExtPnt3[1]-1.0*hy
          ) {
#if IS_TUBE==1
            tpvec[0]=lsbl->xc1;
            tpvec[1]=lsbl->yc1;
            jl0=fabs(tpvec-ExtPnt0);
            jl1=fabs(tpvec-ExtPnt1);
            jl2=fabs(tpvec-ExtPnt2);
            jl3=fabs(tpvec-ExtPnt3);

            if(jl0>3.0*maxhxy && jl1>3.0*maxhxy
                && jl2 > 3.0*maxhxy && jl3>3.0*maxhxy){
#endif
                getCellVorM(lsbl);

                sumVorM+=lsbl->vorM;

#if IS_TUBE==1
            }
#endif
        }        
        current = current->next;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x1899b
leaq 0xfdc9(%rip), %rax      # 0x28610
movq (%rax), %r14
leaq 0x18(%rsp), %rbx
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
movq %rbx, %rdi
callq 0xc11c
leaq 0x100ca(%rip), %r15     # 0x28930
andq $0x0, (%r15)
leaq 0xffff(%rip), %r12      # 0x28870
leaq 0x10008(%rip), %r13     # 0x28880
testq %r14, %r14
je 0x1898c
movq 0x8(%r14), %rbp
cmpw $0x0, 0x1b0(%rbp)
jne 0x18983
cmpw $0x0, (%r14)
jne 0x18983
movsd 0x278(%rbp), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc3aa
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x280(%rbp), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0xc3aa
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
leaq 0xff67(%rip), %rsi      # 0x28850
callq 0xc344
callq 0xc13d
movsd %xmm0, (%rsp)
movq %rbx, %rdi
leaq 0xff5e(%rip), %rsi      # 0x28860
callq 0xc344
callq 0xc13d
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc344
callq 0xc13d
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc344
callq 0xc13d
movsd 0x3350(%rip), %xmm1     # 0x1bc90
movsd (%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x18983
movsd 0x10(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x18983
movsd 0x8(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x18983
ucomisd %xmm1, %xmm0
jbe 0x18983
movq %rbp, %rdi
callq 0x18804
movsd 0x208(%rbp), %xmm0
addsd (%r15), %xmm0
movsd %xmm0, (%r15)
movq 0x10(%r14), %r14
jmp 0x18878
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: solveGradient()
void solveGradient()
{
    double fjbx[4],fjby[4];
    double vol0,vol1;

    for(vector<Face>::size_type isz=0; isz!=faces_comp.size(); ++isz){
        for(int i=0;i<4;++i){
            faces_comp[isz].parent->Ux[i]=0.0;
            faces_comp[isz].parent->Uy[i]=0.0;
            faces_comp[isz].neighbor->Ux[i]=0.0;
            faces_comp[isz].neighbor->Uy[i]=0.0;
        }
    }

    for(vector<Face>::size_type isz=0; isz!=faces_comp.size(); ++isz){
        solveEdge4Gradient(faces_comp[isz], fjbx,fjby);
        vol0=faces_comp[isz].parent->dx*faces_comp[isz].parent->dy;
        vol1=faces_comp[isz].neighbor->dx*faces_comp[isz].neighbor->dy;
        for(int i=0;i<4;++i){
            faces_comp[isz].parent->Ux[i]+=fjbx[i]/vol0;
            faces_comp[isz].parent->Uy[i]+=fjby[i]/vol0;;
            faces_comp[isz].neighbor->Ux[i]-=fjbx[i]/vol1;
            faces_comp[isz].neighbor->Uy[i]-=fjby[i]/vol1;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0xfcd0(%rip), %rax      # 0x28680
movq (%rax), %r12
movq 0x8(%rax), %rax
subq %r12, %rax
movl $0xc0, %ecx
cqto
idivq %rcx
movq %rax, %rbx
xorl %eax, %eax
pushq $-0x20
popq %rcx
cmpq %rbx, %rax
je 0x18a18
imulq $0xc0, %rax, %rsi
movq (%r12,%rsi), %rdx
movq 0x8(%r12,%rsi), %rsi
movq %rcx, %rdi
testq %rdi, %rdi
je 0x18a13
andq $0x0, 0x1d8(%rdx,%rdi)
andq $0x0, 0x1f8(%rdx,%rdi)
andq $0x0, 0x1d8(%rsi,%rdi)
andq $0x0, 0x1f8(%rsi,%rdi)
addq $0x8, %rdi
jmp 0x189e4
incq %rax
jmp 0x189cc
xorl %r13d, %r13d
leaq 0x20(%rsp), %r14
movq %rsp, %r15
cmpq %rbx, %r13
je 0x18af3
imulq $0xc0, %r13, %rbp
leaq (%r12,%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x19e88
movq (%r12,%rbp), %rax
movq 0x8(%r12,%rbp), %rcx
movsd 0x288(%rax), %xmm0
mulsd 0x290(%rax), %xmm0
movsd 0x288(%rcx), %xmm1
mulsd 0x290(%rcx), %xmm1
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x18aeb
movsd 0x20(%rsp,%rdx,8), %xmm2
movapd %xmm2, %xmm3
divsd %xmm0, %xmm3
addsd 0x1b8(%rax,%rdx,8), %xmm3
movsd %xmm3, 0x1b8(%rax,%rdx,8)
movsd (%rsp,%rdx,8), %xmm3
movapd %xmm3, %xmm4
divsd %xmm0, %xmm4
addsd 0x1d8(%rax,%rdx,8), %xmm4
movsd %xmm4, 0x1d8(%rax,%rdx,8)
divsd %xmm1, %xmm2
movsd 0x1b8(%rcx,%rdx,8), %xmm4
subsd %xmm2, %xmm4
movsd 0x1d8(%rcx,%rdx,8), %xmm2
movsd %xmm4, 0x1b8(%rcx,%rdx,8)
divsd %xmm1, %xmm3
subsd %xmm3, %xmm2
movsd %xmm2, 0x1d8(%rcx,%rdx,8)
incq %rdx
jmp 0x18a6d
incq %r13
jmp 0x18a23
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: getAdaptiveParameters(bodygridclass*)
void getAdaptiveParameters(OctCell *unp)
{
    double li;
    li=pow(sqrt(unp->dx*unp->dy),1.5);
    unp->tcur=fabs(unp->Ux[2]-unp->Uy[1])*li;
    unp->vorM=(unp->Ux[2]-unp->Uy[1])*unp->dx*unp->dy;
    unp->tdiv=fabs(unp->Ux[1]+unp->Uy[2])*li;
//0:den,1:press, 2:entropy,3:
#if ADAPTIVE_INDICATOR==0
    unp->pio=sqrt((unp->Ux[0]*unp->Ux[0])+(unp->Uy[0]*unp->Uy[0]))*li;
#elif ADAPTIVE_INDICATOR==1 
    unp->pio=sqrt((unp->Ux[3]*unp->Ux[3])+(unp->Uy[3]*unp->Uy[3]))*li;
#elif ADAPTIVE_INDICATOR==2
    double ason2, a2;//ason2:pressure
    ason2=GAM11*(unp->dof[3][0]-0.5*(unp->dof[1][0]*unp->dof[1][0]
   /unp->dof[0][0]+unp->dof[2][0]*unp->dof[2][0]/unp->dof[0][0]));
    a2=GAMMA*ason2/unp->dof[0][0];
    unp->pio=(fabs(unp->Ux[3]-a2*unp->Ux[0])
        +fabs(unp->Uy[3]-a2*unp->Uy[0]))*li;
#elif ADAPTIVE_INDICATOR==3
#else
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x288(%rdi), %xmm0
mulsd 0x290(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x18b26
sqrtsd %xmm0, %xmm0
jmp 0x18b2b
callq 0x3180
movsd 0x2c85(%rip), %xmm1     # 0x1b7b8
callq 0x3340
movupd 0x1c0(%rbx), %xmm1
shufpd $0x1, %xmm1, %xmm1      # xmm1 = xmm1[1,0]
movupd 0x1e0(%rbx), %xmm2
movapd %xmm1, %xmm3
subpd %xmm2, %xmm3
addpd %xmm2, %xmm1
movsd %xmm3, %xmm1            # xmm1 = xmm3[0],xmm1[1]
mulsd 0x288(%rbx), %xmm3
mulsd 0x290(%rbx), %xmm3
movsd %xmm3, 0x208(%rbx)
andpd 0x26c3(%rip), %xmm1     # 0x1b240
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm1, %xmm2
movupd %xmm2, 0x238(%rbx)
movsd 0x1b8(%rbx), %xmm1
movsd 0x1d8(%rbx), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
sqrtsd %xmm1, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x248(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: charg_sol_grid(bodygridclass*)
void charg_sol_grid(OctCell *pg)//pg为网格单元的指针
{
	bool refflag;
    Vec2D tpvec;
    double jl0,jl1,jl2,jl3;
    double maxhxy;
    maxhxy=max2(hx,hy);
	switch(AMRP)
	{	
	case 0: 
        refflag=(pg->tcur > refine_coe*Sigma_curl
            || pg->tdiv > refine_coe1*Sigma_div);
        break;
	case 1: refflag=(pg->tdiv > refine_coe*Sigma_div); break;	
	case 2: refflag=(pg->tcur > refine_coe*Sigma_curl); break;
	case 3: refflag=(pg->pio > refine_coe*Sigma_pio); break;
	case 4: 
        refflag=(pg->tdiv > refine_coe*Sigma_div
            || pg->pio > refine_coe1*Sigma_pio);
        break;
    case 5:
        refflag=(pg->tdiv > refine_coe*Sigma_div || pg->trbamr);
        break;
	}

	if(refflag==true)
	{
#if IS_TUBE==1
        tpvec[0]=pg->xc1;
        tpvec[1]=pg->yc1;
        jl0=fabs(tpvec-ExtPnt0);
        jl1=fabs(tpvec-ExtPnt1);
        jl2=fabs(tpvec-ExtPnt2);
        jl3=fabs(tpvec-ExtPnt3);

        if(jl0>3.0*maxhxy && jl1>3.0*maxhxy
            && jl2 > 3.0*maxhxy && jl3>3.0*maxhxy)
#endif
            solrefcell.push_back(pg);

		//solrefcell[Namr]=pg;//用于存放需要加密的网格单元地址的数组
	    //Namr++;//记录需要加密的网格单元的数目
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movq %rdi, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0xc11c
movsd 0x240(%r14), %xmm0
movsd 0x1d7da(%rip), %xmm1    # 0x36628
mulsd 0x2c92(%rip), %xmm1     # 0x1bae8
ucomisd %xmm1, %xmm0
ja 0x18e7f
movsd 0x248(%r14), %xmm0
movsd 0x1d7c3(%rip), %xmm1    # 0x36630
mulsd 0x2c83(%rip), %xmm1     # 0x1baf8
ucomisd %xmm1, %xmm0
jbe 0x18f78
movsd 0x278(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc3aa
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x280(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xc3aa
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0xf97e(%rip), %rsi      # 0x28850
movq %rbx, %rdi
callq 0xc344
callq 0xc13d
movsd %xmm0, 0x8(%rsp)
leaq 0xf974(%rip), %rsi      # 0x28860
movq %rbx, %rdi
callq 0xc344
callq 0xc13d
movsd %xmm0, 0x18(%rsp)
leaq 0xf96a(%rip), %rsi      # 0x28870
movq %rbx, %rdi
callq 0xc344
callq 0xc13d
movsd %xmm0, 0x10(%rsp)
leaq 0xf960(%rip), %rsi      # 0x28880
movq %rbx, %rdi
callq 0xc344
callq 0xc13d
movsd 0x8(%rsp), %xmm1
ucomisd 0x2d55(%rip), %xmm1     # 0x1bc90
jbe 0x18f78
movsd 0x18(%rsp), %xmm1
ucomisd 0x2d45(%rip), %xmm1     # 0x1bc90
jbe 0x18f78
movsd 0x10(%rsp), %xmm1
ucomisd 0x2d35(%rip), %xmm1     # 0x1bc90
jbe 0x18f78
ucomisd 0x2d2b(%rip), %xmm0     # 0x1bc90
jbe 0x18f78
leaq 0xa3e2(%rip), %rdi      # 0x23350
leaq 0x20(%rsp), %rsi
callq 0xb262
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: find_sol_refp(bodygridclass**, bodygridclass*)
void find_sol_refp(OctCell *pp[],OctCell *parent)
{ 		
	pp[0]=EastNeighbor(parent);	
	pp[1]=WestNeighbor(parent);		
	pp[2]=NorthNeighbor(parent);
	pp[3]=SouthNeighbor(parent);	
	pp[4]=WestNeighbor(pp[2]);
	pp[5]=EastNeighbor(pp[2]);		
	pp[6]=WestNeighbor(pp[3]); 	
	pp[7]=EastNeighbor(pp[3]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x858f
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x850c
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x8488
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x8610
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %rdi
callq 0x850c
movq %rax, 0x20(%rbx)
movq 0x10(%rbx), %rdi
callq 0x858f
movq %rax, 0x28(%rbx)
movq 0x18(%rbx), %rdi
callq 0x850c
movq %rax, 0x30(%rbx)
movq 0x18(%rbx), %rdi
callq 0x858f
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq