LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19b78(%rip), %rax     # 0x24200
movslq (%rax), %rax
testq %rax, %rax
jle 0xa6df
movq %rax, %rcx
shlq $0x4, %rcx
xorl %edx, %edx
leaq 0x19ce0(%rip), %rsi     # 0x24380
xorpd %xmm0, %xmm0
movsd 0x12d4c(%rip), %xmm1    # 0x1d3f8
movsd (%rsi,%rdx), %xmm2
movsd 0x8(%rsi,%rdx), %xmm3
movapd %xmm3, %xmm4
mulsd %xmm0, %xmm4
addsd %xmm2, %xmm4
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
movsd %xmm4, (%rsi,%rdx)
movsd %xmm2, 0x8(%rsi,%rdx)
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0xa6ac
shlq $0x4, %rax
leaq 0x19c96(%rip), %rcx     # 0x24380
movaps (%rcx), %xmm0
movaps %xmm0, (%rcx,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edi, %edi
jle 0xa775
movl %edi, %eax
movupd (%rsi), %xmm2
shlq $0x4, %rax
xorl %edx, %edx
xorl %ecx, %ecx
movapd %xmm2, %xmm3
movupd 0x10(%rsi,%rdx), %xmm2
movapd %xmm2, %xmm5
unpckhpd %xmm2, %xmm5            # xmm5 = xmm5[1],xmm2[1]
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
ucomisd %xmm5, %xmm4
jne 0xa726
jnp 0xa76a
ucomisd %xmm4, %xmm1
jb 0xa732
ucomisd %xmm1, %xmm5
ja 0xa73e
ucomisd %xmm1, %xmm4
jbe 0xa76a
ucomisd %xmm5, %xmm1
jb 0xa76a
movapd %xmm2, %xmm5
subpd %xmm3, %xmm5
movapd %xmm1, %xmm6
subsd %xmm4, %xmm6
mulsd %xmm5, %xmm6
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
divsd %xmm5, %xmm6
addsd %xmm3, %xmm6
ucomisd %xmm0, %xmm6
jne 0xa766
jnp 0xa778
jbe 0xa76a
incl %ecx
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0xa704
jmp 0xa77d
xorl %eax, %eax
retq
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
andl $0x80000001, %ecx       # imm = 0x80000001
xorl %eax, %eax
cmpl $0x1, %ecx
sete %al
negl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
subq %rax, %rcx
je 0xaae8
sarq $0x3, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0xaad3
ucomisd %xmm1, %xmm0
jb 0x31b0
sqrtsd %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
je 0xabab
sarq $0x3, %rdx
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm0
divsd (%rsi), %xmm0
movsd %xmm0, (%rcx,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0xab95
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdi
subq %rcx, %rdi
je 0xac68
sarq $0x3, %rdi
movsd (%rsi), %xmm0
leaq 0x1(%rdi), %rdx
andq $-0x2, %rdx
decq %rdi
movq %rdi, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
movdqa 0x1284e(%rip), %xmm2    # 0x1d440
xorl %esi, %esi
movdqa 0x12854(%rip), %xmm3    # 0x1d450
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movdqa 0x12854(%rip), %xmm5    # 0x1d460
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm1, %xmm7
pcmpeqd %xmm1, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0xac46
movsd %xmm0, (%rcx,%rsi,8)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0xac5b
movsd %xmm0, 0x8(%rcx,%rsi,8)
addq $0x2, %rsi
paddq %xmm5, %xmm2
cmpq %rsi, %rdx
jne 0xac0c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaa14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0xacdf
sarq $0x3, %rcx
movq (%r14), %rdx
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
mulsd (%rbx), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0xacc9
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
je 0xad95
sarq $0x3, %rdx
movq (%rsi), %rsi
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm0
addsd (%rcx,%rdi,8), %xmm0
movsd %xmm0, (%rcx,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0xad7e
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaa14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0xae8d
sarq $0x3, %rcx
movq (%r14), %rdx
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
subsd (%rbx), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0xae77
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaa14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0xaee0
sarq $0x3, %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd (%r14), %xmm0
mulsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0xaec9
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaa14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0xaf33
sarq $0x3, %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movsd (%r14), %xmm0
divsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0xaf1c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
shrq $0x3, %rsi
callq 0xaa14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0xafdc
sarq $0x3, %rcx
movq (%r14), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm0
addsd (%rax,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0xafc5
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x11f46(%rip), %rsi     # 0x1d0b0
movl $0x1, %edx
callq 0x3250
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0xb188
xorl %ecx, %ecx
jmp 0xb1cf
xorl %r12d, %r12d
leaq 0x11f20(%rip), %r15     # 0x1d0b2
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x3300
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3250
leaq 0x1(%r12), %rcx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
addq $-0x2, %rdx
cmpq %rdx, %r12
movq %rcx, %r12
jne 0xb192
movsd (%rax,%rcx,8), %xmm0
movq %rbx, %rdi
callq 0x3300
leaq 0x11ed1(%rip), %rsi     # 0x1d0b4
movl $0x1, %edx
movq %rax, %rdi
callq 0x3250
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x481c
testq %rbx, %rbx
je 0xbbd9
cmpw $0x0, 0x1fc(%rbx)
je 0xbbf9
xorl %r14d, %r14d
movq 0x258(%rbx,%r14,8), %rdi
movl %ebp, %esi
callq 0xbbb3
incq %r14
cmpq $0x4, %r14
jne 0xbbdc
jmp 0xbc7e
movl $0x20, %edi
callq 0x3210
movq %rax, %r14
movq %rax, %rdi
callq 0x4624
leaq 0x1d9fb(%rip), %rax     # 0x29610
cmpq $0x0, (%rax)
je 0xbc28
movq 0x1ddce(%rip), %rax     # 0x299f0
movq %r14, 0x10(%rax)
jmp 0xbc33
movq %r14, (%rax)
movq $0x0, 0x18(%r14)
movq $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 0x1da31(%rip), %rdi     # 0x29698
callq 0xc0a6
movq 0x1dd7d(%rip), %rax     # 0x299f0
movq %rax, 0x18(%r14)
movq %r14, 0x1dd72(%rip)     # 0x299f0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movl $0x0, 0x1dac2(%rip)     # 0x29a00
leaq 0x1d6cb(%rip), %rax     # 0x29610
movq (%rax), %rbx
testq %rbx, %rbx
je 0xbf61
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rbx
movl $0x2, %esi
callq 0xbed8
jmp 0xbf48
movq 0x18060(%rip), %rdi     # 0x23fc8
leaq 0x11561(%rip), %rsi     # 0x1d4d0
movl $0x25, %edx
popq %rbx
jmp 0x3250
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x1d663(%rip), %rbx     # 0x29610
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbfcb
movq 0x10(%rdi), %r14
movl $0x20, %esi
callq 0x3220
movq %r14, %rdi
testq %r14, %r14
jne 0xbfb5
movq 0x17ff6(%rip), %rdi     # 0x23fc8
leaq 0x1151d(%rip), %rsi     # 0x1d4f6
movl $0x1d, %edx
callq 0x3250
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x1da01(%rip)     # 0x299f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x1d616(%rip), %rbx     # 0x29618
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc020
movq 0x8(%rdi), %r14
movl $0x18, %esi
callq 0x3220
movq %r14, %rdi
testq %r14, %r14
jne 0xc00a
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x1d9cc(%rip)     # 0x299f8
movq 0x17f95(%rip), %rbx     # 0x23fc8
leaq 0x114da(%rip), %rsi     # 0x1d514
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x3250
movl 0x1d9b3(%rip), %esi     # 0x29a00
movq %rbx, %rdi
callq 0x3350
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
leaq 0x114a9(%rip), %rsi     # 0x1d52f
movl $0x22, %edx
movq %rbx, %rdi
callq 0x3250
movl $0x0, 0x1d963(%rip)     # 0x29a00
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
xorpd %xmm2, %xmm2
cmpl $0x3, %edx
ja 0xc5bb
movl %edx, %eax
leaq 0x10ddf(%rip), %rcx     # 0x1d388
leaq 0x10db8(%rip), %r8      # 0x1d368
movsd (%rcx,%rax,8), %xmm2
movhpd (%r8,%rax,8), %xmm2     # xmm2 = xmm2[0],mem[0]
movl 0x1f8(%rsi), %eax
incl %eax
movw %ax, 0x1f8(%rdi)
movl 0x200(%rsi), %eax
movl %eax, 0x200(%rdi)
movw %dx, 0x204(%rdi)
movzwl 0x1fa(%rsi), %eax
movw %ax, 0x1fa(%rdi)
movq %rsi, 0x250(%rdi)
movsd %xmm0, 0x288(%rdi)
movsd %xmm1, 0x290(%rdi)
movapd %xmm0, %xmm3
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
movapd 0x10a3e(%rip), %xmm4    # 0x1d050
divpd %xmm3, %xmm4
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm4
movupd %xmm4, (%rdi)
movhpd %xmm4, 0x10(%rdi)
movapd 0x10a2d(%rip), %xmm4    # 0x1d060
divpd %xmm3, %xmm4
divpd %xmm1, %xmm4
movupd %xmm4, 0x18(%rdi)
movhpd %xmm4, 0x28(%rdi)
mulpd %xmm2, %xmm0
movupd 0x278(%rsi), %xmm1
mulpd 0x10f97(%rip), %xmm0    # 0x1d5f0
addpd %xmm1, %xmm0
movupd %xmm0, 0x278(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
xorpd %xmm2, %xmm2
cmpl $0x3, %edx
ja 0xc68a
movl %edx, %eax
leaq 0x10d10(%rip), %rcx     # 0x1d388
leaq 0x10ce9(%rip), %r8      # 0x1d368
movsd (%rcx,%rax,8), %xmm2
movhpd (%r8,%rax,8), %xmm2     # xmm2 = xmm2[0],mem[0]
movl 0x1f8(%rsi), %eax
incl %eax
movw %ax, 0x1f8(%rdi)
movl 0x200(%rsi), %eax
movl %eax, 0x200(%rdi)
movzwl 0x1fa(%rsi), %eax
movw %ax, 0x1fa(%rdi)
movw %dx, 0x204(%rdi)
movq %rsi, 0x250(%rdi)
movsd %xmm0, 0x288(%rdi)
movsd %xmm1, 0x290(%rdi)
movapd %xmm0, %xmm3
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
movapd 0x1096f(%rip), %xmm4    # 0x1d050
divpd %xmm3, %xmm4
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm4
movupd %xmm4, (%rdi)
movhpd %xmm4, 0x10(%rdi)
movapd 0x1095e(%rip), %xmm4    # 0x1d060
divpd %xmm3, %xmm4
divpd %xmm1, %xmm4
movupd %xmm4, 0x18(%rdi)
movhpd %xmm4, 0x28(%rdi)
mulpd %xmm2, %xmm0
movupd 0x278(%rsi), %xmm1
mulpd 0x10ec8(%rip), %xmm0    # 0x1d5f0
addpd %xmm1, %xmm0
movupd %xmm0, 0x278(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
je 0xc7c7
movq %rdi, %rbx
movsd 0x109f5(%rip), %xmm0    # 0x1d148
movsd 0x288(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
mulsd 0x290(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
movl $0x360, %edi            # imm = 0x360
callq 0x3210
movq %rax, %r15
movq %rax, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x46e8
movq %r15, 0x258(%rbx,%r14,8)
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0xc597
movq %r15, %rdi
callq 0xc280
incq %r14
cmpq $0x4, %r14
jne 0xc775
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x360, %esi            # imm = 0x360
movq %r15, %rdi
callq 0x3220
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/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, 0x1d1ff(%rip)     # 0x29a18
leaq 0x17ac0(%rip), %r13     # 0x242e0
leaq 0x17ac9(%rip), %r15     # 0x242f0
testl %r12d, %r12d
jne 0xc84e
movl $0x360, %r14d           # imm = 0x360
movq (%r13), %rdi
addq %r14, %rdi
callq 0xc280
addq $0x360, %r14            # imm = 0x360
cmpq $0x696a80, %r14         # imm = 0x696A80
jne 0xc832
movslq 0x1d1c3(%rip), %rcx     # 0x29a18
leaq (%rcx,%rcx,2), %rdx
movq 0x8(%r15,%rdx,8), %rax
subq (%r15,%rdx,8), %rax
shrq $0x3, %rax
incl %ecx
movl %ecx, 0x1d1aa(%rip)     # 0x29a18
movl %eax, %ecx
decl %ecx
js 0xc8d4
movl %eax, %ebp
xorl %r13d, %r13d
movslq 0x1d198(%rip), %rax     # 0x29a18
leaq (%rax,%rax,2), %rax
movq -0x18(%r15,%rax,8), %rax
movq (%rax,%r13,8), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb82c
movq %r14, %rdi
callq 0xc735
movw $0x1, 0x1fc(%r14)
xorl %r14d, %r14d
movq (%rsp,%r14,8), %rdi
callq 0xc735
movq (%rsp,%r14,8), %rax
movw $0x1, 0x1fc(%rax)
incq %r14
cmpq $0x30, %r14
jne 0xc8ad
incq %r13
cmpq %rbp, %r13
jne 0xc879
incl %r12d
cmpl $0x3, %r12d
leaq 0x179fe(%rip), %r13     # 0x242e0
jne 0xc827
movl $0x8, %eax
movq -0x8(%r15,%rax), %rcx
cmpq %rcx, (%r15,%rax)
je 0xc8fc
movq %rcx, (%r15,%rax)
addq $0x18, %rax
cmpq $0x68, %rax
jne 0xc8ed
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc9bc
movl %esi, %ebx
movq %rdi, %r14
movw $0x1, 0x1fc(%rdi)
movsd 0x10807(%rip), %xmm0    # 0x1d148
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 0xc597
movq %r12, %rdi
movl %ebx, %esi
callq 0xc918
incq %r15
cmpq $0x4, %r15
jne 0xc966
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_O3/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 0xd922
cmpl $0x3, %esi
jne 0xd927
mulsd 0x8(%rdi), %xmm0
addsd %xmm2, %xmm0
mulsd 0x10(%rdi), %xmm1
jmp 0xd978
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 0xfe06(%rip), %xmm4     # 0x1d760
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_O3/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 0xd9bc
cmpl $0x3, %esi
jne 0xd9c1
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 0xfd82(%rip), %xmm2     # 0x1d768
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 0xfd65(%rip), %xmm9     # 0x1d770
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 0xfd0b(%rip), %xmm4     # 0x1d760
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_O3/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 0xdac3
cmpl $0x3, %ecx
jne 0xdac4
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 0xfc75(%rip), %xmm5     # 0x1d768
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 0xfc58(%rip), %xmm9     # 0x1d770
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 0xfbfe(%rip), %xmm0     # 0x1d760
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_O3/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 0xf924
leaq 0x1ad76(%rip), %rbx     # 0x29680
movq (%rbx), %rdi
cmpq %rdi, 0x8(%rbx)
je 0xe94c
xorl %r14d, %r14d
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r12d, %r12d
addq %r14, %rdi
callq 0xdb94
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 0xe923
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1aae4(%rip), %rax     # 0x29610
movq (%rax), %rbx
testq %rbx, %rbx
je 0xebf5
leaq 0x156d1(%rip), %r14     # 0x24210
movq 0x8(%rbx), %r15
cmpw $0x0, 0x1b0(%r15)
jne 0xebe8
cmpw $0x2, (%rbx)
jg 0xebe8
movsd 0x288(%r15), %xmm0
movsd 0x290(%r15), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
mulsd 0xe5c2(%rip), %xmm0     # 0x1d148
movsd 0x220(%r15), %xmm1
andps 0xe62a(%rip), %xmm1     # 0x1d1c0
movaps %xmm1, (%rsp)
movsd 0xebf6(%rip), %xmm1     # 0x1d798
callq 0x3360
movapd (%rsp), %xmm1
divsd %xmm0, %xmm1
divsd 0x230(%r15), %xmm1
divsd 0x228(%r15), %xmm1
movsd %xmm1, 0x218(%r15)
ucomisd 0xe5cd(%rip), %xmm1     # 0x1d1a0
seta 0x210(%r15)
ucomisd (%r14), %xmm1
seta 0x211(%r15)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0xeb3f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd9da(%rip), %xmm2     # 0x1d140
movapd %xmm5, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm3, %xmm1
addsd 0x18(%rdi), %xmm1
movsd 0xda29(%rip), %xmm4     # 0x1d1a8
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 0xd9e7(%rip), %xmm4     # 0x1d1c0
andpd %xmm10, %xmm4
movsd 0xdfd1(%rip), %xmm11    # 0x1d7b8
ucomisd %xmm4, %xmm11
jbe 0xf7f7
leaq 0x1a143(%rip), %rax     # 0x29938
jmp 0xf7fe
leaq 0x1a142(%rip), %rax     # 0x29940
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 0xd905(%rip), %xmm6     # 0x1d148
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_O3/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 0x19cdc(%rip), %rax     # 0x29610
movq (%rax), %rbx
leaq 0x1a002(%rip), %r14     # 0x29940
xorl %eax, %eax
movq %rax, (%r14)
leaq 0x19fee(%rip), %r15     # 0x29938
movq %rax, (%r15)
testq %rbx, %rbx
je 0xfa74
movsd 0xd7e2(%rip), %xmm3     # 0x1d140
movsd 0xd842(%rip), %xmm4     # 0x1d1a8
movsd 0xd842(%rip), %xmm5     # 0x1d1b0
xorpd %xmm6, %xmm6
movapd 0xd846(%rip), %xmm7     # 0x1d1c0
movq 0x8(%rbx), %rax
cmpw $0x0, 0x1b0(%rax)
jne 0xfa67
cmpw $0x2, (%rbx)
jg 0xfa67
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 0xf9f8
sqrtsd %xmm0, %xmm0
jmp 0xfa3b
movapd %xmm8, 0x10(%rsp)
movapd %xmm9, (%rsp)
callq 0x31b0
movapd (%rsp), %xmm9
movapd 0x10(%rsp), %xmm8
movapd 0xd7a1(%rip), %xmm7     # 0x1d1c0
xorpd %xmm6, %xmm6
movsd 0xd785(%rip), %xmm5     # 0x1d1b0
movsd 0xd775(%rip), %xmm4     # 0x1d1a8
movsd 0xd705(%rip), %xmm3     # 0x1d140
andpd %xmm7, %xmm9
addsd %xmm0, %xmm9
ucomisd (%r15), %xmm9
jbe 0xfa51
movsd %xmm9, (%r15)
andpd %xmm7, %xmm8
addsd %xmm0, %xmm8
ucomisd (%r14), %xmm8
jbe 0xfa67
movsd %xmm8, (%r14)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0xf97a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfaac
sqrtsd %xmm0, %xmm11
jmp 0xfaba
callq 0x31b0
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm11
movsd (%r15), %xmm0
ucomisd %xmm1, %xmm0
jb 0xface
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0xfae3
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 0xd655(%rip), %xmm5     # 0x1d1a8
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 0xd5c7(%rip), %xmm9     # 0x1d148
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 0xd53e(%rip), %xmm0     # 0x1d140
addsd %xmm4, %xmm0
mulsd %xmm5, %xmm0
mulsd %xmm0, %xmm2
divsd 0xd59a(%rip), %xmm2     # 0x1d1b0
movsd %xmm2, 0x18(%r14)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xfc2c
sqrtsd %xmm0, %xmm0
jmp 0xfc31
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_O3/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 0x18b08(%rip), %rbx     # 0x29610
movq (%rbx), %r14
testq %r14, %r14
je 0x10b43
movq %r14, %r15
movq 0x8(%r15), %rdi
testb $0x1, 0x1b0(%rdi)
jne 0x10b3a
cmpw $0x2, (%r15)
jg 0x10b3a
addq $0x2a0, %rdi            # imm = 0x2A0
movl $0xc0, %edx
xorl %esi, %esi
callq 0x3120
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x10b13
leaq 0x18b36(%rip), %r15     # 0x29680
movq (%r15), %rdi
cmpq %rdi, 0x8(%r15)
je 0x10baf
xorl %r14d, %r14d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r13d, %r13d
addq %r14, %rdi
callq 0xfc44
incq %r13
movq (%r15), %rdi
movq 0x8(%r15), %rax
subq %rdi, %rax
sarq $0x6, %rax
imulq %r12, %rax
addq $0xc0, %r14
cmpq %rax, %r13
jne 0x10b63
movq (%rbx), %r14
jmp 0x10baf
movq 0x8(%r14), %rdi
cmpw $0x0, 0x1b0(%rdi)
jne 0x10bab
cmpw $0x2, (%r14)
jg 0x10bab
callq 0x1068e
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x10b91
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: reflection(double, double, double, double*, pointxy const*, privariables*)
void reflection(double hr, double hg, double vnsolid, double U[4], 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(U[1],U[2]);
    double un1,ut1,un2,ut2;
    un1=ur.dot(ndir);
    ut1=ur.dot(tdir);
    un2=-(hg/hr)*un1;
    ut2=ut1;

    jbugst->q = U[0];
    jbugst->p = U[3];

    //	jbugst->u = (- nxyz->x * nxyz->x + nxyz->y * nxyz->y) * jbu->u
     //  - 2 * nxyz->x * nxyz->y * jbu->v + 2 * nxyz->x * vnsolid;
    //    jbugst->v = - 2 * nxyz->x * nxyz->y * jbu->u + (nxyz->x * nxyz->x - nxyz->y * nxyz->y)* jbu->v 
//        + 2 * nxyz->y * vnsolid; 
    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 0xbf83(%rip), %xmm2     # 0x1d0a0
movaps %xmm2, 0x20(%rsp)
leaq 0x70(%rsp), %r15
movq %r15, %rdi
callq 0xcf30
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
callq 0xcf30
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
leaq 0x50(%rsp), %r13
movq %r13, %rdi
callq 0xcf30
movq %r13, %rdi
movq %r15, %rsi
callq 0xcf3a
movsd %xmm0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0xcf3a
movapd 0x40(%rsp), %xmm3
xorpd 0xbf18(%rip), %xmm3     # 0x1d0a0
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