LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbc79(%rip), %xmm2     # 0x1d1c0
movsd 0xbeb1(%rip), %xmm4     # 0x1d400
ucomisd %xmm2, %xmm4
jbe 0x1155f
movsd (%rdi), %xmm1
movsd %xmm1, (%rcx)
jmp 0x115dd
movsd (%rsi), %xmm2
movapd %xmm2, %xmm3
subsd (%rdx), %xmm3
movapd 0xbc4d(%rip), %xmm5     # 0x1d1c0
andpd %xmm3, %xmm5
ucomisd %xmm5, %xmm4
jbe 0x11588
movsd %xmm2, (%rcx)
movsd 0x8(%rdi), %xmm0
jmp 0x115dd
movsd 0x8(%rdi), %xmm4
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
subsd %xmm1, %xmm0
divsd %xmm3, %xmm0
movsd 0xbe07(%rip), %xmm1     # 0x1d3a8
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_O3/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 0x11c94
sqrtsd %xmm0, %xmm0
jmp 0x11cdd
movapd %xmm8, 0x40(%rsp)
movapd %xmm9, 0x30(%rsp)
movapd %xmm10, 0x20(%rsp)
movapd %xmm11, 0x10(%rsp)
movapd %xmm12, (%rsp)
callq 0x31b0
movapd (%rsp), %xmm12
movapd 0x10(%rsp), %xmm11
movapd 0x20(%rsp), %xmm10
movapd 0x30(%rsp), %xmm9
movapd 0x40(%rsp), %xmm8
movapd 0xb4db(%rip), %xmm1     # 0x1d1c0
andpd %xmm1, %xmm12
addsd 0xbb65(%rip), %xmm12    # 0x1d858
divsd %xmm12, %xmm0
mulsd %xmm10, %xmm9
mulsd %xmm11, %xmm8
subsd %xmm9, %xmm8
andpd %xmm1, %xmm8
cmpltsd 0xbb4a(%rip), %xmm8     # 0x1d860
movsd 0xbb4a(%rip), %xmm1     # 0x1d868
andpd %xmm8, %xmm1
andnpd %xmm0, %xmm8
orpd %xmm1, %xmm8
movapd %xmm8, %xmm0
addq $0x58, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x122b4
xorl %r15d, %r15d
movq 0x258(%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x12275
testq %rax, %rax
jne 0x12353
incq %r15
cmpq $0x4, %r15
jne 0x1228d
jmp 0x1234f
movsd 0x278(%rbx), %xmm2
movsd 0x288(%rbx), %xmm0
movsd (%r14), %xmm1
movsd 0xae77(%rip), %xmm3     # 0x1d148
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
addsd 0xae6f(%rip), %xmm3     # 0x1d150
ucomisd %xmm1, %xmm3
jbe 0x1234f
mulsd 0xae51(%rip), %xmm0     # 0x1d140
addsd %xmm2, %xmm0
addsd 0xb575(%rip), %xmm0     # 0x1d870
ucomisd %xmm0, %xmm1
jbe 0x1234f
movsd 0x290(%rbx), %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x280(%rbx), %xmm2
movsd 0xae29(%rip), %xmm3     # 0x1d148
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
addsd 0xae21(%rip), %xmm3     # 0x1d150
ucomisd %xmm1, %xmm3
jbe 0x1234f
mulsd 0xae03(%rip), %xmm0     # 0x1d140
addsd %xmm2, %xmm0
addsd 0xb527(%rip), %xmm0     # 0x1d870
ucomisd %xmm0, %xmm1
ja 0x12356
xorl %ebx, %ebx
jmp 0x12356
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12ca6
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x258(%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x12c6a
incq %r15
cmpq $0x4, %r15
jne 0x12c8b
jmp 0x12cb3
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6c64
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x151d0(%rip), %rax     # 0x29618
movq (%rax), %r15
leaq 0x230fe(%rip), %rdi     # 0x37550
callq 0x6c36
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %r15, %r15
je 0x144db
leaq 0xfe67(%rip), %r12      # 0x242e0
movq %rsp, %rbx
leaq 0x230cd(%rip), %r14     # 0x37550
movq (%r15), %r13
movl 0x200(%r13), %eax
imulq $0x360, %rax, %rsi      # imm = 0x360
addq (%r12), %rsi
movq %rbx, %rdi
callq 0x1b384
movl 0x200(%r13), %eax
imulq $0x360, %rax, %rdi      # imm = 0x360
addq (%r12), %rdi
movq %r14, %rsi
callq 0x1c4f0
xorl %r13d, %r13d
movq (%rsp,%r13,8), %rdi
movq %r14, %rsi
callq 0x1c4f0
incq %r13
cmpq $0x8, %r13
jne 0x144bd
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x14483
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfc16(%rip), %rax      # 0x24200
movslq (%rax), %r15
testq %r15, %r15
jle 0x1461b
leaq 0xfd87(%rip), %rbx      # 0x24380
leaq 0x154a8(%rip), %r14     # 0x29aa8
movq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x144e9
addq $0x10, %rbx
addq $0x38, %r14
decq %r12
jne 0x14603
imulq $0x38, %r15, %r14
leaq 0x1546a(%rip), %rbx     # 0x29a90
leaq (%rbx,%r14), %rdi
movq %rbx, %rsi
callq 0xcfb8
movaps 0x15467(%rip), %xmm0    # 0x29aa0
movups %xmm0, 0x10(%r14,%rbx)
movaps 0x1546a(%rip), %xmm0    # 0x29ab0
movups %xmm0, 0x20(%r14,%rbx)
movq 0x1546d(%rip), %rax     # 0x29ac0
movq %rax, 0x30(%r14,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xfb8d(%rip), %r14      # 0x24200
cmpl $0x0, (%r14)
jle 0x146eb
leaq 0xfd00(%rip), %r15      # 0x24380
addq $0x18, %r15
leaq 0x15405(%rip), %rbx     # 0x29a90
xorl %r12d, %r12d
incq %r12
movsd (%r15), %xmm0
subsd -0x10(%r15), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd1c0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%r15), %xmm0
subsd -0x8(%r15), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xd1c0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movslq (%r14), %rax
addq $0x38, %rbx
addq $0x10, %r15
cmpq %rax, %r12
jl 0x1468e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14869(%rip), %rax     # 0x29610
movq (%rax), %rax
testq %rax, %rax
je 0x14df0
movq 0x8(%rax), %rcx
testb $0x1, 0x1b0(%rcx)
jne 0x14dea
addq $0xf0, %rcx
xorl %edx, %edx
xorl %esi, %esi
movups -0xc0(%rcx,%rsi,8), %xmm0
movups %xmm0, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq $0x6, %rsi
jne 0x14dc7
incq %rdx
addq $0x30, %rcx
cmpq $0x4, %rdx
jne 0x14dc5
movq 0x10(%rax), %rax
jmp 0x14daa
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14e0a
leaq 0x14913(%rip), %rax     # 0x29710
movabsq $0x3f40624dd2f1a9fc, %rcx # imm = 0x3F40624DD2F1A9FC
movq %rcx, (%rax)
testl %edx, %edx
je 0x14f15
cmpl $0x1, %edx
je 0x14e9e
cmpl $0x2, %edx
jne 0x14f68
movl $0x30, %eax
xorl %ecx, %ecx
leaq 0x148de(%rip), %rdx     # 0x29710
movsd 0x8afe(%rip), %xmm0     # 0x1d938
movsd 0x8afe(%rip), %xmm1     # 0x1d940
leaq (%rdi,%rax), %rsi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm2
movsd (%rdi,%r8,8), %xmm3
mulsd (%rdx), %xmm3
mulsd 0x270(%rsi,%r8,8), %xmm3
subsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
movsd 0xc0(%rsi,%r8,8), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%rsi,%r8,8)
incq %r8
cmpq $0x6, %r8
jne 0x14e49
incq %rcx
addq $0x30, %rax
cmpq $0x4, %rcx
jne 0x14e42
jmp 0x14f68
movl $0x30, %eax
xorl %ecx, %ecx
leaq 0x14864(%rip), %rdx     # 0x29710
movsd 0x890c(%rip), %xmm0     # 0x1d7c0
movsd 0x8a8c(%rip), %xmm1     # 0x1d948
leaq (%rdi,%rax), %rsi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm2
movsd (%rdi,%r8,8), %xmm3
mulsd (%rdx), %xmm3
mulsd 0x270(%rsi,%r8,8), %xmm3
subsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
movsd 0xc0(%rsi,%r8,8), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%rsi,%r8,8)
incq %r8
cmpq $0x6, %r8
jne 0x14ec3
incq %rcx
addq $0x30, %rax
cmpq $0x4, %rcx
jne 0x14ebc
jmp 0x14f68
movl $0x30, %eax
xorl %ecx, %ecx
leaq 0x147ed(%rip), %rdx     # 0x29710
leaq (%rdi,%rax), %rsi
xorl %r8d, %r8d
movsd 0xc0(%rsi,%r8,8), %xmm0
movsd (%rdi,%r8,8), %xmm1
mulsd (%rdx), %xmm1
mulsd 0x270(%rsi,%r8,8), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, (%rsi,%r8,8)
incq %r8
cmpq $0x6, %r8
jne 0x14f2a
incq %rcx
addq $0x30, %rax
cmpq $0x4, %rcx
jne 0x14f23
movb $0x1, 0x206(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x14695(%rip), %rax     # 0x29610
movq (%rax), %r14
testq %r14, %r14
je 0x14fae
movl %esi, %ebx
movl %edi, %ebp
movq 0x8(%r14), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x14fa5
cmpw $0x2, (%r14)
jg 0x14fa5
movl %ebp, %esi
movl %ebx, %edx
callq 0x14df1
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x14f87
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5bc9(%rip), %xmm0     # 0x1d140
mulsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
addsd 0xc0(%rdi), %xmm0
mulsd 0x5c19(%rip), %xmm0     # 0x1d1a8
mulsd 0x5c19(%rip), %xmm0     # 0x1d1b0
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x175ab
sqrtsd %xmm0, %xmm0
jmp 0x175de
movapd %xmm3, 0x20(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm5, (%rsp)
movapd %xmm6, 0x10(%rsp)
callq 0x31b0
movapd 0x10(%rsp), %xmm6
movsd (%rsp), %xmm5
movsd 0x8(%rsp), %xmm4
movapd 0x20(%rsp), %xmm3
leaq 0xcc3b(%rip), %rax      # 0x24220
movsd (%rax), %xmm1
mulsd %xmm5, %xmm1
mulsd %xmm4, %xmm1
movapd 0x5bc7(%rip), %xmm2     # 0x1d1c0
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_O3/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 %r15
pushq %r14
pushq %rbx
leaq 0x120dd(%rip), %r14     # 0x29710
movabsq $0x409f400000000000, %rax # imm = 0x409F400000000000
movq %rax, (%r14)
leaq 0x11fc9(%rip), %rax     # 0x29610
movq (%rax), %r15
testq %r15, %r15
je 0x17694
movq 0x8(%r15), %rbx
cmpw $0x0, 0x1b0(%rbx)
jne 0x1768e
cmpw $0x2, (%r15)
jg 0x1768e
movq %rbx, %rdi
callq 0x17529
cmpw $0x0, 0x1b0(%rbx)
jne 0x1768e
movsd 0x298(%rbx), %xmm0
movsd (%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1768e
movsd %xmm0, (%r14)
movq 0x10(%r15), %r15
jmp 0x1764a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5af6(%rip), %xmm0     # 0x1d1b0
mulsd %xmm2, %xmm0
divsd %xmm5, %xmm0
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
jb 0x176d2
sqrtsd %xmm0, %xmm0
jmp 0x17705
movsd %xmm5, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x31b0
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 0x6262(%rip), %xmm8     # 0x1d980
movapd %xmm5, %xmm7
mulsd %xmm8, %xmm7
mulsd %xmm6, %xmm7
movsd 0x5a75(%rip), %xmm4     # 0x1d1a8
mulsd %xmm6, %xmm4
addsd 0x5981(%rip), %xmm4     # 0x1d0c0
divsd %xmm4, %xmm7
movsd %xmm7, (%r15)
mulsd 0x6238(%rip), %xmm6     # 0x1d988
addsd 0x6238(%rip), %xmm6     # 0x1d990
mulsd %xmm2, %xmm6
divsd %xmm8, %xmm6
movsd %xmm6, (%r14)
movsd (%r15), %xmm4
movapd %xmm5, %xmm2
divsd %xmm4, %xmm2
movsd 0x5a25(%rip), %xmm6     # 0x1d1a0
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_O3/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 0x59f1(%rip), %xmm0     # 0x1d1b0
mulsd %xmm2, %xmm0
divsd %xmm5, %xmm0
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
jb 0x177d7
sqrtsd %xmm0, %xmm0
jmp 0x1780a
movsd %xmm5, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x31b0
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 0x615d(%rip), %xmm8     # 0x1d980
movapd %xmm5, %xmm7
mulsd %xmm8, %xmm7
mulsd %xmm6, %xmm7
movsd 0x5970(%rip), %xmm4     # 0x1d1a8
mulsd %xmm6, %xmm4
addsd 0x587c(%rip), %xmm4     # 0x1d0c0
divsd %xmm4, %xmm7
movsd %xmm7, (%r15)
mulsd 0x6133(%rip), %xmm6     # 0x1d988
addsd 0x6133(%rip), %xmm6     # 0x1d990
mulsd %xmm2, %xmm6
divsd %xmm8, %xmm6
movsd %xmm6, (%r14)
movsd (%r15), %xmm4
movapd %xmm5, %xmm2
divsd %xmm4, %xmm2
movsd 0x5920(%rip), %xmm6     # 0x1d1a0
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_O3/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 0x180bc
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
jbe 0x180bc
ucomisd %xmm4, %xmm2
jbe 0x180bc
minsd %xmm1, %xmm0
minsd %xmm2, %xmm0
jmp 0x180da
ucomisd %xmm0, %xmm3
jbe 0x180de
xorpd %xmm4, %xmm4
ucomisd %xmm1, %xmm4
jbe 0x180de
ucomisd %xmm2, %xmm4
jbe 0x180de
maxsd %xmm1, %xmm0
maxsd %xmm2, %xmm0
movapd %xmm0, %xmm3
movapd %xmm3, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x106ce(%rip), %rax     # 0x29610
movq (%rax), %rbx
testq %rbx, %rbx
je 0x18f72
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x18f6c
cmpw $0x2, (%rbx)
jg 0x18f6c
cmpb $0x1, 0x210(%rdi)
jne 0x18f6c
callq 0x1810a
movq 0x10(%rbx), %rbx
jmp 0x18f45
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10039(%rip), %rax     # 0x29610
movq (%rax), %rbx
testq %rbx, %rbx
je 0x195fe
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x195f8
cmpw $0x2, (%rbx)
jg 0x195f8
callq 0x18f74
movq 0x10(%rbx), %rbx
jmp 0x195da
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: parent0bAvg(bodygridclass*)
void parent0bAvg(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!=false){
            if(parent->children[0]->bAvg== false 
                && parent->children[1]->bAvg== false
                && parent->children[2]->bAvg== false
                && parent->children[3]->bAvg== false){
                parent->bAvg=false;
            }
            else{
                break;
            }

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

// Assembly:
movq 0x250(%rdi), %rax
testq %rax, %rax
je 0x196a1
movl $0x5, %ecx
cmpb $0x1, 0x206(%rax)
jne 0x19691
movq 0x258(%rax), %rdx
cmpb $0x0, 0x206(%rdx)
jne 0x196a1
movq 0x260(%rax), %rdx
cmpb $0x0, 0x206(%rdx)
jne 0x196a1
movq 0x268(%rax), %rdx
cmpb $0x0, 0x206(%rdx)
jne 0x196a1
movq 0x270(%rax), %rdx
cmpb $0x0, 0x206(%rdx)
jne 0x196a1
movb $0x0, 0x206(%rax)
decl %ecx
je 0x196a1
movq 0x250(%rax), %rax
testq %rax, %rax
jne 0x19641
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x250(%rdi), %rbx
testq %rbx, %rbx
je 0x19717
movl $0x5, %ebp
cmpb $0x0, 0x206(%rbx)
jne 0x19707
movq 0x258(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x19717
movq 0x260(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x19717
movq 0x268(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x19717
movq 0x270(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x19717
movq %rbx, %rdi
callq 0x1971e
decl %ebp
je 0x19717
movq 0x250(%rbx), %rbx
testq %rbx, %rbx
jne 0x196b6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x30, %r8d
movsd 0x4071(%rip), %xmm0     # 0x1d7c0
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
cmpq $0xf0, %r8
jne 0x1974f
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfe82(%rip), %rax      # 0x29610
movq (%rax), %r14
testq %r14, %r14
je 0x1980c
movq 0x8(%r14), %rbx
testb $0x1, 0x1b0(%rbx)
jne 0x19806
cmpw $0x2, (%r14)
jg 0x19806
movzwl 0x1f8(%rbx), %ebp
movq %rbx, %rdi
callq 0x8d37
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x8db8
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x8cb4
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x8c30
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movq (%rsp,%rax,8), %rcx
cmpw 0x1f8(%rcx), %bp
jg 0x197fe
incq %rax
cmpq $0x4, %rax
jne 0x197e6
jmp 0x19806
movq %rbx, %rdi
callq 0x19630
movq 0x10(%r14), %r14
jmp 0x19791
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfdec(%rip), %rax      # 0x29610
movq (%rax), %r14
testq %r14, %r14
je 0x198a2
movq 0x8(%r14), %rbx
testb $0x1, 0x1b0(%rbx)
jne 0x1989c
cmpw $0x2, (%r14)
jg 0x1989c
movzwl 0x1f8(%rbx), %ebp
movq %rbx, %rdi
callq 0x8d37
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x8db8
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x8cb4
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x8c30
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movq (%rsp,%rax,8), %rcx
cmpw 0x1f8(%rcx), %bp
jg 0x19894
incq %rax
cmpq $0x4, %rax
jne 0x1987c
jmp 0x1989c
movq %rbx, %rdi
callq 0x196a2
movq 0x10(%r14), %r14
jmp 0x19827
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ad0a
leaq 0xea85(%rip), %rax      # 0x29610
movq (%rax), %rbp
leaq 0x18(%rsp), %rdi
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
callq 0xcf30
leaq 0xed89(%rip), %r14      # 0x29930
movq $0x0, (%r14)
testq %rbp, %rbp
je 0x1acfb
leaq 0x18(%rsp), %rbx
leaq 0xecad(%rip), %r12      # 0x29870
leaq 0xecb6(%rip), %r13      # 0x29880
movq 0x8(%rbp), %r15
cmpw $0x0, 0x1b0(%r15)
jne 0x1acee
cmpw $0x0, (%rbp)
jne 0x1acee
movsd 0x278(%r15), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd1c0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x280(%r15), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xd1c0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
leaq 0xec19(%rip), %rsi      # 0x29850
callq 0xd15a
callq 0xcf51
movsd %xmm0, (%rsp)
movq %rbx, %rdi
leaq 0xec10(%rip), %rsi      # 0x29860
callq 0xd15a
callq 0xcf51
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd15a
callq 0xcf51
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd15a
callq 0xcf51
movsd 0x3072(%rip), %xmm1     # 0x1dd00
movsd (%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x1acee
movsd 0x10(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x1acee
movsd 0x8(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x1acee
ucomisd %xmm1, %xmm0
jbe 0x1acee
movsd 0x1c8(%r15), %xmm0
subsd 0x1e0(%r15), %xmm0
mulsd 0x288(%r15), %xmm0
mulsd 0x290(%r15), %xmm0
movsd %xmm0, 0x208(%r15)
addsd (%r14), %xmm0
movsd %xmm0, (%r14)
movq 0x10(%rbp), %rbp
testq %rbp, %rbp
jne 0x1abca
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe961(%rip), %rax      # 0x29680
movq (%rax), %r15
movq 0x8(%rax), %rax
movq %rax, %rcx
subq %r15, %rcx
je 0x1ae72
sarq $0x6, %rcx
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %r12
xorl %ecx, %ecx
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rdi
shlq $0x6, %rdi
movq (%r15,%rdi), %rsi
movq 0x8(%r15,%rdi), %rdi
movq $-0x4, %r8
movq %rcx, 0x1d8(%rsi,%r8,8)
movq %rcx, 0x1f8(%rsi,%r8,8)
movq %rcx, 0x1d8(%rdi,%r8,8)
movq %rcx, 0x1f8(%rdi,%r8,8)
incq %r8
jne 0x1ad60
incq %rdx
cmpq %r12, %rdx
jne 0x1ad48
cmpq %r15, %rax
je 0x1ae72
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbx
movq %rsp, %r14
leaq (,%r13,2), %rbp
addq %r13, %rbp
shlq $0x6, %rbp
leaq (%r15,%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1c2d2
movq (%r15,%rbp), %rax
movq 0x8(%r15,%rbp), %rcx
movsd 0x288(%rax), %xmm0
mulsd 0x290(%rax), %xmm0
movsd 0x288(%rcx), %xmm1
mulsd 0x290(%rcx), %xmm1
xorl %edx, %edx
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
cmpq $0x4, %rdx
jne 0x1adea
incq %r13
cmpq %r12, %r13
jne 0x1ada1
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1aea5
sqrtsd %xmm0, %xmm0
jmp 0x1aeaa
callq 0x31b0
movsd 0x28e6(%rip), %xmm1     # 0x1d798
callq 0x3360
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 0x22c4(%rip), %xmm1     # 0x1d1c0
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_O3/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, %rbx
movq %rdi, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0xcf30
movsd 0x240(%rbx), %xmm0
movsd 0x1c43f(%rip), %xmm1    # 0x37628
mulsd 0x2967(%rip), %xmm1     # 0x1db58
ucomisd %xmm1, %xmm0
ja 0x1b219
movsd 0x248(%rbx), %xmm0
movsd 0x1c429(%rip), %xmm1    # 0x37630
mulsd 0x2959(%rip), %xmm1     # 0x1db68
ucomisd %xmm1, %xmm0
jbe 0x1b32d
movsd 0x278(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xd1c0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x280(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movl $0x1, %esi
callq 0xd1c0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0xe5e4(%rip), %rsi      # 0x29850
movq %r14, %rdi
callq 0xd15a
callq 0xcf51
movsd %xmm0, 0x8(%rsp)
leaq 0xe5da(%rip), %rsi      # 0x29860
movq %r14, %rdi
callq 0xd15a
callq 0xcf51
movsd %xmm0, 0x18(%rsp)
leaq 0xe5d0(%rip), %rsi      # 0x29870
movq %r14, %rdi
callq 0xd15a
callq 0xcf51
movsd %xmm0, 0x10(%rsp)
leaq 0xe5c6(%rip), %rsi      # 0x29880
movq %r14, %rdi
callq 0xd15a
callq 0xcf51
movsd 0x8(%rsp), %xmm1
ucomisd 0x2a2b(%rip), %xmm1     # 0x1dd00
jbe 0x1b32d
movsd 0x18(%rsp), %xmm1
ucomisd 0x2a1b(%rip), %xmm1     # 0x1dd00
jbe 0x1b32d
movsd 0x10(%rsp), %xmm1
ucomisd 0x2a0b(%rip), %xmm1     # 0x1dd00
jbe 0x1b32d
ucomisd 0x2a01(%rip), %xmm0     # 0x1dd00
jbe 0x1b32d
leaq 0x9048(%rip), %rax      # 0x24350
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x1b31c
movq %rbx, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x1b32d
leaq 0x902d(%rip), %rdi      # 0x24350
leaq 0x20(%rsp), %rdx
callq 0xc142
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8d37
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x8cb4
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x8c30
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x8db8
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %rdi
callq 0x8cb4
movq %rax, 0x20(%rbx)
movq 0x10(%rbx), %rdi
callq 0x8d37
movq %rax, 0x28(%rbx)
movq 0x18(%rbx), %rdi
callq 0x8cb4
movq %rax, 0x30(%rbx)
movq 0x18(%rbx), %rdi
callq 0x8d37
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargeleveldifference(bodygridclass*)
int chargeleveldifference(OctCell *parent)
{
	int i;
	OctCell *pp[8]={NULL}; 
	int plevel,nlevel;//目标单元的层次-1，邻居单元的层次
	plevel=parent->level+1;
	find_sol_refp(pp,parent);
	for(i=0;i<8;i++)
	{
        if(pp[i]!=NULL)//here don't need if TODO
		{
			nlevel=pp[i]->level;
			if(abs(nlevel-plevel)>1)
			{break;}
		}
	}
	if(i==8) return(0);
	else return(1);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movswl 0x1f8(%rsi), %ebx
notl %ebx
callq 0x1b384
xorl %ecx, %ecx
movq (%rsp,%rcx,8), %rax
testq %rax, %rax
je 0x1b485
movswl 0x1f8(%rax), %eax
addl %ebx, %eax
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
cmpl $0x1, %edx
ja 0x1b492
incq %rcx
cmpq $0x8, %rcx
jne 0x1b467
xorl %eax, %eax
jmp 0x1b49b
xorl %eax, %eax
cmpq $0x8, %rcx
setne %al
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: creat_sol_children(bodygridclass*)
void creat_sol_children(OctCell *parent)
{
	int j,m,preflag,dlevel;
	OctCell *children[4]={NULL};
	//double plevel,hx,hy;
	double hx1,hy1;
	if(parent!=NULL)//here do not need if TODO
	{
		preflag=parent->reflag;	
		dlevel=chargeleveldifference(parent);
		if(preflag==1||dlevel==1) return;//判断该网格单元是否加密
		else
		{
		//	plevel=parent->level+1;		
		//	hx=Hx/pow(2.0,plevel);hy=Hy/pow(2.0,plevel);//子网格的步长	
            hx1=0.5*parent->dx;
            hy1=0.5*parent->dy;
			for(m=0;m<4;++m)
			{
				//children[m]=(struct cell*)malloc(LENC);
                children[m]=new OctCell(hx1,hy1);

				parent->children[m]=children[m];
				childrenvalue(children[m],parent,hx1,hy1,m);
				charggrid0(children[m]);// here I omit is right TODO
			}
			parent->reflag=1;
//            parent->p_node=NULL;
		}
	}

	for(m=0;m<4;m++)
	{
		children[m]->level0=parent->level0;//
        son_cell_value(parent,m,children[m]);
	}				
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, 0x10(%rsp)
testq %rdi, %rdi
je 0x1b572
movzwl 0x1fc(%rbx), %ebp
movq %rbx, %rdi
callq 0x1b43a
cmpw $0x1, %bp
je 0x1b59c
testl %eax, %eax
jne 0x1b59c
movsd 0x1c58(%rip), %xmm0     # 0x1d148
movsd 0x288(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
mulsd 0x290(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
movl $0x360, %edi            # imm = 0x360
callq 0x3210
movq %rax, %r15
movq %rax, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x46e8
movq %r15, 0x10(%rsp,%r14,8)
movq %r15, 0x258(%rbx,%r14,8)
movq %r15, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movl %r14d, %edx
callq 0xc666
movq %r15, %rdi
callq 0xc42c
incq %r14
cmpq $0x4, %r14
jne 0x1b512
movw $0x1, 0x1fc(%rbx)
xorl %r14d, %r14d
movzwl 0x1fa(%rbx), %eax
movq 0x10(%rsp,%r14,8), %rdx
movw %ax, 0x1fa(%rdx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1b5bf
incq %r14
cmpq $0x4, %r14
jne 0x1b575
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x360, %esi            # imm = 0x360
movq %r15, %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargegridforcoarse()
void chargegridforcoarse()
{
	Node *current;
	OctCell *lsbl;
	current = HeadListAllGrid;
    solcoacell.clear();
	//Ncoar=0; //需要粗化网格单元数目初始化
	while(current != NULL)
	{
		lsbl = current->cell;
#if IS_TUBE==0
		if(lsbl->flag== 0
#elif IS_TUBE==1
        if((lsbl->flag== 0 || lsbl->exflag!=0)
#endif
            && current->flg<=2)
			chargsolgridforcoarse(lsbl);
		current = current->next;
	}
}

// Assembly:
pushq %rbx
leaq 0xda39(%rip), %rax      # 0x29610
movq (%rax), %rbx
leaq 0x8787(%rip), %rax      # 0x24368
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x1bc17
movq %rcx, 0x8(%rax)
jmp 0x1bc17
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
je 0x1bc08
cmpw $0x0, 0x1b2(%rdi)
je 0x1bc13
cmpw $0x2, (%rbx)
jg 0x1bc13
callq 0x1bb42
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x1bbf0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargecoarselevel(bodygridclass*)
int chargecoarselevel(OctCell *pc)
{
	int i;
	OctCell *pp[8]={NULL};
	find_sol_refp(pp,pc);
	for(i=0;i<4;i++)
	{
		if(pp[i]!=NULL&&pp[i]->reflag==1) 
		//if(pp[i]->reflag==1) 
		{
			break;
		}
	}
	if(i==4) return(0);
	else return(1);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x1b384
xorl %ecx, %ecx
movq (%rsp,%rcx,8), %rax
testq %rax, %rax
je 0x1bf0d
cmpw $0x1, 0x1fc(%rax)
je 0x1bf1a
incq %rcx
cmpq $0x4, %rcx
jne 0x1befa
xorl %eax, %eax
jmp 0x1bf23
xorl %eax, %eax
cmpq $0x4, %rcx
setne %al
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargeholegrid(bodygridclass*)
int chargeholegrid(OctCell *pc)
{
	OctCell *pp[8];
	find_sol_refp(pp,pc);
     if((pp[0]!=NULL&&pp[0]->reflag==1&&pp[1]!=NULL&&pp[1]->reflag==1)
     ||(pp[2]!=NULL&&pp[2]->reflag==1&&pp[3]!=NULL&&pp[3]->reflag==1))
    //if((pp[0]->reflag==1&&pp[1]->reflag==1) 
      //  ||(pp[2]->reflag==1&&pp[3]->reflag==1))
        return(1);
	else
		return(0);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1b384
movq (%rbx), %rax
testq %rax, %rax
je 0x1c0af
cmpw $0x1, 0x1fc(%rax)
sete %al
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x1c0af
movl $0x1, %eax
cmpw $0x1, 0x1fc(%rcx)
je 0x1c0e7
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1c0e5
cmpw $0x1, 0x1fc(%rax)
sete %al
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x1c0e5
movl $0x1, %eax
cmpw $0x1, 0x1fc(%rcx)
je 0x1c0e7
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq