LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/amr_grid_treat.cpp
// Function: creatgrid()
void creatgrid()
{   
   int ir;	
   int ic,Nc;
   int kr,Nk;
   
   int i;
   
   OctCell *parent;
   
   OctCell *pp[48]={NULL};//�����ཻ�������ڽ�����Ҫ���ܵ�������Ԫ��ַ  
   Nc=Nx*Ny;
 //  kref=0; //
   re=0;
   for(ir=0;ir<Nr;ir++)
   {
	   if(ir==0)
	   {
		   for(ic=1;ic<=Nc;ic++)//�ҳ�z=0��������Ҫ���ܵ�������Ԫ
		   {			               
			   charggrid(&bodygrid[ic]);
		   }
	   }
	   
	   Nk=refcell[re].size()-1;
	//   Nk=kref-1;
	//   kref=0;
	   re++;
	   
	   for(kr=0;kr<=Nk;kr++)//Nk�������ཻ��������(ljm Nk+1)
	   {
	//	   OctCell *pp[48];//�����ཻ�������ڽ�����Ҫ���ܵ�������Ԫ��ַ  
               //  parent=refcell[re-1][kr];
                 parent=refcell[re-1][kr];
		   findrefp(pp,parent);	//�ҵ������ཻ�������ڽ�����Ҫ���ܵ�������Ԫ           
		   creatchildren(parent);
		   parent->reflag=1;
		   for(i=0;i<48;i++)
		   {                
		      creatchildren(pp[i]);
		       pp[i]->reflag=1;
		   }
	   }
   }
   
   for(int itm=0; itm<Nr+1; ++itm) 
        refcell[itm].clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsp, %rbx
xorl %r12d, %r12d
movl $0x180, %edx            # imm = 0x180
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3120
movl $0x0, 0x1e06e(%rip)     # 0x2aa18
leaq 0x1892f(%rip), %r13     # 0x252e0
leaq 0x18938(%rip), %r15     # 0x252f0
testl %r12d, %r12d
jne 0xc9df
movl $0x360, %r14d           # imm = 0x360
movq (%r13), %rdi
addq %r14, %rdi
callq 0xc3f8
addq $0x360, %r14            # imm = 0x360
cmpq $0x696a80, %r14         # imm = 0x696A80
jne 0xc9c3
movslq 0x1e032(%rip), %rcx     # 0x2aa18
leaq (%rcx,%rcx,2), %rdx
movq 0x8(%r15,%rdx,8), %rax
subq (%r15,%rdx,8), %rax
shrq $0x3, %rax
incl %ecx
movl %ecx, 0x1e019(%rip)     # 0x2aa18
movl %eax, %ecx
decl %ecx
js 0xca65
movl %eax, %ebp
xorl %r13d, %r13d
movslq 0x1e007(%rip), %rax     # 0x2aa18
leaq (%rax,%rax,2), %rax
movq -0x18(%r15,%rax,8), %rax
movq (%rax,%r13,8), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb9a0
movq %r14, %rdi
callq 0xc8c6
movw $0x1, 0x1fc(%r14)
xorl %r14d, %r14d
movq (%rsp,%r14,8), %rdi
callq 0xc8c6
movq (%rsp,%r14,8), %rax
movw $0x1, 0x1fc(%rax)
incq %r14
cmpq $0x30, %r14
jne 0xca3e
incq %r13
cmpq %rbp, %r13
jne 0xca0a
incl %r12d
cmpl $0x3, %r12d
leaq 0x1886d(%rip), %r13     # 0x252e0
jne 0xc9b8
movl $0x8, %eax
movq -0x8(%r15,%rax), %rcx
cmpq %rcx, (%r15,%rax)
je 0xca8d
movq %rcx, (%r15,%rax)
addq $0x18, %rax
cmpq $0x68, %rax
jne 0xca7e
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/amr_grid_treat.cpp
// Function: refineOneCell(bodygridclass*, int)
void refineOneCell(OctCell *parent, int rfN)
{
	double hcx,hcy;//�������Ĳ���
	OctCell *children[4]={NULL};
//	double plevel;
	int m;

//	plevel=parent->level+1;	
//	hc=h/pow(2.0,plevel);//�������Ĳ���	

    if( rfN >= 1)
	{
		parent->reflag=1; /*1��2���޸�*/
		hcx=0.5*parent->dx;
		hcy=0.5*parent->dy;
		for(m=0;m<4;m++)
		{		
			children[m]=new OctCell(hcx,hcy);	
			parent->children[m]=children[m];
			childrenvalue(children[m],parent,m,hcx, hcy);			
			refineOneCell(children[m], rfN-1);
		}
	}
	else return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0xcb4d
movl %esi, %ebx
movq %rdi, %r14
movw $0x1, 0x1fc(%rdi)
movsd 0x11676(%rip), %xmm0    # 0x1e148
movsd 0x288(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd 0x290(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
decl %ebx
xorl %r15d, %r15d
movl $0x360, %edi            # imm = 0x360
callq 0x3210
movq %rax, %r12
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x46e8
movq %r12, 0x258(%r14,%r15,8)
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0xc728
movq %r12, %rdi
movl %ebx, %esi
callq 0xcaa9
incq %r15
cmpq $0x4, %r15
jne 0xcaf7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x360, %esi            # imm = 0x360
movq %r12, %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec2d.cpp
// Function: Vec2D::operator/=(double const&)
Vec2D &Vec2D::operator/= (const double &right) {
	comp[0]/=right;
	comp[1]/=right;
	//comp[2]/=right;
	return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
divsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
divsd (%rsi), %xmm1
movsd %xmm1, 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec2d.cpp
// Function: Vec2D::operator=(Vec2D const&)
Vec2D &Vec2D::operator= (const Vec2D &right) {
	comp[0]=right.comp[0];
	comp[1]=right.comp[1];
//	comp[2]=right.comp[2];
	return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec2d.cpp
// Function: Vec2D::operator=(double const&)
Vec2D &Vec2D::operator= (const double &right) {
	comp[0]=right;
	comp[1]=right;
//	comp[2]=right;
	return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
movsd (%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec2d.cpp
// Function: Vec2D::operator+=(Vec2D const&)
Vec2D &Vec2D::operator+= (const Vec2D &right) {
	comp[0]+=right.comp[0];
	comp[1]+=right.comp[1];
//	comp[2]+=right.comp[2];
	return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
addsd (%rdi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
addsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/approx_sol.cpp
// Function: approx_sol(double, double, double*, int)
double approx_sol(double x, double y, double *doftmp, int n )
{

    double uh;
    if(n==6) {
      uh=doftmp[0]+doftmp[1]*x+doftmp[2]*y+doftmp[3]*x*y
       +doftmp[4]*(x*x-1.0/3.0) + doftmp[5]*(y*y-1.0/3.0); 
     }
     else if(n==3) {
      uh=doftmp[0]+doftmp[1]*x+doftmp[2]*y;
     }
     else if(n==1) {
        uh=doftmp[0];
     }
       
    return uh;
}

// Assembly:
movsd (%rdi), %xmm2
cmpl $0x1, %esi
je 0xdc6a
cmpl $0x3, %esi
jne 0xdc6f
mulsd 0x8(%rdi), %xmm0
addsd %xmm2, %xmm0
mulsd 0x10(%rdi), %xmm1
jmp 0xdcc0
movapd %xmm2, %xmm0
retq
movsd 0x8(%rdi), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd 0x10(%rdi), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
movsd 0x18(%rdi), %xmm3
mulsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm0, %xmm0
movsd 0x10ade(%rip), %xmm4    # 0x1e780
addsd %xmm4, %xmm0
mulsd 0x20(%rdi), %xmm0
addsd %xmm2, %xmm3
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm4, %xmm1
mulsd 0x28(%rdi), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/approx_sol.cpp
// Function: n_approx_sol(double, double, double, double, double, double, double*, int)
double n_approx_sol(double x,double y, double xc1, double yc1, double dx, double dy, double *doftmp, int n )
{
    double uh;
    if(n==6) {
      uh=doftmp[0]+doftmp[1]*2.0*(x-xc1)/dx+doftmp[2]*2.0*(y-yc1)/dy+doftmp[3]*4.0*(x-xc1)*(y-yc1)/(dx*dy)
       +doftmp[4]*((x-xc1)*(x-xc1)*4.0/(dx*dx)-1.0/3.0) + doftmp[5]*((y-yc1)*(y-yc1)*4.0/(dy*dy)-1.0/3.0); 
     }
     else if(n==3) {
      uh=doftmp[0]+doftmp[1]*2.0*(x-xc1)/dx+doftmp[2]*2.0*(y-yc1)/dy;
     }
     else if(n==1) {
        uh=doftmp[0];
     }
       
    return uh;
}

// Assembly:
movsd (%rdi), %xmm6
cmpl $0x1, %esi
je 0xdd04
cmpl $0x3, %esi
jne 0xdd09
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
subpd %xmm2, %xmm0
movupd 0x8(%rdi), %xmm1
addpd %xmm1, %xmm1
mulpd %xmm0, %xmm1
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
divpd %xmm4, %xmm1
addsd %xmm1, %xmm6
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm1, %xmm6
movapd %xmm6, %xmm0
retq
movsd 0x8(%rdi), %xmm7
addsd %xmm7, %xmm7
subsd %xmm2, %xmm0
mulsd %xmm0, %xmm7
divsd %xmm4, %xmm7
addsd %xmm7, %xmm6
subsd %xmm3, %xmm1
movsd 0x10a5a(%rip), %xmm2    # 0x1e788
movsd 0x18(%rdi), %xmm3
mulsd %xmm2, %xmm3
movapd %xmm4, %xmm7
mulsd %xmm5, %xmm7
movsd 0x10(%rdi), %xmm8
unpcklpd %xmm0, %xmm8            # xmm8 = xmm8[0],xmm0[0]
movapd 0x10a3d(%rip), %xmm9    # 0x1e790
unpcklpd %xmm3, %xmm9            # xmm9 = xmm9[0],xmm3[0]
mulpd %xmm8, %xmm9
movapd %xmm1, %xmm3
unpcklpd %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0]
mulpd %xmm9, %xmm3
movapd %xmm5, %xmm8
unpcklpd %xmm7, %xmm8            # xmm8 = xmm8[0],xmm7[0]
divpd %xmm8, %xmm3
addsd %xmm3, %xmm6
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
addsd %xmm6, %xmm3
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm0
mulsd %xmm4, %xmm4
divsd %xmm4, %xmm0
movsd 0x109e3(%rip), %xmm4    # 0x1e780
addsd %xmm4, %xmm0
mulsd 0x20(%rdi), %xmm0
addsd %xmm3, %xmm0
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm5, %xmm5
divsd %xmm5, %xmm1
addsd %xmm4, %xmm1
mulsd 0x28(%rdi), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/approx_sol.cpp
// Function: n_approx_sol(double const*, double const*, double, double, double*, int)
double n_approx_sol(const double xi[2],  const double xc[2], double dx, double dy, double *doftmp, int n )
{
    double uh;
    if(n==6) {
      uh=doftmp[0]+doftmp[1]*2.0*(xi[0]-xc[0])/dx+doftmp[2]*2.0*(xi[1]-xc[1])/dy+doftmp[3]*4.0*(xi[0]-xc[0])*(xi[1]-xc[1])/(dx*dy)
       +doftmp[4]*((xi[0]-xc[0])*(xi[0]-xc[0])*4.0/(dx*dx)-1.0/3.0) + doftmp[5]*((xi[1]-xc[1])*(xi[1]-xc[1])*4.0/(dy*dy)-1.0/3.0); 
     }
     else if(n==3) {
      uh=doftmp[0]+doftmp[1]*2.0*(xi[0]-xc[0])/dx+doftmp[2]*2.0*(xi[1]-xc[1])/dy;
     }
     else if(n==1) {
        uh=doftmp[0];
     }       
    return uh;
}

// Assembly:
movapd %xmm0, %xmm2
movsd (%rdx), %xmm0
cmpl $0x1, %ecx
je 0xde0b
cmpl $0x3, %ecx
jne 0xde0c
movupd 0x8(%rdx), %xmm3
addpd %xmm3, %xmm3
movupd (%rdi), %xmm4
movupd (%rsi), %xmm5
subpd %xmm5, %xmm4
mulpd %xmm3, %xmm4
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
divpd %xmm2, %xmm4
addsd %xmm4, %xmm0
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
addsd %xmm4, %xmm0
retq
movsd 0x8(%rdx), %xmm5
addsd %xmm5, %xmm5
movsd (%rdi), %xmm4
movsd 0x8(%rdi), %xmm3
subsd (%rsi), %xmm4
mulsd %xmm4, %xmm5
divsd %xmm2, %xmm5
addsd %xmm5, %xmm0
subsd 0x8(%rsi), %xmm3
movsd 0x1094d(%rip), %xmm5    # 0x1e788
movsd 0x18(%rdx), %xmm6
mulsd %xmm5, %xmm6
movapd %xmm2, %xmm7
mulsd %xmm1, %xmm7
movsd 0x10(%rdx), %xmm8
unpcklpd %xmm4, %xmm8            # xmm8 = xmm8[0],xmm4[0]
movapd 0x10930(%rip), %xmm9    # 0x1e790
unpcklpd %xmm6, %xmm9            # xmm9 = xmm9[0],xmm6[0]
mulpd %xmm8, %xmm9
movapd %xmm3, %xmm6
unpcklpd %xmm3, %xmm6            # xmm6 = xmm6[0],xmm3[0]
mulpd %xmm9, %xmm6
movapd %xmm1, %xmm8
unpcklpd %xmm7, %xmm8            # xmm8 = xmm8[0],xmm7[0]
divpd %xmm8, %xmm6
addsd %xmm6, %xmm0
unpckhpd %xmm6, %xmm6            # xmm6 = xmm6[1,1]
addsd %xmm0, %xmm6
mulsd %xmm4, %xmm4
mulsd %xmm5, %xmm4
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm4
movsd 0x108d6(%rip), %xmm0    # 0x1e780
addsd %xmm0, %xmm4
mulsd 0x20(%rdx), %xmm4
addsd %xmm6, %xmm4
mulsd %xmm3, %xmm3
mulsd %xmm5, %xmm3
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm3
addsd %xmm0, %xmm3
mulsd 0x28(%rdx), %xmm3
addsd %xmm4, %xmm3
movapd %xmm3, %xmm0
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/face_flux_all.cpp
// Function: face_flux_all()
void face_flux_all( )
{
    if(HLLCFLUX==0)
        set_max_cv();
    for(vector<Face>::size_type isz=0; isz!=faces_comp.size(); ++isz){
        face_flux(faces_comp[isz]);
    }   
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0xfcac
leaq 0x1ba2a(%rip), %rbx     # 0x2a680
movq (%rbx), %rdi
cmpq %rdi, 0x8(%rbx)
je 0xec98
xorl %r14d, %r14d
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r12d, %r12d
addq %r14, %rdi
callq 0xdedc
incq %r12
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
sarq $0x6, %rax
imulq %r15, %rax
addq $0xc0, %r14
cmpq %rax, %r12
jne 0xec6f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/face_flux_all.cpp
// Function: set_kxrcf()
void set_kxrcf()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    double rtp;
  //  int pol=2;
  //  pol=(nDOF==6?2:1);
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag  == 0 && current->flg<=2 ) {
          //  rtp=max2(pcell0->dx,pcell0->dy);
            rtp=0.5*sqrt(pcell0->dx*pcell0->dx
                +pcell0->dy*pcell0->dy);
            pcell0->kxrcf=fabs(pcell0->kxq)/pow(rtp,1.5)/
            pcell0->inlen/pcell0->maxqp;
            if(pcell0->kxrcf>1.0) pcell0->trb=true;
            else pcell0->trb=false;
            if(pcell0->kxrcf>value_kxrcf_amr) pcell0->trbamr=true;
            else pcell0->trbamr=false;
        }
        current = current->next;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x1b798(%rip), %rax     # 0x2a610
movq (%rax), %rbx
testq %rbx, %rbx
je 0xef52
leaq 0x16385(%rip), %r14     # 0x25210
movq 0x8(%rbx), %r15
cmpw $0x0, 0x1b0(%r15)
jne 0xef45
cmpw $0x2, (%rbx)
jg 0xef45
movsd 0x288(%r15), %xmm0
movsd 0x290(%r15), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd 0xf2ea(%rip), %xmm0     # 0x1e1b8
jb 0xeed6
sqrtsd %xmm0, %xmm0
jmp 0xeedb
callq 0x31b0
mulsd 0xf265(%rip), %xmm0     # 0x1e148
movsd 0x220(%r15), %xmm1
andps 0xf2cd(%rip), %xmm1     # 0x1e1c0
movaps %xmm1, (%rsp)
movsd 0xf8b9(%rip), %xmm1     # 0x1e7b8
callq 0x3360
movapd (%rsp), %xmm1
divsd %xmm0, %xmm1
divsd 0x230(%r15), %xmm1
divsd 0x228(%r15), %xmm1
movsd %xmm1, 0x218(%r15)
ucomisd 0xf270(%rip), %xmm1     # 0x1e1a0
seta 0x210(%r15)
ucomisd (%r14), %xmm1
seta 0x211(%r15)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0xee8b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/./non_uniform_grid.h
// Function: GLF_flux(conservedvariables&, conservedvariables&, pointxy&, double*)
inline void shblToJbbl(SHBL *ush, JBBL *jbu)
{
    jbu->q=ush->q;
    jbu->u=ush->qu/ush->q;
    jbu->v=ush->qv/ush->q;

    jbu->p = (ush->te - 0.5 * ush->q * (jbu->u * jbu->u
            + jbu->v * jbu->v)) * GAM11;

}

// Assembly:
movsd (%rdi), %xmm5
movsd 0x8(%rdi), %xmm0
divsd %xmm5, %xmm0
movsd 0x10(%rdi), %xmm6
divsd %xmm5, %xmm6
movapd %xmm6, %xmm1
mulsd %xmm6, %xmm1
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movsd 0xe652(%rip), %xmm2     # 0x1e140
movapd %xmm5, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm3, %xmm1
addsd 0x18(%rdi), %xmm1
movsd 0xe6a1(%rip), %xmm4     # 0x1e1a8
mulsd %xmm4, %xmm1
movsd (%rsi), %xmm7
movsd 0x8(%rsi), %xmm3
divsd %xmm7, %xmm3
movsd 0x10(%rsi), %xmm8
divsd %xmm7, %xmm8
movapd %xmm8, %xmm9
mulsd %xmm8, %xmm9
movapd %xmm3, %xmm10
mulsd %xmm3, %xmm10
addsd %xmm9, %xmm10
mulsd %xmm7, %xmm2
mulsd %xmm10, %xmm2
addsd 0x18(%rsi), %xmm2
mulsd %xmm4, %xmm2
movsd (%rdx), %xmm9
movsd 0x8(%rdx), %xmm10
movapd 0xe65f(%rip), %xmm4     # 0x1e1c0
andpd %xmm10, %xmm4
movsd 0xec69(%rip), %xmm11    # 0x1e7d8
ucomisd %xmm4, %xmm11
jbe 0xfb7f
leaq 0x1adbb(%rip), %rax     # 0x2a938
jmp 0xfb86
leaq 0x1adba(%rip), %rax     # 0x2a940
movsd (%rax), %xmm4
mulsd %xmm10, %xmm8
mulsd %xmm9, %xmm3
addsd %xmm8, %xmm3
mulsd %xmm10, %xmm6
mulsd %xmm9, %xmm0
addsd %xmm6, %xmm0
movapd %xmm7, %xmm6
mulsd %xmm3, %xmm6
subsd %xmm5, %xmm7
mulsd %xmm0, %xmm5
addsd %xmm6, %xmm5
mulsd %xmm4, %xmm7
subsd %xmm7, %xmm5
movsd 0xe57d(%rip), %xmm6     # 0x1e148
mulsd %xmm6, %xmm5
movsd %xmm5, (%rcx)
movsd 0x8(%rdi), %xmm5
movsd (%rdx), %xmm7
movapd %xmm1, %xmm8
mulsd %xmm7, %xmm8
movsd 0x8(%rsi), %xmm9
movapd %xmm9, %xmm10
subsd %xmm5, %xmm9
mulsd %xmm0, %xmm5
addsd %xmm8, %xmm5
mulsd %xmm3, %xmm10
addsd %xmm5, %xmm10
mulsd %xmm2, %xmm7
addsd %xmm10, %xmm7
mulsd %xmm4, %xmm9
subsd %xmm9, %xmm7
mulsd %xmm6, %xmm7
movsd %xmm7, 0x8(%rcx)
movsd 0x10(%rdi), %xmm5
movsd 0x8(%rdx), %xmm7
movapd %xmm1, %xmm8
mulsd %xmm7, %xmm8
movsd 0x10(%rsi), %xmm9
movapd %xmm9, %xmm10
subsd %xmm5, %xmm9
mulsd %xmm0, %xmm5
addsd %xmm8, %xmm5
mulsd %xmm3, %xmm10
addsd %xmm5, %xmm10
mulsd %xmm2, %xmm7
addsd %xmm10, %xmm7
mulsd %xmm4, %xmm9
subsd %xmm9, %xmm7
mulsd %xmm6, %xmm7
movsd %xmm7, 0x10(%rcx)
movsd 0x18(%rdi), %xmm5
addsd %xmm5, %xmm1
movsd 0x18(%rsi), %xmm7
addsd %xmm7, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
subsd %xmm5, %xmm7
mulsd %xmm4, %xmm7
subsd %xmm7, %xmm1
mulsd %xmm6, %xmm1
movsd %xmm1, 0x18(%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/hllc.cpp
// Function: set_max_cv()
void set_max_cv()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *unp;
    double a;
    JBBL jbu;
    SHBL shu;
    double rt1,rt0;

    max_cv_x=max_cv_y=0.0;

    while(current != NULL)
    {		
        unp = current->cell;
        if(unp->flag  == 0 && current->flg<=2 ) {

            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);

            a = sqrt(GAMMA * jbu.p / jbu.q);
            rt0=fabs(jbu.u)+a;
            rt1=fabs(jbu.v)+a;
            if(max_cv_x<rt0)max_cv_x=rt0;
            if(max_cv_y<rt1)max_cv_y=rt1;
        }
        current = current->next;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x1a954(%rip), %rax     # 0x2a610
movq (%rax), %rbx
leaq 0x1ac7a(%rip), %r14     # 0x2a940
xorl %eax, %eax
movq %rax, (%r14)
leaq 0x1ac66(%rip), %r15     # 0x2a938
movq %rax, (%r15)
testq %rbx, %rbx
je 0xfdfc
movsd 0xe45a(%rip), %xmm3     # 0x1e140
movsd 0xe4ba(%rip), %xmm4     # 0x1e1a8
movsd 0xe4ba(%rip), %xmm5     # 0x1e1b0
xorpd %xmm6, %xmm6
movapd 0xe4be(%rip), %xmm7     # 0x1e1c0
movq 0x8(%rbx), %rax
cmpw $0x0, 0x1b0(%rax)
jne 0xfdef
cmpw $0x2, (%rbx)
jg 0xfdef
movsd 0x30(%rax), %xmm1
movsd 0x60(%rax), %xmm9
movsd 0x90(%rax), %xmm8
divsd %xmm1, %xmm9
divsd %xmm1, %xmm8
movapd %xmm8, %xmm0
mulsd %xmm8, %xmm0
movapd %xmm9, %xmm2
mulsd %xmm9, %xmm2
addsd %xmm0, %xmm2
movapd %xmm1, %xmm0
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm0
addsd 0xc0(%rax), %xmm0
mulsd %xmm4, %xmm0
mulsd %xmm5, %xmm0
divsd %xmm1, %xmm0
ucomisd %xmm6, %xmm0
jb 0xfd80
sqrtsd %xmm0, %xmm0
jmp 0xfdc3
movapd %xmm8, 0x10(%rsp)
movapd %xmm9, (%rsp)
callq 0x31b0
movapd (%rsp), %xmm9
movapd 0x10(%rsp), %xmm8
movapd 0xe419(%rip), %xmm7     # 0x1e1c0
xorpd %xmm6, %xmm6
movsd 0xe3fd(%rip), %xmm5     # 0x1e1b0
movsd 0xe3ed(%rip), %xmm4     # 0x1e1a8
movsd 0xe37d(%rip), %xmm3     # 0x1e140
andpd %xmm7, %xmm9
addsd %xmm0, %xmm9
ucomisd (%r15), %xmm9
jbe 0xfdd9
movsd %xmm9, (%r15)
andpd %xmm7, %xmm8
addsd %xmm0, %xmm8
ucomisd (%r14), %xmm8
jbe 0xfdef
movsd %xmm8, (%r14)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0xfd02
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/roe.cpp
// Function: RoeRiemannSolver(privariables*, privariables*, privariables*, double*)
void RoeRiemannSolver(JBBL *Ul, JBBL *Ur, JBBL *Uface, double *a) 
{
	double ql,qr;

	double htl, htr,faceht;
	double dls;

	ql=sqrt(Ul->q);
	qr=sqrt(Ur->q);

 
	Uface->q = ql*qr;

	Uface->u=(ql*Ul->u + qr*Ur->u)/(ql+qr);
	Uface->v=(ql*Ul->v + qr*Ur->v)/(ql+qr);

        htl=Ul->p/(Ul->q * (GAMMA-1)) 
		+ 0.5 * (Ul->u * Ul->u + Ul->v * Ul->v)
		+ Ul->p/Ul->q;
        htr=Ur->p/(Ur->q * (GAMMA-1)) 
		+ 0.5 * (Ur->u * Ur->u + Ur->v * Ur->v)
		+ Ur->p/Ur->q;

	faceht=(ql*htl + qr*htr)/(ql+qr);

       htl=(faceht - 0.5 * (Uface->u*Uface->u +
		Uface->v*Uface->v)) * (GAMMA-1);

	Uface->p = Uface->q * htl  / GAMMA;
	*a=sqrt(htl);  // ����
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd (%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xfe34
sqrtsd %xmm0, %xmm11
jmp 0xfe42
callq 0x31b0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm11
movsd (%r15), %xmm0
ucomisd %xmm1, %xmm0
jb 0xfe56
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0xfe6b
movapd %xmm11, (%rsp)
callq 0x31b0
movapd (%rsp), %xmm11
movapd %xmm0, %xmm1
movapd %xmm11, %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, (%r14)
movapd %xmm11, %xmm3
addsd %xmm1, %xmm3
movupd 0x8(%r12), %xmm4
movupd 0x8(%r15), %xmm0
movapd %xmm1, %xmm5
unpcklpd %xmm1, %xmm5            # xmm5 = xmm5[0],xmm1[0]
mulpd %xmm0, %xmm5
movapd %xmm11, %xmm0
unpcklpd %xmm11, %xmm0           # xmm0 = xmm0[0],xmm11[0]
mulpd %xmm4, %xmm0
addpd %xmm5, %xmm0
movapd %xmm3, %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
divpd %xmm4, %xmm0
movupd %xmm0, 0x8(%r14)
movsd 0x18(%r12), %xmm4
movsd (%r12), %xmm6
movsd 0x8(%r12), %xmm7
movsd 0xe2cd(%rip), %xmm5     # 0x1e1a8
movapd %xmm4, %xmm8
divsd %xmm6, %xmm4
mulsd %xmm5, %xmm6
divsd %xmm6, %xmm8
movsd 0x10(%r12), %xmm6
mulsd %xmm6, %xmm6
mulsd %xmm7, %xmm7
addsd %xmm6, %xmm7
movsd 0xe23f(%rip), %xmm9     # 0x1e148
mulsd %xmm9, %xmm7
addsd %xmm8, %xmm7
addsd %xmm7, %xmm4
movsd 0x18(%r15), %xmm6
movsd (%r15), %xmm7
movsd 0x8(%r15), %xmm8
movapd %xmm6, %xmm10
divsd %xmm7, %xmm6
mulsd %xmm5, %xmm7
divsd %xmm7, %xmm10
movsd 0x10(%r15), %xmm7
mulsd %xmm7, %xmm7
mulsd %xmm8, %xmm8
addsd %xmm7, %xmm8
mulsd %xmm9, %xmm8
addsd %xmm10, %xmm8
addsd %xmm8, %xmm6
mulsd %xmm1, %xmm6
mulsd %xmm11, %xmm4
addsd %xmm6, %xmm4
divsd %xmm3, %xmm4
movapd %xmm0, %xmm1
mulpd %xmm0, %xmm1
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd 0xe1b6(%rip), %xmm0     # 0x1e140
addsd %xmm4, %xmm0
mulsd %xmm5, %xmm0
mulsd %xmm0, %xmm2
divsd 0xe212(%rip), %xmm2     # 0x1e1b0
movsd %xmm2, 0x18(%r14)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xffb4
sqrtsd %xmm0, %xmm0
jmp 0xffb9
callq 0x31b0
movsd %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/spatial_discretization.cpp
// Function: spatial_discretization_all()
void spatial_discretization_all()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag % 2 == 0 && current->flg<=2 ) {
            for(int im=0;im<4; ++im){
                for(int jm=0;jm<6; ++jm){
                    pcell0->residual[im][jm]=0.0;
                }
            }
        }

        current = current->next;
    }


    for(vector<Face>::size_type isz=0; isz!=faces_comp.size(); ++isz){
        spatial_discretize_f(faces_comp[isz]);
    }

    current = HeadListAllGrid;     
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag == 0 && current->flg<=2 ) 
            spatial_discretize_v(pcell0);
        current = current->next;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x19779(%rip), %rbx     # 0x2a610
movq (%rbx), %r14
testq %r14, %r14
je 0x10ecc
movq 0x8(%r14), %rdi
testb $0x1, 0x1b0(%rdi)
jne 0x10ec6
cmpw $0x2, (%r14)
jg 0x10ec6
addq $0x2a0, %rdi            # imm = 0x2A0
movl $0xc0, %edx
xorl %esi, %esi
callq 0x3120
movq 0x10(%r14), %r14
jmp 0x10e9a
leaq 0x197ad(%rip), %r14     # 0x2a680
movq (%r14), %rdi
cmpq %rdi, 0x8(%r14)
je 0x10f15
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r13d, %r13d
addq %r15, %rdi
callq 0xffcc
incq %r13
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
sarq $0x6, %rax
imulq %r12, %rax
addq $0xc0, %r15
cmpq %rax, %r13
jne 0x10eec
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x10f3c
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x10f36
cmpw $0x2, (%rbx)
jg 0x10f36
callq 0x10a16
movq 0x10(%rbx), %rbx
jmp 0x10f18
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: reflection(privariables const*, pointxy const*, privariables*)
void reflection(const JBBL *jbu, const PXYZ *nxyz, JBBL *jbugst)
{
    jbugst->q = jbu->q;
    jbugst->p = jbu->p;

    jbugst->u = (- nxyz->x * nxyz->x + nxyz->y * nxyz->y) * jbu->u - 2 * nxyz->x * nxyz->y * jbu->v; 
    jbugst->v = - 2 * nxyz->x * nxyz->y * jbu->u + (nxyz->x * nxyz->x - nxyz->y * nxyz->y)* jbu->v; 
}

// Assembly:
movsd (%rdi), %xmm0
movsd %xmm0, (%rdx)
movsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x18(%rdx)
movsd (%rsi), %xmm0
movapd %xmm0, %xmm1
mulsd 0xcc88(%rip), %xmm0     # 0x1e0c8
movsd 0x8(%rsi), %xmm2
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm1
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
movsd 0x10(%rdi), %xmm4
movapd %xmm0, %xmm5
mulsd %xmm4, %xmm5
mulsd 0x8(%rdi), %xmm3
addsd %xmm5, %xmm3
movsd %xmm3, 0x8(%rdx)
subsd %xmm2, %xmm1
mulsd %xmm4, %xmm1
mulsd 0x8(%rdi), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: reflection(double, double, privariables const*, pointxy const*, privariables*)
void reflection(double hr, double hg,const JBBL *jbu, const PXYZ *nxyz, JBBL *jbugst)
{
    double tx,ty,nx,ny;
    nx=nxyz->x;
    ny=nxyz->y;
    tx=ny;
    ty=-nx;
    Vec2D ndir(nx,ny);
    Vec2D tdir(tx,ty);
    Vec2D ur(jbu->u,jbu->v);
    double un1,ut1,un2,ut2;
    un1=ur.dot(ndir);
    ut1=ur.dot(tdir);
    un2=-(hg/hr)*un1;
    ut2=ut1;

    jbugst->q = jbu->q;
    jbugst->p = jbu->p;
    jbugst->u = (ny * ut2 - ty * un2)/(tx * ny - nx * ty);
    jbugst->v = (tx * un2 - nx * ut2)/(tx * ny - nx * ty);			
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movaps %xmm1, 0x40(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd (%rsi), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x8(%rsi), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, %xmm2
xorps 0xcbd7(%rip), %xmm2     # 0x1e0a0
movaps %xmm2, 0x20(%rsp)
leaq 0x70(%rsp), %r15
movq %r15, %rdi
callq 0xd250
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
callq 0xd250
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
leaq 0x50(%rsp), %r13
movq %r13, %rdi
callq 0xd250
movq %r13, %rdi
movq %r15, %rsi
callq 0xd25a
movsd %xmm0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0xd25a
movapd 0x40(%rsp), %xmm3
xorpd 0xcb6c(%rip), %xmm3     # 0x1e0a0
divsd 0x8(%rsp), %xmm3
mulsd (%rsp), %xmm3
movsd (%r14), %xmm1
movsd %xmm1, (%rbx)
movsd 0x18(%r14), %xmm1
movsd %xmm1, 0x18(%rbx)
movapd 0x30(%rsp), %xmm4
movapd %xmm4, %xmm1
mulsd %xmm4, %xmm1
movapd 0x10(%rsp), %xmm5
movapd %xmm5, %xmm2
mulsd %xmm5, %xmm2
addsd %xmm1, %xmm2
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
unpcklpd %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0]
unpcklpd 0x20(%rsp), %xmm3       # xmm3 = xmm3[0],mem[0]
mulpd %xmm4, %xmm3
movapd %xmm5, %xmm1
unpcklpd %xmm5, %xmm1            # xmm1 = xmm1[0],xmm5[0]
mulpd %xmm0, %xmm1
addpd %xmm3, %xmm1
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
divpd %xmm2, %xmm1
movupd %xmm1, 0x8(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc78f(%rip), %xmm2     # 0x1e1c0
movsd 0xc9a7(%rip), %xmm4     # 0x1e3e0
ucomisd %xmm2, %xmm4
jbe 0x11a49
movsd (%rdi), %xmm1
movsd %xmm1, (%rcx)
jmp 0x11ac7
movsd (%rsi), %xmm2
movapd %xmm2, %xmm3
subsd (%rdx), %xmm3
movapd 0xc763(%rip), %xmm5     # 0x1e1c0
andpd %xmm3, %xmm5
ucomisd %xmm5, %xmm4
jbe 0x11a72
movsd %xmm2, (%rcx)
movsd 0x8(%rdi), %xmm0
jmp 0x11ac7
movsd 0x8(%rdi), %xmm4
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
subsd %xmm1, %xmm0
divsd %xmm3, %xmm0
movsd 0xc8fd(%rip), %xmm1     # 0x1e388
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_O1/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 0x12175
sqrtsd %xmm0, %xmm0
jmp 0x121be
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 0xbffa(%rip), %xmm1     # 0x1e1c0
andpd %xmm1, %xmm12
addsd 0xc6a4(%rip), %xmm12    # 0x1e878
divsd %xmm12, %xmm0
mulsd %xmm10, %xmm9
mulsd %xmm11, %xmm8
subsd %xmm9, %xmm8
andpd %xmm1, %xmm8
cmpltsd 0xc689(%rip), %xmm8     # 0x1e880
movsd 0xc689(%rip), %xmm1     # 0x1e888
andpd %xmm8, %xmm1
andnpd %xmm0, %xmm8
orpd %xmm1, %xmm8
movapd %xmm8, %xmm0
addq $0x58, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12929
xorl %r15d, %r15d
movq 0x258(%rbx,%r15,8), %rsi
movq %r14, %rdi
callq 0x128ea
testq %rax, %rax
jne 0x129c8
incq %r15
cmpq $0x4, %r15
jne 0x12902
jmp 0x129c4
movsd 0x278(%rbx), %xmm2
movsd 0x288(%rbx), %xmm0
movsd (%r14), %xmm1
movsd 0xb802(%rip), %xmm3     # 0x1e148
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
addsd 0xb7fa(%rip), %xmm3     # 0x1e150
ucomisd %xmm1, %xmm3
jbe 0x129c4
mulsd 0xb7dc(%rip), %xmm0     # 0x1e140
addsd %xmm2, %xmm0
addsd 0xbf20(%rip), %xmm0     # 0x1e890
ucomisd %xmm0, %xmm1
jbe 0x129c4
movsd 0x290(%rbx), %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x280(%rbx), %xmm2
movsd 0xb7b4(%rip), %xmm3     # 0x1e148
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
addsd 0xb7ac(%rip), %xmm3     # 0x1e150
ucomisd %xmm1, %xmm3
jbe 0x129c4
mulsd 0xb78e(%rip), %xmm0     # 0x1e140
addsd %xmm2, %xmm0
addsd 0xbed2(%rip), %xmm0     # 0x1e890
ucomisd %xmm0, %xmm1
ja 0x129cb
xorl %ebx, %ebx
jmp 0x129cb
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
cmpw $0x0, 0x1fc(%rdi)
je 0x132ab
xorl %r14d, %r14d
movq (%rsp), %rax
movq 0x258(%rax,%r14,8), %rdi
movq %rbx, %rsi
callq 0x13274
incq %r14
cmpq $0x4, %r14
jne 0x1328c
jmp 0x132b6
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/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 0x15b2d(%rip), %rax     # 0x2a618
movq (%rax), %r15
leaq 0x23a5b(%rip), %rdi     # 0x38550
callq 0x6d74
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %r15, %r15
je 0x14b7e
leaq 0x107c4(%rip), %r12     # 0x252e0
movq %rsp, %rbx
leaq 0x23a2a(%rip), %r14     # 0x38550
movq (%r15), %r13
movl 0x200(%r13), %eax
imulq $0x360, %rax, %rsi      # imm = 0x360
addq (%r12), %rsi
movq %rbx, %rdi
callq 0x1b8a2
movl 0x200(%r13), %eax
imulq $0x360, %rax, %rdi      # imm = 0x360
addq (%r12), %rdi
movq %r14, %rsi
callq 0x1c9fc
xorl %r13d, %r13d
movq (%rsp,%r13,8), %rdi
movq %r14, %rsi
callq 0x1c9fc
incq %r13
cmpq $0x8, %r13
jne 0x14b60
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x14b26
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10573(%rip), %rax     # 0x25200
movslq (%rax), %r15
testq %r15, %r15
jle 0x14cbe
leaq 0x106e4(%rip), %rbx     # 0x25380
leaq 0x15e05(%rip), %r14     # 0x2aaa8
movq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14b8c
addq $0x10, %rbx
addq $0x38, %r14
decq %r12
jne 0x14ca6
imulq $0x38, %r15, %r14
leaq 0x15dc7(%rip), %rbx     # 0x2aa90
leaq (%rbx,%r14), %rdi
movq %rbx, %rsi
callq 0xd2fa
movaps 0x15dc4(%rip), %xmm0    # 0x2aaa0
movups %xmm0, 0x10(%r14,%rbx)
movaps 0x15dc7(%rip), %xmm0    # 0x2aab0
movups %xmm0, 0x20(%r14,%rbx)
movq 0x15dca(%rip), %rax     # 0x2aac0
movq %rax, 0x30(%r14,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x104ea(%rip), %r14     # 0x25200
cmpl $0x0, (%r14)
jle 0x14d8e
leaq 0x1065d(%rip), %r15     # 0x25380
addq $0x18, %r15
leaq 0x15d62(%rip), %rbx     # 0x2aa90
xorl %r12d, %r12d
incq %r12
movsd (%r15), %xmm0
subsd -0x10(%r15), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd506
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%r15), %xmm0
subsd -0x8(%r15), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xd506
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movslq (%r14), %rax
addq $0x38, %rbx
addq $0x10, %r15
cmpq %rax, %r12
jl 0x14d31
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x151c5(%rip), %rax     # 0x2a610
movq (%rax), %rax
testq %rax, %rax
je 0x15494
movq 0x8(%rax), %rcx
testb $0x1, 0x1b0(%rcx)
jne 0x1548e
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 0x1546b
incq %rdx
addq $0x30, %rcx
cmpq $0x4, %rdx
jne 0x15469
movq 0x10(%rax), %rax
jmp 0x1544e
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x154ae
leaq 0x1526f(%rip), %rax     # 0x2a710
movabsq $0x3f40624dd2f1a9fc, %rcx # imm = 0x3F40624DD2F1A9FC
movq %rcx, (%rax)
testl %edx, %edx
je 0x155b9
cmpl $0x1, %edx
je 0x15542
cmpl $0x2, %edx
jne 0x1560c
movl $0x30, %eax
xorl %ecx, %ecx
leaq 0x1523a(%rip), %rdx     # 0x2a710
movsd 0x947a(%rip), %xmm0     # 0x1e958
movsd 0x947a(%rip), %xmm1     # 0x1e960
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 0x154ed
incq %rcx
addq $0x30, %rax
cmpq $0x4, %rcx
jne 0x154e6
jmp 0x1560c
movl $0x30, %eax
xorl %ecx, %ecx
leaq 0x151c0(%rip), %rdx     # 0x2a710
movsd 0x9288(%rip), %xmm0     # 0x1e7e0
movsd 0x9408(%rip), %xmm1     # 0x1e968
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 0x15567
incq %rcx
addq $0x30, %rax
cmpq $0x4, %rcx
jne 0x15560
jmp 0x1560c
movl $0x30, %eax
xorl %ecx, %ecx
leaq 0x15149(%rip), %rdx     # 0x2a710
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 0x155ce
incq %rcx
addq $0x30, %rax
cmpq $0x4, %rcx
jne 0x155c7
movb $0x1, 0x206(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14ff1(%rip), %rax     # 0x2a610
movq (%rax), %r14
testq %r14, %r14
je 0x15652
movl %esi, %ebx
movl %edi, %ebp
movq 0x8(%r14), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x15649
cmpw $0x2, (%r14)
jg 0x15649
movl %ebp, %esi
movl %ebx, %edx
callq 0x15495
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x1562b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x669d(%rip), %xmm0     # 0x1e140
mulsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
addsd 0xc0(%rdi), %xmm0
mulsd 0x66ed(%rip), %xmm0     # 0x1e1a8
mulsd 0x66ed(%rip), %xmm0     # 0x1e1b0
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x17ad7
sqrtsd %xmm0, %xmm0
jmp 0x17b0a
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 0xd70f(%rip), %rax      # 0x25220
movsd (%rax), %xmm1
mulsd %xmm5, %xmm1
mulsd %xmm4, %xmm1
movapd 0x669b(%rip), %xmm2     # 0x1e1c0
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_O1/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 0x12bb1(%rip), %r14     # 0x2a710
movabsq $0x409f400000000000, %rax # imm = 0x409F400000000000
movq %rax, (%r14)
leaq 0x12a9d(%rip), %rax     # 0x2a610
movq (%rax), %r15
testq %r15, %r15
je 0x17bc0
movq 0x8(%r15), %rbx
cmpw $0x0, 0x1b0(%rbx)
jne 0x17bba
cmpw $0x2, (%r15)
jg 0x17bba
movq %rbx, %rdi
callq 0x17a55
cmpw $0x0, 0x1b0(%rbx)
jne 0x17bba
movsd 0x298(%rbx), %xmm0
movsd (%r14), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x17bba
movsd %xmm0, (%r14)
movq 0x10(%r15), %r15
jmp 0x17b76
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x65ca(%rip), %xmm0     # 0x1e1b0
mulsd %xmm2, %xmm0
divsd %xmm5, %xmm0
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
jb 0x17bfe
sqrtsd %xmm0, %xmm0
jmp 0x17c31
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 0x6d56(%rip), %xmm8     # 0x1e9a0
movapd %xmm5, %xmm7
mulsd %xmm8, %xmm7
mulsd %xmm6, %xmm7
movsd 0x6549(%rip), %xmm4     # 0x1e1a8
mulsd %xmm6, %xmm4
addsd 0x6455(%rip), %xmm4     # 0x1e0c0
divsd %xmm4, %xmm7
movsd %xmm7, (%r15)
mulsd 0x6d2c(%rip), %xmm6     # 0x1e9a8
addsd 0x6d2c(%rip), %xmm6     # 0x1e9b0
mulsd %xmm2, %xmm6
divsd %xmm8, %xmm6
movsd %xmm6, (%r14)
movsd (%r15), %xmm4
movapd %xmm5, %xmm2
divsd %xmm4, %xmm2
movsd 0x64f9(%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