LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x64c5(%rip), %xmm0     # 0x1e1b0
mulsd %xmm2, %xmm0
divsd %xmm5, %xmm0
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
jb 0x17d03
sqrtsd %xmm0, %xmm0
jmp 0x17d36
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 0x6c51(%rip), %xmm8     # 0x1e9a0
movapd %xmm5, %xmm7
mulsd %xmm8, %xmm7
mulsd %xmm6, %xmm7
movsd 0x6444(%rip), %xmm4     # 0x1e1a8
mulsd %xmm6, %xmm4
addsd 0x6350(%rip), %xmm4     # 0x1e0c0
divsd %xmm4, %xmm7
movsd %xmm7, (%r15)
mulsd 0x6c27(%rip), %xmm6     # 0x1e9a8
addsd 0x6c27(%rip), %xmm6     # 0x1e9b0
mulsd %xmm2, %xmm6
divsd %xmm8, %xmm6
movsd %xmm6, (%r14)
movsd (%r15), %xmm4
movapd %xmm5, %xmm2
divsd %xmm4, %xmm2
movsd 0x63f4(%rip), %xmm6     # 0x1e1a0
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_O1/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 0x185b8
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
jbe 0x185b8
ucomisd %xmm4, %xmm2
jbe 0x185b8
minsd %xmm1, %xmm0
minsd %xmm2, %xmm0
jmp 0x185d6
ucomisd %xmm0, %xmm3
jbe 0x185da
xorpd %xmm4, %xmm4
ucomisd %xmm1, %xmm4
jbe 0x185da
ucomisd %xmm2, %xmm4
jbe 0x185da
maxsd %xmm1, %xmm0
maxsd %xmm2, %xmm0
movapd %xmm0, %xmm3
movapd %xmm3, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x111d2(%rip), %rax     # 0x2a610
movq (%rax), %rbx
testq %rbx, %rbx
je 0x1946e
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x19468
cmpw $0x2, (%rbx)
jg 0x19468
cmpb $0x1, 0x210(%rdi)
jne 0x19468
callq 0x18606
movq 0x10(%rbx), %rbx
jmp 0x19441
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10b53(%rip), %rax     # 0x2a610
movq (%rax), %rbx
testq %rbx, %rbx
je 0x19ae4
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x19ade
cmpw $0x2, (%rbx)
jg 0x19ade
callq 0x19470
movq 0x10(%rbx), %rbx
jmp 0x19ac0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19b89
movl $0x5, %ecx
cmpb $0x1, 0x206(%rax)
jne 0x19b79
movq 0x258(%rax), %rdx
cmpb $0x0, 0x206(%rdx)
jne 0x19b89
movq 0x260(%rax), %rdx
cmpb $0x0, 0x206(%rdx)
jne 0x19b89
movq 0x268(%rax), %rdx
cmpb $0x0, 0x206(%rdx)
jne 0x19b89
movq 0x270(%rax), %rdx
cmpb $0x0, 0x206(%rdx)
jne 0x19b89
movb $0x0, 0x206(%rax)
decl %ecx
je 0x19b89
movq 0x250(%rax), %rax
testq %rax, %rax
jne 0x19b29
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19bff
movl $0x5, %ebp
cmpb $0x0, 0x206(%rbx)
jne 0x19bef
movq 0x258(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x19bff
movq 0x260(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x19bff
movq 0x268(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x19bff
movq 0x270(%rbx), %rax
cmpb $0x1, 0x206(%rax)
jne 0x19bff
movq %rbx, %rdi
callq 0x19c06
decl %ebp
je 0x19bff
movq 0x250(%rbx), %rbx
testq %rbx, %rbx
jne 0x19b9e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ba9(%rip), %xmm0     # 0x1e7e0
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 0x19c37
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0x1098e(%rip), %rax     # 0x2a610
movq (%rax), %r14
testq %r14, %r14
je 0x19d00
movq 0x8(%r14), %rbx
testb $0x1, 0x1b0(%rbx)
jne 0x19cfa
cmpw $0x2, (%r14)
jg 0x19cfa
movzwl 0x1f8(%rbx), %ebp
movq %rbx, %rdi
callq 0x8e7f
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x8f00
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x8dfc
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x8d78
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movq (%rsp,%rax,8), %rcx
cmpw 0x1f8(%rcx), %bp
jg 0x19cf2
incq %rax
cmpq $0x4, %rax
jne 0x19cda
jmp 0x19cfa
movq %rbx, %rdi
callq 0x19b18
movq 0x10(%r14), %r14
jmp 0x19c85
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0x108ec(%rip), %rax     # 0x2a610
movq (%rax), %r14
testq %r14, %r14
je 0x19da2
movq 0x8(%r14), %rbx
testb $0x1, 0x1b0(%rbx)
jne 0x19d9c
cmpw $0x2, (%r14)
jg 0x19d9c
movzwl 0x1f8(%rbx), %ebp
movq %rbx, %rdi
callq 0x8e7f
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x8f00
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x8dfc
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x8d78
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movq (%rsp,%rax,8), %rcx
cmpw 0x1f8(%rcx), %bp
jg 0x19d94
incq %rax
cmpq $0x4, %rax
jne 0x19d7c
jmp 0x19d9c
movq %rbx, %rdi
callq 0x19b8a
movq 0x10(%r14), %r14
jmp 0x19d27
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b20a
leaq 0xf585(%rip), %rax      # 0x2a610
movq (%rax), %rbp
leaq 0x18(%rsp), %rdi
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
callq 0xd250
leaq 0xf889(%rip), %r14      # 0x2a930
movq $0x0, (%r14)
testq %rbp, %rbp
je 0x1b1fb
leaq 0x18(%rsp), %rbx
leaq 0xf7ad(%rip), %r12      # 0x2a870
leaq 0xf7b6(%rip), %r13      # 0x2a880
movq 0x8(%rbp), %r15
cmpw $0x0, 0x1b0(%r15)
jne 0x1b1ee
cmpw $0x0, (%rbp)
jne 0x1b1ee
movsd 0x278(%r15), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd506
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x280(%r15), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xd506
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
leaq 0xf719(%rip), %rsi      # 0x2a850
callq 0xd4a0
callq 0xd271
movsd %xmm0, (%rsp)
movq %rbx, %rdi
leaq 0xf710(%rip), %rsi      # 0x2a860
callq 0xd4a0
callq 0xd271
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd4a0
callq 0xd271
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xd4a0
callq 0xd271
movsd 0x3b72(%rip), %xmm1     # 0x1ed00
movsd (%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x1b1ee
movsd 0x10(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x1b1ee
movsd 0x8(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x1b1ee
ucomisd %xmm1, %xmm0
jbe 0x1b1ee
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 0x1b0ca
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf461(%rip), %rax      # 0x2a680
movq (%rax), %r15
movq 0x8(%rax), %rax
movq %rax, %rcx
subq %r15, %rcx
sarq $0x6, %rcx
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %r12
cmpq %r15, %rax
je 0x1b28c
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 0x1b25f
incq %rdx
cmpq %r12, %rdx
jne 0x1b247
cmpq %r15, %rax
je 0x1b371
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 0x1c7de
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 0x1b2e9
incq %r13
cmpq %r12, %r13
jne 0x1b2a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x288(%rdi), %xmm0
mulsd 0x290(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1b3a8
sqrtsd %xmm0, %xmm0
jmp 0x1b3ad
callq 0x31b0
movsd 0x3403(%rip), %xmm1     # 0x1e7b8
callq 0x3360
movapd %xmm0, %xmm3
movupd 0x1c0(%rbx), %xmm0
shufpd $0x1, %xmm0, %xmm0      # xmm0 = xmm0[1,0]
movupd 0x1e0(%rbx), %xmm1
movapd %xmm0, %xmm2
subpd %xmm1, %xmm2
addpd %xmm1, %xmm0
movsd %xmm2, %xmm0            # xmm0 = xmm2[0],xmm0[1]
mulsd 0x288(%rbx), %xmm2
mulsd 0x290(%rbx), %xmm2
andpd 0x2dc5(%rip), %xmm0     # 0x1e1c0
movsd %xmm2, 0x208(%rbx)
movapd %xmm3, %xmm1
unpcklpd %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0]
mulpd %xmm0, %xmm1
movupd %xmm1, 0x238(%rbx)
movsd 0x1b8(%rbx), %xmm0
movsd 0x1d8(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd 0x2d7d(%rip), %xmm0     # 0x1e1b8
jb 0x1b443
sqrtsd %xmm0, %xmm0
jmp 0x1b452
movapd %xmm3, (%rsp)
callq 0x31b0
movapd (%rsp), %xmm3
mulsd %xmm0, %xmm3
movsd %xmm3, 0x248(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0xd250
movq 0x8(%rsp), %rax
movsd 0x240(%rax), %xmm0
movsd 0x1cf23(%rip), %xmm1    # 0x38628
mulsd 0x344b(%rip), %xmm1     # 0x1eb58
ucomisd %xmm1, %xmm0
ja 0x1b735
movsd 0x248(%rax), %xmm0
movsd 0x1cf0d(%rip), %xmm1    # 0x38630
mulsd 0x343d(%rip), %xmm1     # 0x1eb68
ucomisd %xmm1, %xmm0
jbe 0x1b84d
movsd 0x278(%rax), %xmm0
movsd %xmm0, (%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd506
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rax
movsd 0x280(%rax), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xd506
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0xf0c7(%rip), %rsi      # 0x2a850
movq %rbx, %rdi
callq 0xd4a0
callq 0xd271
movsd %xmm0, (%rsp)
leaq 0xf0be(%rip), %rsi      # 0x2a860
movq %rbx, %rdi
callq 0xd4a0
callq 0xd271
movsd %xmm0, 0x18(%rsp)
leaq 0xf0b4(%rip), %rsi      # 0x2a870
movq %rbx, %rdi
callq 0xd4a0
callq 0xd271
movsd %xmm0, 0x10(%rsp)
leaq 0xf0aa(%rip), %rsi      # 0x2a880
movq %rbx, %rdi
callq 0xd4a0
callq 0xd271
movsd (%rsp), %xmm1
ucomisd 0x3510(%rip), %xmm1     # 0x1ed00
jbe 0x1b84d
movsd 0x18(%rsp), %xmm1
ucomisd 0x3500(%rip), %xmm1     # 0x1ed00
jbe 0x1b84d
movsd 0x10(%rsp), %xmm1
ucomisd 0x34f0(%rip), %xmm1     # 0x1ed00
jbe 0x1b84d
ucomisd 0x34e6(%rip), %xmm0     # 0x1ed00
jbe 0x1b84d
leaq 0x9b2d(%rip), %rax      # 0x25350
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x1b83c
movq 0x8(%rsp), %rcx
movq %rcx, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x1b84d
leaq 0x9b0d(%rip), %rdi      # 0x25350
leaq 0x8(%rsp), %rdx
callq 0xc2bc
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8e7f
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x8dfc
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x8d78
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x8f00
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %rdi
callq 0x8dfc
movq %rax, 0x20(%rbx)
movq 0x10(%rbx), %rdi
callq 0x8e7f
movq %rax, 0x28(%rbx)
movq 0x18(%rbx), %rdi
callq 0x8dfc
movq %rax, 0x30(%rbx)
movq 0x18(%rbx), %rdi
callq 0x8e7f
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b8a2
xorl %ecx, %ecx
movq (%rsp,%rcx,8), %rax
testq %rax, %rax
je 0x1b9a3
movswl 0x1f8(%rax), %eax
addl %ebx, %eax
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
cmpl $0x1, %edx
ja 0x1b9b1
incq %rcx
cmpq $0x8, %rcx
jne 0x1b985
movl $0x8, %ecx
xorl %eax, %eax
cmpl $0x8, %ecx
setne %al
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ba90
movzwl 0x1fc(%rbx), %ebp
movq %rbx, %rdi
callq 0x1b958
cmpw $0x1, %bp
je 0x1baba
testl %eax, %eax
jne 0x1baba
movsd 0x273a(%rip), %xmm0     # 0x1e148
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 0xc7f7
movq %r15, %rdi
callq 0xc5b9
incq %r14
cmpq $0x4, %r14
jne 0x1ba30
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 0x1badd
incq %r14
cmpq $0x4, %r14
jne 0x1ba93
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_O1/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 0xe52d(%rip), %rax      # 0x2a610
movq (%rax), %rbx
leaq 0x927b(%rip), %rax      # 0x25368
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x1c123
movq %rcx, 0x8(%rax)
jmp 0x1c123
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
je 0x1c114
cmpw $0x0, 0x1b2(%rdi)
je 0x1c11f
cmpw $0x2, (%rbx)
jg 0x1c11f
callq 0x1c05b
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x1c0fc
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b8a2
xorl %ecx, %ecx
movq (%rsp,%rcx,8), %rax
testq %rax, %rax
je 0x1c419
cmpw $0x1, 0x1fc(%rax)
je 0x1c427
incq %rcx
cmpq $0x4, %rcx
jne 0x1c406
movl $0x4, %ecx
xorl %eax, %eax
cmpl $0x4, %ecx
setne %al
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b8a2
movq (%rbx), %rax
testq %rax, %rax
je 0x1c5bb
cmpw $0x1, 0x1fc(%rax)
sete %al
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x1c5bb
movl $0x1, %eax
cmpw $0x1, 0x1fc(%rcx)
je 0x1c5f3
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1c5f1
cmpw $0x1, 0x1fc(%rax)
sete %al
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x1c5f1
movl $0x1, %eax
cmpw $0x1, 0x1fc(%rcx)
je 0x1c5f3
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargehillgrid(bodygridclass*)
int chargehillgrid(OctCell *pc)
{
    OctCell *pp[8],*parent;
    parent=pc->parent;
    if(parent!=NULL)
    {
        if(parent->reflag==1)
        {
            find_sol_refp(pp,parent);
            if((pp[0]!=NULL&&pp[0]->reflag==0
                    &&pp[1]!=NULL&&pp[1]->reflag==0)
                &&(pp[2]!=NULL&&pp[2]->reflag==0
                    &&pp[3]!=NULL&&pp[3]->reflag==0))
     // if((pp[0]->reflag==0&&pp[1]->reflag==0)
      //          &&(pp[2]->reflag==0&&pp[3]->reflag==0))
                return(1);	
            else		
                return(0);
        }
    }
    return(0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x250(%rdi), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x1c695
cmpw $0x1, 0x1fc(%rsi)
jne 0x1c695
movq %rsp, %r14
movq %r14, %rdi
callq 0x1b8a2
movq (%r14), %rax
testq %rax, %rax
je 0x1c695
cmpw $0x0, 0x1fc(%rax)
sete %cl
movq 0x8(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1c695
cmpw $0x0, 0x1fc(%rax)
sete %cl
movq 0x10(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1c695
cmpw $0x0, 0x1fc(%rax)
sete %cl
movq 0x18(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1c695
cmpw $0x0, 0x1fc(%rax)
jne 0x1c695
movl $0x1, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: solveEdge4Gradient(Face&, double*, double*)
void solveEdge4Gradient(Face &fc, double fjbx[],double fjby[])
{
    OctCell *lsbl,*lsbl0;

    lsbl0=fc.parent;
    lsbl=fc.neighbor;
    double ush0[4],ush[4];
    double ujb0[4],ujb[4];
    for(int i=0;i<4;++i)
    {
        ush0[i]=lsbl0->dof[i][0];
        ush[i]=lsbl->dof[i][0];
    }
    shbl2jbbl(ush0,ujb0);
    shbl2jbbl(ush,ujb);

    for(int i=0; i<4;++i){
        fjbx[i]=0.5*(ujb0[i]+ujb[i])*fc.nml[0]*fc.area;
        fjby[i]=0.5*(ujb0[i]+ujb[i])*fc.nml[1]*fc.area;
    }
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movl $0xc, %r8d
xorl %r9d, %r9d
movsd -0x30(%rax,%r8,8), %xmm0
movhps (%rax,%r8,8), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, -0x20(%rsp,%r9,8)
movsd -0x30(%rcx,%r8,8), %xmm0
movhps (%rcx,%r8,8), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, -0x40(%rsp,%r9,8)
addq $0x2, %r9
addq $0xc, %r8
cmpq $0x4, %r9
jne 0x1c7ef
movsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x60(%rsp)
movupd -0x18(%rsp), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm2, %xmm1
movupd %xmm1, -0x58(%rsp)
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
movsd 0x18df(%rip), %xmm2     # 0x1e140
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
addsd -0x8(%rsp), %xmm0
movsd 0x1931(%rip), %xmm1     # 0x1e1a8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rsp)
movsd -0x40(%rsp), %xmm0
movsd %xmm0, -0x80(%rsp)
movupd -0x38(%rsp), %xmm3
movapd %xmm0, %xmm4
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
divpd %xmm4, %xmm3
movupd %xmm3, -0x78(%rsp)
movapd %xmm3, %xmm4
mulpd %xmm3, %xmm4
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
mulsd %xmm3, %xmm3
addsd %xmm4, %xmm3
mulsd %xmm2, %xmm0
mulsd %xmm3, %xmm0
addsd -0x28(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rsp)
xorl %eax, %eax
movsd 0x186d(%rip), %xmm0     # 0x1e148
movsd -0x60(%rsp,%rax,8), %xmm1
addsd -0x80(%rsp,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd 0x10(%rdi), %xmm2
mulsd %xmm1, %xmm2
mulsd 0xb0(%rdi), %xmm2
movsd %xmm2, (%rsi,%rax,8)
mulsd 0x18(%rdi), %xmm1
mulsd 0xb0(%rdi), %xmm1
movsd %xmm1, (%rdx,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x1c8db
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: SolutionAMR(int)
void SolutionAMR(int i)
{	
#ifndef KXRCF_AMR
    solveGradient();
	getAllAdpParametersList();
#else
    kxrcf_relate();
    face_kxrcf_all();
    set_kxrcf();
#endif
	charg_sol_gridAll();
	chargegridforcoarse();
	creatcoarsegrid();
	creat_amr_grid();
//    release_ColCoa();
    solrefcell.clear();//solution AMR cell
    solcoacell.clear();//solution coase cell

	cout<<"Adaptively Refine and Coarsen Mesh Complete>>>>>\n";
	smoothcell();		
	cout<<"Smooth Adaptively Mesh Complete>>>>>\n";
    releaseList();
    formListForAllGrid();

    setFlagForAll();

    releaseFaceCellList();
    formListFaceCellAll();   
#if IS_TUBE==1
    set_exFlag4All(NPT_EXT_WALL, ext_wall);
    formExtWallInOutBndry();
#endif
    face_vec();
    point_vec();     
 // outputcell_new(i);//output mesh
  //outputcell_sol(i);//output solution
#if HAVE_MV!=0
    for(int wy=0; wy<N_BODY;++wy){
        for(int i_t=0;i_t<MVptNum[wy];++i_t){  
            find_multivalue_cell(MBsharp_point[wy][i_t]);
        }
    }
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1b20a
callq 0x1b464
callq 0x1b853
callq 0x1c0db
callq 0x1c434
callq 0x1bea8
leaq 0x8a09(%rip), %rax      # 0x25350
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x1c954
movq %rcx, 0x8(%rax)
leaq 0x8a0d(%rip), %rax      # 0x25368
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x1c968
movq %rcx, 0x8(%rax)
movq 0x8659(%rip), %rbx      # 0x24fc8
leaq 0x241f(%rip), %rsi      # 0x1ed95
movl $0x31, %edx
movq %rbx, %rdi
callq 0x3250
callq 0x1c69f
leaq 0x2438(%rip), %rsi      # 0x1edc7
movl $0x25, %edx
movq %rbx, %rdi
callq 0x3250
callq 0xc11d
callq 0xbc5c
callq 0x4f50
callq 0xc172
callq 0xc0ae
leaq 0xc8c4(%rip), %rsi      # 0x29280
movl $0x138, %edi            # imm = 0x138
callq 0x50cd
callq 0xbe13
callq 0x8fad
callq 0x57fc
xorl %ebx, %ebx
leaq 0xdd72(%rip), %r14      # 0x2a750
leaq (%rbx,%r14), %rdi
callq 0x1ca4f
addq $0x10, %rbx
cmpq $0x30, %rbx
jne 0x1c9de
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/multi_value_cell.cpp
// Function: insert_cell2(bodygridclass*, std::set<bodygridclass*, std::less<bodygridclass*>, std::allocator<bodygridclass*>>&)
void insert_cell2(OctCell *pp, set<OctCell*> &grid)
{
    if(pp->reflag==0){
        if(pp->flag%2==0)grid.insert(pp);
    }
    else {
        for(int m=0; m<4;++m) 
            insert_cell2(pp->children[m], grid);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
cmpw $0x0, 0x1fc(%rdi)
je 0x1ca33
xorl %r14d, %r14d
movq (%rsp), %rax
movq 0x258(%rax,%r14,8), %rdi
movq %rbx, %rsi
callq 0x1c9fc
incq %r14
cmpq $0x4, %r14
jne 0x1ca14
jmp 0x1ca47
testb $0x1, 0x1b0(%rdi)
jne 0x1ca47
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6da2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/multi_value_cell.cpp
// Function: find_multivalue_cell(pointxy const&)
void find_multivalue_cell(const PXYZ &sharppoint)
{
    double hcx, hcy;
    OctCell *cellflow=NULL;
    OctCell *in_this_cell=NULL;
    OctCell *ppvec[9]={NULL};
   // PXYZ point;
   // point=wallpoint[n_sharp_point];
    mvalue_set.clear();
    for(int i=1;i<=Nx*Ny;++i){
        cellflow=bodygrid+i;
        hcx=cellflow->dx;
        hcy=cellflow->dy;

        if(sharppoint.x < cellflow->xc1 + 0.5 * hcx + ERRS
            && sharppoint.x > cellflow->xc1 - 0.5 * hcx - ERRS
            && sharppoint.y < cellflow->yc1 + 0.5 * hcy + ERRS
            && sharppoint.y > cellflow->yc1 - 0.5 * hcy - ERRS){
            in_this_cell=cellflow;
            break;
        }
    }

    find_sol_refp(ppvec,in_this_cell);
    ppvec[8]=in_this_cell;
    for(int i=0; i<9;++i)
        insert_cell2(ppvec[i],mvalue_set);

    for(set<OctCell*>::iterator it_set=mvalue_set.begin();
        it_set!=mvalue_set.end();++it_set) {
        (*it_set)->mvflg=true;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x40(%rsp)
leaq 0xdca1(%rip), %rdi      # 0x2a720
callq 0x6d74
leaq 0x8855(%rip), %rax      # 0x252e0
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movl $0x360, %ebx            # imm = 0x360
addq (%rax), %rbx
movl $0x1f3b, %eax           # imm = 0x1F3B
movsd 0x169f(%rip), %xmm2     # 0x1e148
movsd 0x169f(%rip), %xmm3     # 0x1e150
movsd 0x1687(%rip), %xmm4     # 0x1e140
movsd 0x1dcf(%rip), %xmm5     # 0x1e890
movsd 0x278(%rbx), %xmm7
movsd 0x288(%rbx), %xmm6
movapd %xmm6, %xmm8
mulsd %xmm2, %xmm8
addsd %xmm7, %xmm8
addsd %xmm3, %xmm8
ucomisd %xmm0, %xmm8
jbe 0x1cb3b
mulsd %xmm4, %xmm6
addsd %xmm7, %xmm6
addsd %xmm5, %xmm6
ucomisd %xmm6, %xmm0
jbe 0x1cb3b
movsd 0x290(%rbx), %xmm6
movsd 0x280(%rbx), %xmm7
movapd %xmm6, %xmm8
mulsd %xmm2, %xmm8
addsd %xmm7, %xmm8
addsd %xmm3, %xmm8
ucomisd %xmm1, %xmm8
jbe 0x1cb3b
mulsd %xmm4, %xmm6
addsd %xmm7, %xmm6
addsd %xmm5, %xmm6
ucomisd %xmm6, %xmm1
ja 0x1cb4d
addq $0x360, %rbx            # imm = 0x360
decq %rax
jne 0x1cac1
xorl %ebx, %ebx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b8a2
movq %rbx, 0x40(%r14)
xorl %r14d, %r14d
leaq 0xdbb7(%rip), %rbx      # 0x2a720
movq (%rsp,%r14,8), %rdi
movq %rbx, %rsi
callq 0x1c9fc
incq %r14
cmpq $0x9, %r14
jne 0x1cb69
movq 0x18(%rbx), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x1cba0
movq 0x20(%rax), %rcx
movb $0x1, 0x1b4(%rcx)
movq %rax, %rdi
callq 0x3260
jmp 0x1cb86
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/cal_te_res.cpp
// Function: cal_te_res()
void cal_te_res()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    double db_tmp=0.0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag == 0 && current->flg<=2 ) {
            db_tmp+=pcell0->residual[0][0]*pcell0->residual[0][0]
                *pcell0->dx*pcell0->dy;
        }        
        current = current->next;
    }
    db_tmp=sqrt(db_tmp);
//    cout<<"rhoE ie. residual[3][0]->"<<scientific<<db_tmp<<"\n";
    cout<<"rho       "<<scientific<<db_tmp<<"\n";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xda5c(%rip), %rax      # 0x2a610
movq (%rax), %rax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x1cbfe
movq 0x8(%rax), %rcx
cmpw $0x0, 0x1b0(%rcx)
jne 0x1cbf8
cmpw $0x2, (%rax)
jg 0x1cbf8
movsd 0x2a0(%rcx), %xmm2
mulsd %xmm2, %xmm2
mulsd 0x288(%rcx), %xmm2
mulsd 0x290(%rcx), %xmm2
addsd %xmm2, %xmm0
movq 0x10(%rax), %rax
jmp 0x1cbbf
ucomisd %xmm1, %xmm0
jb 0x1cc0a
sqrtsd %xmm0, %xmm0
jmp 0x1cc0f
callq 0x31b0
movsd %xmm0, 0x8(%rsp)
movq 0x83ac(%rip), %rbx      # 0x24fc8
leaq 0x21ca(%rip), %rsi      # 0x1eded
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl 0x18(%rbx,%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3300
leaq 0x165b(%rip), %rsi      # 0x1e2ba
movl $0x1, %edx
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x3250
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/riemannWallBound.cpp
// Function: solveERS(double, double, double, double, double*, double*)
void  solveERS(double dl,double ul, double pl, 
			  double uw, double *di,double *pi)
{
    double cM, A_M,B_M,aM;
    double du0;
    cM=ul-uw;
    A_M=g5/dl;
    B_M=pl*g6;

    du0=ul-uw;
    aM=sqrt(gama*pl/dl);

    if(du0<0.0){
        *pi=pl*pow(1.0+g7*cM/aM, g3);
        *di=dl*pow(*pi/pl, 1.0/gama);
    }
    else
    {
        *pi=pl+cM*0.5/A_M*(cM+sqrt(cM*cM+4.0*A_M*(B_M+pl)));
        *di=dl*(*pi/pl+g6)/(g6*(*pi)/pl+1.0);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movapd %xmm1, %xmm4
movapd %xmm0, %xmm1
subsd %xmm3, %xmm4
movsd 0x151b(%rip), %xmm0     # 0x1e1b0
movapd %xmm2, 0x10(%rsp)
mulsd %xmm2, %xmm0
divsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movsd %xmm1, 0x8(%rsp)
jb 0x1ccb9
sqrtsd %xmm0, %xmm0
jmp 0x1cccc
movsd %xmm4, (%rsp)
callq 0x31b0
xorpd %xmm2, %xmm2
movsd (%rsp), %xmm4
ucomisd %xmm4, %xmm2
jbe 0x1cd26
mulsd 0x1dde(%rip), %xmm4     # 0x1eab8
divsd %xmm0, %xmm4
addsd 0x14ba(%rip), %xmm4     # 0x1e1a0
movsd 0x211a(%rip), %xmm1     # 0x1ee08
movapd %xmm4, %xmm0
callq 0x3360
movapd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, (%r14)
divsd %xmm1, %xmm0
movsd 0x1b56(%rip), %xmm1     # 0x1e868
callq 0x3360
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
jmp 0x1cdea
movsd 0x20ca(%rip), %xmm1     # 0x1edf8
movapd 0x10(%rsp), %xmm3
mulsd %xmm3, %xmm1
movsd 0x20c0(%rip), %xmm0     # 0x1ee00
movsd 0x8(%rsp), %xmm2
divsd %xmm2, %xmm0
movsd 0x13f6(%rip), %xmm5     # 0x1e148
mulsd %xmm4, %xmm5
divsd %xmm0, %xmm5
mulsd 0x1a26(%rip), %xmm0     # 0x1e788
addsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm4, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1cd86
sqrtsd %xmm0, %xmm0
jmp 0x1cda7
movsd %xmm4, (%rsp)
movapd %xmm5, 0x20(%rsp)
callq 0x31b0
movapd 0x20(%rsp), %xmm5
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm2
addsd %xmm0, %xmm4
mulsd %xmm4, %xmm5
movapd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm5
movsd %xmm5, (%r14)
movsd 0x2032(%rip), %xmm0     # 0x1edf8
mulsd %xmm5, %xmm0
unpcklpd %xmm0, %xmm5            # xmm5 = xmm5[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm5
addpd 0x2032(%rip), %xmm5     # 0x1ee10
mulsd %xmm5, %xmm2
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
divsd %xmm5, %xmm2
movsd %xmm2, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH04_Expressions/examples/warn_dbltoint.cc
// Function: main
int main()
{
	// the compiler might warn about loss of precision
	int ival = 3.541 + 3; // the compiler might warn about loss of precision
	cout << ival << endl;  // prints 6

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x2dff(%rip), %rdi      # 0x3fd8
movl $0x6, %esi
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtmidi_build/tests/midiclock.cpp
// Function: clock_in()
int clock_in()
{
  RtMidiIn *midiin = 0;
  unsigned int clock_count = 0;

  try {

    // RtMidiIn constructor
    midiin = new RtMidiIn();

    // Call function to select port.
    if ( chooseInputPort( midiin ) == false ) goto cleanup;

    // Set our callback function.  This should be done immediately after
    // opening the port to avoid having incoming messages written to the
    // queue instead of sent to the callback function.
    midiin->setCallback( &mycallback, &clock_count );

    // Don't ignore sysex, timing, or active sensing messages.
    midiin->ignoreTypes( false, false, false );

    std::cout << "\nReading MIDI input ... press <enter> to quit.\n";
    char input;
    std::cin.get(input);

  } catch ( RtMidiError &error ) {
    error.printMessage();
  }

 cleanup:

  delete midiin;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x0, 0x4(%rsp)
xorl %ebx, %ebx
movl $0x10, %edi
callq 0x2100
movq %rax, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1c14(%rip), %rsi      # 0x4076
leaq 0x1c20(%rip), %rdx      # 0x4089
leaq 0x8(%rsp), %rdi
callq 0x3318
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x64, %ecx
callq 0x20b0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x249e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
leaq 0x1cb9(%rip), %rsi      # 0x415e
movq %rbx, %rdi
callq 0x2bb9
testb %al, %al
je 0x24ff
movq 0x8(%rbx), %rdi
leaq -0x190(%rip), %rsi      # 0x232c
leaq 0x4(%rsp), %rdx
callq 0x2040
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x48(%rax)
movq 0x3af3(%rip), %rdi      # 0x5fd0
leaq 0x1ba6(%rip), %rsi      # 0x408a
movl $0x2f, %edx
callq 0x2120
movq 0x3aeb(%rip), %rdi      # 0x5fe0
leaq 0x3(%rsp), %rsi
callq 0x2150
testq %rbx, %rbx
je 0x250d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2553
movq %rdx, %r15
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2542
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
jmp 0x2542
movq %rdx, %r15
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x2110
xorl %ebx, %ebx
jmp 0x2559
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x2577
callq 0x2050
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
callq 0x21a0
jmp 0x24ff
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtmidi_build/tests/midiclock.cpp
// Function: main
int main( int, const char *argv[] )
{
  std::string prog(argv[0]);
  if (prog.find("midiclock_in") != prog.npos) {
    clock_in();
  }
  else if (prog.find("midiclock_out") != prog.npos) {
    clock_out();
  }
  else {
    std::cout << "Don't know what to do as " << prog << std::endl;
  }
  return 0;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq (%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2b7c
leaq 0x1690(%rip), %rsi      # 0x4129
movl $0xc, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x21c0
cmpq $-0x1, %rax
je 0x2ab5
callq 0x242f
jmp 0x2b32
leaq 0x167a(%rip), %rsi      # 0x4136
leaq 0x10(%rsp), %rdi
movl $0xd, %ecx
xorl %edx, %edx
callq 0x21c0
cmpq $-0x1, %rax
je 0x2ada
callq 0x2588
jmp 0x2b32
movq 0x34ef(%rip), %rdi      # 0x5fd0
leaq 0x165c(%rip), %rsi      # 0x4144
movl $0x19, %edx
callq 0x2120
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x34cd(%rip), %rdi      # 0x5fd0
callq 0x2120
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b4d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2110
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b73
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21e0
nop