LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/points_solid.cpp
// Function: shapeTransfer()
void shapeTransfer()
{
    int i;
    double phi, x1,y1, cphi,sphi;
    phi = rotate_deg * PI/180.0;
    cphi = cos(-phi);
    sphi = sin(-phi);

    for(int jj=0;jj<N_BODY;++jj) {
        for(i=0;i< NWallPts[jj]; i++)
        {
            x1 = MultiCircle[jj][i].x *  cphi
                - MultiCircle[jj][i].y * sphi;
            y1 = MultiCircle[jj][i].x *  sphi
                + MultiCircle[jj][i].y * cphi;
            MultiCircle[jj][i].x = x1;
            MultiCircle[jj][i].y = y1;
        }

        MultiCircle[jj][NWallPts[jj]]=MultiCircle[jj][0];
    }
}

// Assembly:
leaq 0x19600(%rip), %rax     # 0x23200
movslq (%rax), %rax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
shlq $0x4, %rdx
leaq 0x19766(%rip), %rsi     # 0x23380
xorpd %xmm0, %xmm0
movsd 0x11832(%rip), %xmm1    # 0x1b458
cmpq %rcx, %rdx
je 0x9c5b
movsd (%rsi,%rcx), %xmm2
movsd 0x8(%rsi,%rcx), %xmm3
movapd %xmm3, %xmm4
mulsd %xmm0, %xmm4
addsd %xmm2, %xmm4
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
movsd %xmm4, (%rsi,%rcx)
movsd %xmm2, 0x8(%rsi,%rcx)
addq $0x10, %rcx
jmp 0x9c26
shlq $0x4, %rax
movaps (%rsi), %xmm0
movaps %xmm0, (%rsi,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/points_solid.cpp
// Function: newFlagpoint(double, double, int, pointxy*)
int newFlagpoint(double x,double y, int NumberPoint,PXYZ wallpnt[] )
{
    int ie, cnt=0;
    PXYZ pnt1,pt1,pt2;
	pnt1.x=x;
	pnt1.y=y;
    for(ie=0; ie <= NumberPoint - 1;++ie){
        pt1.x=wallpnt[ie].x;
        pt1.y=wallpnt[ie].y;
        pt2.x=wallpnt[ie+1].x;
        pt2.y=wallpnt[ie+1].y;

        if ((pt1.y!=pt2.y)&&(((pnt1.y >= pt1.y) && (pnt1.y < pt2.y)) 
                || ((pnt1.y >= pt2.y) && (pnt1.y < pt1.y)))) 
        {
            if(pnt1.x == (pt2.x - pt1.x) * (pnt1.y - pt1.y) / (pt2.y - pt1.y) + pt1.x)
            {	
                cnt=-1;break;
            }
            else  if (pnt1.x < (pt2.x - pt1.x) * (pnt1.y - pt1.y) / (pt2.y - pt1.y) + pt1.x)
            {	
                cnt++;
            }
        }
    }          
    return (cnt%2>0)?-1:0;
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
negq %rdi
addq $0x10, %rsi
pushq $-0x1
popq %rdx
xorl %ecx, %ecx
leaq 0x1(%rax), %r9
shlq $0x4, %rax
addq %rsi, %rax
movq %rax, %r8
movq %r9, %rax
leaq (%rdi,%rax), %r9
cmpq $0x1, %r9
je 0x9d08
movupd -0x10(%r8), %xmm2
movupd (%r8), %xmm3
movapd %xmm3, %xmm5
unpckhpd %xmm3, %xmm5            # xmm5 = xmm5[1],xmm3[1]
movapd %xmm2, %xmm4
unpckhpd %xmm2, %xmm4            # xmm4 = xmm4[1],xmm2[1]
ucomisd %xmm5, %xmm4
jne 0x9cb8
jnp 0x9cf6
ucomisd %xmm4, %xmm1
jb 0x9cc4
ucomisd %xmm1, %xmm5
ja 0x9cd0
ucomisd %xmm1, %xmm4
jbe 0x9cf6
ucomisd %xmm5, %xmm1
jb 0x9cf6
subpd %xmm2, %xmm3
movapd %xmm1, %xmm5
subsd %xmm4, %xmm5
mulsd %xmm3, %xmm5
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
divsd %xmm3, %xmm5
addsd %xmm2, %xmm5
ucomisd %xmm0, %xmm5
jne 0x9cf4
jnp 0x9d06
ja 0x9cff
incq %rax
addq $0x10, %r8
jmp 0x9c8b
incl %ecx
jmp 0x9c7a
movl %edx, %ecx
andl $0x80000001, %ecx       # imm = 0x80000001
xorl %eax, %eax
cmpl $0x1, %ecx
sete %al
negl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vecnd.cpp
// Function: fabs(VecND const&)
double fabs(const VecND &vec) {
	//return sqrt(vec.comp[0]*vec.comp[0]+vec.comp[1]*vec.comp[1]+vec.comp[2]*vec.comp[2]);
	//return sqrt(vec.dot(vec));
	
       double rtmp=0.0;
       for(vdsz_type cnt=0; cnt!=vec.comp.size(); ++cnt)
              rtmp+=vec.comp[cnt]*vec.comp[cnt];
       return sqrt(rtmp);	
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xa05d
movsd (%rax,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0xa046
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3180
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vecnd.cpp
// Function: VecND::operator/=(double const&)
VecND &VecND::operator/= (const double &right) {
     for(vdsz_type cnt=0; cnt!=comp.size();++cnt) 
        comp[cnt]/=right;
	//comp[0]/=right;
	//comp[1]/=right;
	//comp[2]/=right;
	return *this;
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %edi, %edi
cmpq %rdi, %rdx
je 0xa0d3
movsd (%rcx,%rdi,8), %xmm0
divsd (%rsi), %xmm0
movsd %xmm0, (%rcx,%rdi,8)
incq %rdi
jmp 0xa0bb
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vecnd.cpp
// Function: VecND::operator=(double const&)
VecND &VecND::operator= (const double &right) {
        for(vdsz_type cnt=0; cnt!=comp.size();++cnt)
                 comp[cnt]=right;
	//comp[0]=right;
	//comp[1]=right;
	//comp[2]=right;
	return *this;
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %edi, %edi
cmpq %rdi, %rdx
je 0xa108
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx,%rdi,8)
incq %rdi
jmp 0xa0f5
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vecnd.cpp
// Function: VecND::operator*(double const&)
VecND VecND::operator*(const double &right) {
	VecND temp(comp.size());
       for(vdsz_type cnt=0; cnt!=comp.size();++cnt) {
           temp.comp[cnt]=comp[cnt]*right;
        }
        	
//	Vec3D temp;
//	temp.comp[0]=comp[0]*right;
//	temp.comp[1]=comp[1]*right;
//	temp.comp[2]=comp[2]*right;
	return temp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
shrq $0x3, %rsi
callq 0x9fa0
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq (%r14), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xa17f
movsd (%rax,%rsi,8), %xmm0
mulsd (%rbx), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0xa167
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vecnd.cpp
// Function: VecND::operator+=(VecND const&)
VecND &VecND::operator+= (const VecND &right) {
       for(vdsz_type cnt=0; cnt!=comp.size();++cnt) 
          comp[cnt]+=right.comp[cnt];
//	comp[0]+=right.comp[0];
//	comp[1]+=right.comp[1];
//	comp[2]+=right.comp[2];
	return *this;
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movq (%rsi), %rsi
xorl %edi, %edi
cmpq %rdi, %rdx
je 0xa235
movsd (%rsi,%rdi,8), %xmm0
addsd (%rcx,%rdi,8), %xmm0
movsd %xmm0, (%rcx,%rdi,8)
incq %rdi
jmp 0xa21c
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vecnd.cpp
// Function: VecND::operator-(double const&)
VecND VecND::operator- (const double &right) {
	VecND temp(comp.size());
       for(vdsz_type cnt=0; cnt!=comp.size();++cnt) 
          temp.comp[cnt]=comp[cnt]-right;
	//VecND temp;
//	temp.comp[0]=comp[0]-right;
	//temp.comp[1]=comp[1]-right;
//	temp.comp[2]=comp[2]-right;
	return temp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
shrq $0x3, %rsi
callq 0x9fa0
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq (%r14), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xa32d
movsd (%rax,%rsi,8), %xmm0
subsd (%rbx), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0xa315
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vecnd.cpp
// Function: operator*(double const&, VecND const&)
VecND operator*(const double &left, const VecND &right) {
	VecND temp(right.comp.size());
       for(vdsz_type cnt=0; cnt!=right.comp.size();++cnt) 
          temp.comp[cnt]=left*right.comp[cnt];
	//Vec3D temp;
	//temp.comp[0]=left*right.comp[0];
	//temp.comp[1]=left*right.comp[1];
//	temp.comp[2]=left*right.comp[2];
	return temp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
shrq $0x3, %rsi
callq 0x9fa0
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq (%rbx), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xa380
movsd (%r14), %xmm0
mulsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0xa367
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vecnd.cpp
// Function: operator/(double const&, VecND const&)
VecND operator/ (const double &left, const VecND &right) {
	VecND temp(right.comp.size());
       for(vdsz_type cnt=0; cnt!=right.comp.size();++cnt) 
          temp.comp[cnt]=left/right.comp[cnt];
//	Vec3D temp;
//	temp.comp[0]=left/right.comp[0];
//	temp.comp[1]=left/right.comp[1];
//	temp.comp[2]=left/right.comp[2];
	return temp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
shrq $0x3, %rsi
callq 0x9fa0
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq (%rbx), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xa3d3
movsd (%r14), %xmm0
divsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0xa3ba
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vecnd.cpp
// Function: operator+(VecND const&, VecND const&)
VecND operator+ (const VecND &left, const VecND &right) {
	VecND temp(right.comp.size());
       for(vdsz_type cnt=0; cnt!=right.comp.size();++cnt) 
          temp.comp[cnt]=left.comp[cnt]+right.comp[cnt];
//	Vec3D temp;
//	temp.comp[0]=left.comp[0]+right.comp[0];
//	temp.comp[1]=left.comp[1]+right.comp[1];
//	temp.comp[2]=left.comp[2]+right.comp[2];
	return temp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
shrq $0x3, %rsi
callq 0x9fa0
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq (%r15), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
cmpq %rdi, %rcx
je 0xa47c
movsd (%rdx,%rdi,8), %xmm0
addsd (%rax,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
jmp 0xa463
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/vecnd.cpp
// Function: operator<<(std::ostream&, VecND const&)
ostream &operator<< (ostream &output,const VecND &right) {
	//output << "{" << right.comp[0] << "," << right.comp[1] << "," << right.comp[2] << "}";
	output << "{";
       for(vdsz_type cnt=0; cnt!=right.comp.size()-1;++cnt) 
         	output << right.comp[cnt]<<",";   
       output << right.comp[right.comp.size()-1]<<"}";  
	return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10b55(%rip), %rsi     # 0x1b0b0
callq 0x31d0
xorl %r12d, %r12d
leaq 0x10b48(%rip), %r15     # 0x1b0b2
movq (%r14), %rax
movq 0x8(%r14), %r13
subq %rax, %r13
sarq $0x3, %r13
decq %r13
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x32e0
cmpq %r13, %r12
je 0xa59e
movq %rax, %rdi
movq %r15, %rsi
callq 0x31d0
incq %r12
jmp 0xa56a
leaq 0x10b0f(%rip), %rsi     # 0x1b0b4
movq %rax, %rdi
callq 0x31d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/formlist.cpp
// Function: formListAll(bodygridclass*, int)
void formListAll(OctCell *pcell, int flg)  //TODO cut off the solid cell
{
    cellEdgeBool ceb1;

	if(pcell!=NULL&&pcell->reflag==0)
	{
		Node *current;
	//    current = (Node *)malloc(sizeof(Node));
        current=new Node;
	
		if(HeadListAllGrid == NULL)	
		{	HeadListAllGrid = current;
            current->prev=NULL;
		}
		else	
			Prev3->next = current;
			
	    current->next = NULL;
	    current->flg=flg;	    
	    current->cell = pcell;
	    //����Ҷ�ӽڵ��� bool bAvg
	    pcell->bAvg=true;
        pcell->mvflg=false;
  //      pcell->p_node=current;
	    //
			      
	    cellEbools.insert(make_pair(pcell,ceb1));

	    current->prev=Prev3;
	    Prev3=current;
	}
	else
	    for(int m=0;m<4;m++) formListAll(pcell->children[m], flg);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
callq 0x45f4
testq %rbx, %rbx
je 0xae1b
cmpw $0x0, 0x1fc(%rbx)
je 0xae3c
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0xaeb9
movq 0x258(%rbx,%r14,8), %rdi
movl %ebp, %esi
callq 0xadf5
incq %r14
jmp 0xae1e
pushq $0x20
popq %rdi
callq 0x31e0
movq %rax, %r14
movq %rax, %rdi
callq 0x441c
leaq 0x1d7ba(%rip), %rax     # 0x28610
cmpq $0x0, (%rax)
je 0xae69
movq 0x1db8d(%rip), %rax     # 0x289f0
movq %r14, 0x10(%rax)
jmp 0xae71
movq %r14, (%rax)
andq $0x0, 0x18(%r14)
andq $0x0, 0x10(%r14)
movw %bp, (%r14)
movq %rbx, 0x8(%r14)
movb $0x1, 0x206(%rbx)
movb $0x0, 0x1b4(%rbx)
movl 0xc(%rsp), %eax
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
movl %eax, 0x8(%rsi)
leaq 0x1d7f6(%rip), %rdi     # 0x28698
callq 0xb280
movq 0x1db42(%rip), %rax     # 0x289f0
movq %rax, 0x18(%r14)
movq %r14, 0x1db37(%rip)     # 0x289f0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/formlist.cpp
// Function: formListFaceCell(bodygridclass*, int)
void formListFaceCell(OctCell *pg, int listflg)
{
	if(pg->flag==listflg)
	{
	    BndryNode *current;
	    current = new BndryNode;
	
	    if(HeadFaceCell == NULL)	
            HeadFaceCell = current;
	    else	
            PrevFacecell->next = current;
		
	    current->next = NULL;	  
	      
	    current->cell = pg;
	      
	    current->prev=PrevFacecell;
	    
//	    pg->pnode=current;
	    PrevFacecell=current;
	    ++sfcell;
	}
	
}

// Assembly:
movswl 0x1b0(%rdi), %eax
cmpl %esi, %eax
jne 0xb128
pushq %rbx
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x31e0
leaq 0x1d527(%rip), %rcx     # 0x28618
cmpq $0x0, (%rcx)
je 0xb104
movq 0x1d8fa(%rip), %rcx     # 0x289f8
movq %rax, 0x8(%rcx)
jmp 0xb10e
movq %rax, (%rcx)
movq 0x1d8ea(%rip), %rcx     # 0x289f8
andq $0x0, 0x8(%rax)
movq %rbx, (%rax)
movq %rcx, 0x10(%rax)
movq %rax, 0x1d8d7(%rip)     # 0x289f8
incl 0x1d8d9(%rip)           # 0x28a00
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/formlist.cpp
// Function: formListFaceCellAll()
void formListFaceCellAll()
{
	Node *current, *pnext;
	OctCell *pcell;
       sfcell=0;
	current = HeadListAllGrid;
	while(current != NULL)
	{
		pnext = current->next;
		pcell=current->cell;
		
		formListFaceCell(pcell, 2);
		current=pnext;
	}
    cout<<"internal face cells have been formed\n";
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
andl $0x0, 0x1d8cc(%rip)     # 0x28a00
leaq 0x1d4d5(%rip), %rax     # 0x28610
movq (%rax), %r14
pushq $0x2
popq %rbx
testq %r14, %r14
je 0xb157
movq 0x8(%r14), %rdi
movq 0x10(%r14), %r14
movl %ebx, %esi
callq 0xb0d3
jmp 0xb141
movq 0x17e62(%rip), %rdi     # 0x22fc0
leaq 0x1038c(%rip), %rsi     # 0x1b4f1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31d0
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/formlist.cpp
// Function: releaseList()
void releaseList()
{
    Node *current, *pnext;

    current = HeadListAllGrid;
    while(current != NULL)
    {
        pnext = current->next;
        delete current;
        current=pnext;
    }
    cout<<"release all listAllGrid end.\n";

    HeadListAllGrid=NULL;
    Prev3=NULL;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1d46b(%rip), %r14     # 0x28610
movq (%r14), %rdi
pushq $0x20
popq %rbx
testq %rdi, %rdi
je 0xb1c1
movq 0x10(%rdi), %r15
movq %rbx, %rsi
callq 0x31f0
movq %r15, %rdi
jmp 0xb1ab
movq 0x17df8(%rip), %rdi     # 0x22fc0
leaq 0x10348(%rip), %rsi     # 0x1b517
callq 0x31d0
andq $0x0, (%r14)
andq $0x0, 0x1d810(%rip)     # 0x289f0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/formlist.cpp
// Function: releaseFaceCellList()
void releaseFaceCellList()
{
    BndryNode *curr, *pne;      
    curr=HeadFaceCell;
    while(curr!=NULL) {
        pne=curr->next;
    //    curr->cell->pnode=NULL;
        delete curr;
        curr=pne;
    }
    HeadFaceCell=NULL;
    PrevFacecell=NULL;
    cout<<"total internal face cell: "<<sfcell<<endl;
    cout<<"releasing internal face cell done\n";
    sfcell=0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1d426(%rip), %r14     # 0x28618
movq (%r14), %rdi
pushq $0x18
popq %rbx
testq %rdi, %rdi
je 0xb20e
movq 0x8(%rdi), %r15
movq %rbx, %rsi
callq 0x31f0
movq %r15, %rdi
jmp 0xb1f8
andq $0x0, (%r14)
andq $0x0, 0x1d7de(%rip)     # 0x289f8
movq 0x17d9f(%rip), %rbx     # 0x22fc0
leaq 0x1030d(%rip), %rsi     # 0x1b535
movq %rbx, %rdi
callq 0x31d0
movl 0x1d7ca(%rip), %esi     # 0x28a00
movq %rax, %rdi
callq 0x3330
movq %rax, %rdi
callq 0x30d0
leaq 0x10303(%rip), %rsi     # 0x1b550
movq %rbx, %rdi
callq 0x31d0
andl $0x0, 0x1d7a4(%rip)     # 0x28a00
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/amr_grid_treat.cpp
// Function: childrenvalue(bodygridclass*, bodygridclass*, int, double, double)
void childrenvalue(OctCell *p1, OctCell *parent,int m,double hcx, double hcy)
{      
	int i,j;
	switch(m)
	{	
	case 0: i=-1;j=-1;break;
	case 1: i=1;j=-1;break;
	case 2: i=1;j=1;break;
	case 3: i=-1;j=1;break;	
	}	   
//	   p1->flag=0;
	   p1->level=parent->level+1;
          p1->NOparent=parent->NOparent;
	   p1->NOchildren=m;
          p1->level0=parent->level0;
	//   p1->reflag=0; //constructor can do this
	//   p1->coflag=0;
	   p1->parent=parent;
	   p1->dx=hcx;
	   p1->dy=hcy;
	   p1->set_invM();
	   
//	   for(int n=0;n<4;n++)	
//	   {                    
//		   p1->children[n]=NULL;			
//	   }	
	   							
	   p1->xc1=parent->xc1+i*hcx*0.5;				
	   p1->yc1=parent->yc1+j*hcy*0.5;	
	   			
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm2, %xmm2
cmpl $0x3, %edx
ja 0xb78d
movl %edx, %eax
leaq 0xfc63(%rip), %rcx      # 0x1b3e0
leaq 0xfc3c(%rip), %rsi      # 0x1b3c0
movsd (%rcx,%rax,8), %xmm2
movhps (%rsi,%rax,8), %xmm2    # xmm2 = xmm2[0,1],mem[0,1]
movaps %xmm2, 0x20(%rsp)
movl 0x1f8(%r14), %eax
incl %eax
movw %ax, 0x1f8(%rbx)
movl 0x200(%r14), %eax
movl %eax, 0x200(%rbx)
movw %dx, 0x204(%rbx)
movzwl 0x1fa(%r14), %eax
movw %ax, 0x1fa(%rbx)
movq %r14, 0x250(%rbx)
movsd %xmm0, 0x288(%rbx)
movsd %xmm1, 0x290(%rbx)
movq %rbx, %rdi
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
callq 0x43ce
movapd (%rsp), %xmm1
unpcklpd 0x10(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
mulpd 0x20(%rsp), %xmm1
movupd 0x278(%r14), %xmm0
mulpd 0xfe01(%rip), %xmm1     # 0x1b610
addpd %xmm0, %xmm1
movupd %xmm1, 0x278(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/amr_grid_treat.cpp
// Function: childrenvalue(bodygridclass*, bodygridclass*, double, double, int)
void childrenvalue(OctCell *p1, OctCell *parent,
    double hcx, double hcy, int m)
{      
	int i,j;
	switch(m)
	{	
	case 0: i=-1;j=-1;break;
	case 1: i=1;j=-1;break;
	case 2: i=1;j=1;break;
	case 3: i=-1;j=1;break;	
	}	   
//	   p1->flag=0;
	   p1->level=parent->level+1;
          p1->NOparent=parent->NOparent;
          p1->level0=parent->level0;
	   p1->NOchildren=m;
	//   p1->reflag=0; //constructor can do this
	//   p1->coflag=0;
	   p1->parent=parent;
	   p1->dx=hcx;
	   p1->dy=hcy;
	   p1->set_invM();
	   
//	   for(int n=0;n<4;n++)	
//	   {                    
//		   p1->children[n]=NULL;			
//	   }	
	   							
	   p1->xc1=parent->xc1+i*hcx*0.5;				
	   p1->yc1=parent->yc1+j*hcy*0.5;	
	   			
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm2, %xmm2
cmpl $0x3, %edx
ja 0xb851
movl %edx, %eax
leaq 0xfb9f(%rip), %rcx      # 0x1b3e0
leaq 0xfb78(%rip), %rsi      # 0x1b3c0
movsd (%rcx,%rax,8), %xmm2
movhps (%rsi,%rax,8), %xmm2    # xmm2 = xmm2[0,1],mem[0,1]
movaps %xmm2, 0x20(%rsp)
movl 0x1f8(%r14), %eax
incl %eax
movw %ax, 0x1f8(%rbx)
movl 0x200(%r14), %eax
movl %eax, 0x200(%rbx)
movzwl 0x1fa(%r14), %eax
movw %ax, 0x1fa(%rbx)
movw %dx, 0x204(%rbx)
movq %r14, 0x250(%rbx)
movsd %xmm0, 0x288(%rbx)
movsd %xmm1, 0x290(%rbx)
movq %rbx, %rdi
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
callq 0x43ce
movapd (%rsp), %xmm1
unpcklpd 0x10(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
mulpd 0x20(%rsp), %xmm1
movupd 0x278(%r14), %xmm0
mulpd 0xfd3d(%rip), %xmm1     # 0x1b610
addpd %xmm0, %xmm1
movupd %xmm1, 0x278(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/amr_grid_treat.cpp
// Function: creatchildren(bodygridclass*)
void creatchildren( OctCell *parent)
{
	int m,preflag;
	//double plevel; 
	double hcx, hcy;//�������Ĳ���
	OctCell *children[4];

	preflag=parent->reflag;

	if(preflag==1) return;//�жϸ�������Ԫ�Ƿ�����
	else 
	{
	//	plevel=parent->level+1;	

		//hc=h/pow(2.0,plevel);//�������Ĳ���	
		hcx=0.5*parent->dx;
		hcy=0.5*parent->dy;

		for(m=0;m<4;m++)
		{		
			//children[m]=(struct bodygrid *)malloc(LEN);
			children[m]=new OctCell(hcx,hcy);	
			parent->children[m]=children[m];
			childrenvalue(children[m],parent,m,hcx, hcy);			
			charggrid(children[m]);	
		} 
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpw $0x1, 0x1fc(%rdi)
jne 0xb904
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movsd 0xf869(%rip), %xmm0     # 0x1b178
movsd 0x288(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
mulsd 0x290(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0xb8fa
movl $0x360, %edi            # imm = 0x360
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x44e8
movq %r15, 0x258(%rbx,%r14,8)
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0xb75f
movq %r15, %rdi
callq 0xb460
incq %r14
jmp 0xb931
movq %rax, %rbx
movl $0x360, %esi            # imm = 0x360
movq %r15, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x198, %rsp            # imm = 0x198
leaq 0x10(%rsp), %rbx
xorl %r12d, %r12d
movl $0x180, %edx            # imm = 0x180
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3100
andl $0x0, 0x1d04c(%rip)     # 0x28a18
leaq 0x1790d(%rip), %r13     # 0x232e0
leaq 0x17916(%rip), %r15     # 0x232f0
testl %r12d, %r12d
je 0xba94
cmpl $0x3, %r12d
je 0xbabc
movq %r12, 0x8(%rsp)
movslq 0x1d01f(%rip), %rax     # 0x28a18
imulq $0x18, %rax, %rcx
movq 0x8(%r15,%rcx), %rbp
subq (%r15,%rcx), %rbp
incl %eax
movl %eax, 0x1d00a(%rip)     # 0x28a18
shlq $0x1d, %rbp
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rax, %rbp
sarq $0x20, %rbp
xorl %r12d, %r12d
cmpq %rbp, %r12
jg 0xba87
movslq 0x1cfe6(%rip), %rax     # 0x28a18
imulq $0x18, %rax, %rax
movq -0x18(%rax,%r15), %rax
movq (%rax,%r12,8), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa74
movq %r14, %rdi
callq 0xb8e7
movw $0x1, 0x1fc(%r14)
xorl %r14d, %r14d
cmpq $0x30, %r14
je 0xba82
movq 0x10(%rsp,%r14,8), %rdi
callq 0xb8e7
movq 0x10(%rsp,%r14,8), %rax
movw $0x1, 0x1fc(%rax)
incq %r14
jmp 0xba5f
incq %r12
jmp 0xba26
movq 0x8(%rsp), %r12
incl %r12d
jmp 0xb9da
movl $0x360, %r14d           # imm = 0x360
cmpq $0x696a80, %r14         # imm = 0x696A80
je 0xb9ed
movq (%r13), %rdi
addq %r14, %rdi
callq 0xb460
addq $0x360, %r14            # imm = 0x360
jmp 0xba9a
pushq $0x8
popq %rax
cmpq $0x68, %rax
je 0xbada
movq -0x8(%r15,%rax), %rcx
cmpq %rcx, (%r15,%rax)
je 0xbad4
movq %rcx, (%r15,%rax)
addq $0x18, %rax
jmp 0xbabf
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbb92
movl %esi, %ebx
movq %rdi, %r14
movw $0x1, 0x1fc(%rdi)
movsd 0xf663(%rip), %xmm0     # 0x1b178
movsd 0x288(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd 0x290(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
decl %ebx
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0xbb92
movl $0x360, %edi            # imm = 0x360
callq 0x31e0
movq %rax, %r12
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x44e8
movq %r12, 0x258(%r14,%r15,8)
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0xb75f
movq %r12, %rdi
movl %ebx, %esi
callq 0xbaec
incq %r15
jmp 0xbb3a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x360, %esi            # imm = 0x360
movq %r12, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/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 %xmm0, 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc9ea
cmpl $0x3, %esi
jne 0xc9ef
mulsd 0x8(%rdi), %xmm0
addsd %xmm2, %xmm0
mulsd 0x10(%rdi), %xmm1
jmp 0xca40
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 0xed5e(%rip), %xmm4     # 0x1b780
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_O2/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 0xca84
cmpl $0x3, %esi
jne 0xca89
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 0xecda(%rip), %xmm2     # 0x1b788
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 0xecbd(%rip), %xmm9     # 0x1b790
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 0xec63(%rip), %xmm4     # 0x1b780
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_O2/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 0xcb8b
cmpl $0x3, %ecx
jne 0xcb8c
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 0xebcd(%rip), %xmm5     # 0x1b788
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 0xebb0(%rip), %xmm9     # 0x1b790
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 0xeb56(%rip), %xmm0     # 0x1b780
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_O2/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 0xe9b0
xorl %ebx, %ebx
leaq 0x1ac9d(%rip), %r14     # 0x28680
movl $0xc0, %r15d
xorl %r12d, %r12d
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
cqto
idivq %r15
cmpq %rax, %r12
je 0xda14
addq %rbx, %rdi
callq 0xcc5c
incq %r12
addq $0xc0, %rbx
jmp 0xd9ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1aa03(%rip), %rbx     # 0x28610
leaq 0x155fc(%rip), %r14     # 0x23210
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xdcd2
movq 0x8(%rbx), %r15
cmpw $0x0, 0x1b0(%r15)
jne 0xdcc9
cmpw $0x2, (%rbx)
jg 0xdcc9
movsd 0x288(%r15), %xmm0
movsd 0x290(%r15), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
mulsd 0xd511(%rip), %xmm0     # 0x1b178
movsd 0x220(%r15), %xmm1
andps 0xd5c9(%rip), %xmm1     # 0x1b240
movaps %xmm1, (%rsp)
movsd 0xdb35(%rip), %xmm1     # 0x1b7b8
callq 0x3340
movapd (%rsp), %xmm1
divsd %xmm0, %xmm1
divsd 0x230(%r15), %xmm1
divsd 0x228(%r15), %xmm1
movsd %xmm1, 0x218(%r15)
ucomisd 0xd56c(%rip), %xmm1     # 0x1b220
seta 0x210(%r15)
ucomisd (%r14), %xmm1
seta 0x211(%r15)
addq $0x10, %rbx
jmp 0xdc14
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/./non_uniform_grid.h
// Function: shblToJbbl(conservedvariables*, privariables*)
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), %xmm0
movsd %xmm0, (%rsi)
movupd 0x8(%rdi), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm2, %xmm1
movupd %xmm1, 0x8(%rsi)
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulsd %xmm1, %xmm1
mulsd 0xd45e(%rip), %xmm0     # 0x1b170
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
addsd 0x18(%rdi), %xmm0
mulsd 0xd501(%rip), %xmm0     # 0x1b228
movsd %xmm0, 0x18(%rsi)
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/hllc.cpp
// Function: GLF_flux(conservedvariables&, conservedvariables&, pointxy&, double*)
void GLF_flux(SHBL &wl, SHBL &wr, PXYZ &nml, double flxface[4])  
{
    JBBL ul,ur;
    double vnl,vnr;
    double tzmax;
    
	shblToJbbl(&wl, &ul);
	shblToJbbl(&wr, &ur);

    vnl=ul.u*nml.x+ul.v*nml.y;
    vnr=ur.u*nml.x+ur.v*nml.y;
    if(fabs(nml.x)<1e-7) tzmax=max_cv_y;
    if(fabs(nml.y)<1e-7) tzmax=max_cv_x;

    flxface[0]=0.5*(wl.q*vnl+wr.q*vnr-tzmax*(wr.q-wl.q));
    flxface[1]=0.5*(wl.qu*vnl+nml.x*ul.p
        +wr.qu*vnr+nml.x*ur.p-tzmax*(wr.qu-wl.qu));
    flxface[2]=0.5*(wl.qv*vnl+nml.y*ul.p
        +wr.qv*vnr+nml.y*ur.p-tzmax*(wr.qv-wl.qv));

    flxface[3]=0.5*((wl.te+ul.p)*vnl + (wr.te+ur.p)*vnr
        - tzmax*(wr.te-wl.te));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rsp, %r13
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
callq 0xdcdc
movq %r14, %rdi
movq %r13, %rsi
callq 0xdcdc
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm3
movapd 0xca0b(%rip), %xmm1     # 0x1b240
andpd %xmm3, %xmm1
movsd 0xcf97(%rip), %xmm2     # 0x1b7d8
ucomisd %xmm1, %xmm2
jbe 0xe850
leaq 0x1a0ea(%rip), %rax     # 0x28938
jmp 0xe857
leaq 0x1a0e9(%rip), %rax     # 0x28940
movsd (%rax), %xmm1
movsd 0x10(%rsp), %xmm4
mulsd %xmm3, %xmm4
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
mulsd 0x30(%rsp), %xmm3
mulsd 0x28(%rsp), %xmm0
addsd %xmm4, %xmm2
addsd %xmm3, %xmm0
movsd (%r15), %xmm4
movsd (%r14), %xmm3
movapd %xmm2, %xmm5
mulsd %xmm3, %xmm5
subsd %xmm4, %xmm3
mulsd %xmm0, %xmm4
addsd %xmm5, %xmm4
mulsd %xmm1, %xmm3
subsd %xmm3, %xmm4
movsd 0xc8c7(%rip), %xmm3     # 0x1b178
mulsd %xmm3, %xmm4
movsd %xmm4, (%rbx)
movsd 0x8(%r15), %xmm5
movsd (%r12), %xmm6
movsd 0x38(%rsp), %xmm4
movapd %xmm6, %xmm7
mulsd %xmm4, %xmm7
movsd 0x8(%r14), %xmm8
movapd %xmm8, %xmm9
subsd %xmm5, %xmm8
mulsd %xmm0, %xmm5
addsd %xmm7, %xmm5
mulsd %xmm2, %xmm9
addsd %xmm5, %xmm9
movsd 0x18(%rsp), %xmm5
mulsd %xmm5, %xmm6
addsd %xmm9, %xmm6
mulsd %xmm1, %xmm8
subsd %xmm8, %xmm6
mulsd %xmm3, %xmm6
movsd %xmm6, 0x8(%rbx)
movsd 0x10(%r15), %xmm6
movsd 0x8(%r12), %xmm7
movapd %xmm4, %xmm8
mulsd %xmm7, %xmm8
movsd 0x10(%r14), %xmm9
movapd %xmm9, %xmm10
subsd %xmm6, %xmm9
mulsd %xmm0, %xmm6
addsd %xmm8, %xmm6
mulsd %xmm2, %xmm10
addsd %xmm6, %xmm10
mulsd %xmm5, %xmm7
addsd %xmm10, %xmm7
mulsd %xmm1, %xmm9
subsd %xmm9, %xmm7
mulsd %xmm3, %xmm7
movsd %xmm7, 0x10(%rbx)
movsd 0x18(%r15), %xmm6
addsd %xmm6, %xmm4
movsd 0x18(%r14), %xmm7
addsd %xmm7, %xmm5
mulsd %xmm2, %xmm5
mulsd %xmm0, %xmm4
addsd %xmm5, %xmm4
subsd %xmm6, %xmm7
mulsd %xmm1, %xmm7
subsd %xmm7, %xmm4
mulsd %xmm3, %xmm4
movsd %xmm4, 0x18(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19c50(%rip), %rax     # 0x28610
movq (%rax), %rbx
leaq 0x19f76(%rip), %r14     # 0x28940
andq $0x0, (%r14)
leaq 0x19f63(%rip), %r15     # 0x28938
andq $0x0, (%r15)
movsd 0xc78f(%rip), %xmm3     # 0x1b170
movsd 0xc83f(%rip), %xmm4     # 0x1b228
movsd 0xc83f(%rip), %xmm5     # 0x1b230
xorpd %xmm6, %xmm6
movapd 0xc843(%rip), %xmm7     # 0x1b240
testq %rbx, %rbx
je 0xeafc
movq 0x8(%rbx), %rax
cmpw $0x0, 0x1b0(%rax)
jne 0xeaf3
cmpw $0x2, (%rbx)
jg 0xeaf3
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 0xea84
sqrtsd %xmm0, %xmm0
jmp 0xeac7
movapd %xmm8, 0x10(%rsp)
movapd %xmm9, (%rsp)
callq 0x3180
movapd (%rsp), %xmm9
movapd 0x10(%rsp), %xmm8
movapd 0xc795(%rip), %xmm7     # 0x1b240
xorpd %xmm6, %xmm6
movsd 0xc779(%rip), %xmm5     # 0x1b230
movsd 0xc769(%rip), %xmm4     # 0x1b228
movsd 0xc6a9(%rip), %xmm3     # 0x1b170
andpd %xmm7, %xmm9
addsd %xmm0, %xmm9
ucomisd (%r15), %xmm9
jbe 0xeadd
movsd %xmm9, (%r15)
andpd %xmm7, %xmm8
addsd %xmm0, %xmm8
ucomisd (%r14), %xmm8
jbe 0xeaf3
movsd %xmm8, (%r14)
movq 0x10(%rbx), %rbx
jmp 0xe9fd
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xeb34
sqrtsd %xmm0, %xmm11
jmp 0xeb42
callq 0x3180
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm11
movsd (%r15), %xmm0
ucomisd %xmm1, %xmm0
jb 0xeb53
sqrtsd %xmm0, %xmm1
jmp 0xeb68
movapd %xmm11, (%rsp)
callq 0x3180
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 0xc650(%rip), %xmm5     # 0x1b228
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 0xc572(%rip), %xmm9     # 0x1b178
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 0xc4e9(%rip), %xmm0     # 0x1b170
addsd %xmm4, %xmm0
mulsd %xmm5, %xmm0
mulsd %xmm0, %xmm2
divsd 0xc595(%rip), %xmm2     # 0x1b230
movsd %xmm2, 0x18(%r14)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xecb1
sqrtsd %xmm0, %xmm0
jmp 0xecb6
callq 0x3180
movsd %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
leaq 0x18f80(%rip), %rax     # 0x28610
movq (%rax), %rax
testq %rax, %rax
je 0xf6db
movq 0x8(%rax), %rcx
testb $0x1, 0x1b0(%rcx)
jne 0xf6d5
cmpw $0x2, (%rax)
jg 0xf6d5
addq $0x2a0, %rcx            # imm = 0x2A0
xorl %edx, %edx
cmpq $0x4, %rdx
je 0xf6d5
xorl %esi, %esi
cmpq $0x6, %rsi
je 0xf6cc
andq $0x0, (%rcx,%rsi,8)
incq %rsi
jmp 0xf6bc
incq %rdx
addq $0x30, %rcx
jmp 0xf6b4
addq $0x10, %rax
jmp 0xf690
xorl %ebx, %ebx
leaq 0x18f9c(%rip), %r14     # 0x28680
movl $0xc0, %r15d
xorl %r12d, %r12d
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
cqto
idivq %r15
cmpq %rax, %r12
je 0xf715
addq %rbx, %rdi
callq 0xecc8
incq %r12
addq $0xc0, %rbx
jmp 0xf6ed
leaq 0x18ef4(%rip), %rbx     # 0x28610
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xf743
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0xf73d
cmpw $0x2, (%rbx)
jg 0xf73d
callq 0xf1f1
addq $0x10, %rbx
jmp 0xf71c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb5d5(%rip), %xmm0     # 0x1b0c8
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