LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x17e60
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x16faa
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x182c0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x16f51
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movb $0x0, 0x3f(%rsp)
callq 0x17e60
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x16c50
movq $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x17e60
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x17105
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x182c0
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
movq 0x40(%rsp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rsi
callq 0x182c0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x17099
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x1711b
movq 0x28(%rsp), %rdi
callq 0x182e0
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x17e60
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x17328
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17fb0
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x182c0
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x172c1
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movb $0x0, 0x3f(%rsp)
callq 0x17e60
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x16c50
movq $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x17e60
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x17605
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x182c0
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
movq 0x40(%rsp), %rax
subsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rsi
callq 0x182c0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x17599
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x1761b
movq 0x28(%rsp), %rdi
callq 0x182e0
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
movq 0x40(%rsp), %rdi
callq 0x17e60
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x16c50
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x17e60
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
je 0x176ec
movq 0x48(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x17fb0
movsd 0x8(%rsp), %xmm0
movq 0x28(%rsp), %rdi
mulsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rsi
callq 0x182c0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x17674
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x17702
movq 0x28(%rsp), %rdi
callq 0x182e0
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
movq 0x40(%rsp), %rdi
callq 0x17e60
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x16c50
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x17e60
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
je 0x177cc
movq 0x48(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x17fb0
movsd 0x8(%rsp), %xmm0
movq 0x28(%rsp), %rdi
divsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rsi
callq 0x182c0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x17754
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x177e2
movq 0x28(%rsp), %rdi
callq 0x182e0
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
movq 0x40(%rsp), %rdi
callq 0x17e60
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x16c50
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x17e60
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
je 0x17999
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x17fb0
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x17fb0
movsd 0x8(%rsp), %xmm0
movq 0x28(%rsp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rsi
callq 0x182c0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x17914
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x179af
movq 0x28(%rsp), %rdi
callq 0x182e0
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x27453(%rip), %rsi     # 0x3f08d
callq 0x3240
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x17e60
movq %rax, %rcx
movq 0x18(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x17cb3
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x17fb0
movq 0x10(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x3480
movq %rax, %rdi
leaq 0x273f1(%rip), %rsi     # 0x3f08f
callq 0x3240
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x17c48
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x17e60
movq (%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x17fb0
movq 0x8(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x3480
movq %rax, %rdi
leaq 0x27399(%rip), %rsi     # 0x3f091
callq 0x3240
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: jamesliu516[P]amrdg2d/formlist.cpp
// Function: formListForAllGrid()
void formListForAllGrid()
{
	int j,k;
	int flg;
    cellEbools.clear();
		for(j=1; j<=Ny; j++)
		{
			for(k=1; k<=Nx; k++)
			{
			    if(  (k>=adp_begin+1 && k<= Nx-adp_begin)&&(j>=adp_begin+1&& j<= Ny-adp_begin) ){
	                      flg=0;
	                     }
	                  else if( (k<=2||k>=Nx-1) || (j<=2||j>=Ny-1)  ) {
	                         flg=6;
	                    }
	                   else {
	                        flg=2;
	                    }
	                    
			    formListAll(&bodygrid[(j-1)*Nx + k], flg );
			}
		}
        cout<<"all cell list has been formed\n";
}

// Assembly:
subq $0x18, %rsp
leaq 0x35b4d(%rip), %rdi     # 0x50728
callq 0x13330
movl $0x1, 0x14(%rsp)
cmpl $0x41, 0x14(%rsp)
jg 0x1acab
movl $0x1, 0x10(%rsp)
cmpl $0x7b, 0x10(%rsp)
jg 0x1ac99
cmpl $0x8, 0x10(%rsp)
jl 0x1ac2c
cmpl $0x74, 0x10(%rsp)
jg 0x1ac2c
cmpl $0x8, 0x14(%rsp)
jl 0x1ac2c
cmpl $0x3a, 0x14(%rsp)
jg 0x1ac2c
movl $0x0, 0xc(%rsp)
jmp 0x1ac5c
cmpl $0x2, 0x10(%rsp)
jle 0x1ac48
cmpl $0x7a, 0x10(%rsp)
jge 0x1ac48
cmpl $0x2, 0x14(%rsp)
jle 0x1ac48
cmpl $0x40, 0x14(%rsp)
jl 0x1ac52
movl $0x6, 0xc(%rsp)
jmp 0x1ac5a
movl $0x2, 0xc(%rsp)
jmp 0x1ac5c
leaq 0x3070d(%rip), %rax     # 0x4b370
movq (%rax), %rdi
movl 0x14(%rsp), %eax
subl $0x1, %eax
imull $0x7b, %eax, %eax
addl 0x10(%rsp), %eax
cltq
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rax, %rdi
movl 0xc(%rsp), %esi
callq 0x1acd0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1abfb
jmp 0x1ac9b
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1abe8
movq 0x3031e(%rip), %rdi     # 0x4afd0
leaq 0x24787(%rip), %rsi     # 0x3f440
callq 0x3240
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5570
cmpq $0x0, 0x60(%rsp)
je 0x1ae2b
movq 0x60(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x0, %eax
jne 0x1ae2b
movl $0x20, %edi
callq 0x3250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x50d0
jmp 0x1ad23
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x3596d(%rip), %rax     # 0x506a0
cmpq $0x0, (%rax)
jne 0x1ad78
movq 0x50(%rsp), %rcx
leaq 0x3595b(%rip), %rax     # 0x506a0
movq %rcx, (%rax)
movq 0x50(%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x1ad88
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x20, %esi
callq 0x3260
jmp 0x1ae69
movq 0x50(%rsp), %rcx
movq 0x35cfc(%rip), %rax     # 0x50a80
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rax
movq $0x0, 0x10(%rax)
movw 0x5c(%rsp), %cx
movq 0x50(%rsp), %rax
movw %cx, (%rax)
movq 0x60(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x60(%rsp), %rax
movb $0x1, 0x206(%rax)
movq 0x60(%rsp), %rax
movb $0x0, 0x1b4(%rax)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1b400
movq %rdx, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x38(%rsp)
leaq 0x3592e(%rip), %rdi     # 0x50728
leaq 0x30(%rsp), %rsi
callq 0x1b3b0
movq %rax, 0x10(%rsp)
movb %dl, 0x18(%rsp)
movq 0x35c6c(%rip), %rcx     # 0x50a80
movq 0x50(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x35c57(%rip)     # 0x50a80
jmp 0x1ae64
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jge 0x1ae62
movq 0x60(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq 0x258(%rax,%rcx,8), %rdi
movl 0x5c(%rsp), %esi
callq 0x1acd0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1ae33
jmp 0x1ae64
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl 0x2c(%rsp), %eax
jne 0x1b17b
movl $0x18, %edi
callq 0x3250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x1b4d0
jmp 0x1b0df
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x355b8(%rip), %rax     # 0x506a8
cmpq $0x0, (%rax)
jne 0x1b126
movq 0x20(%rsp), %rcx
leaq 0x355a6(%rip), %rax     # 0x506a8
movq %rcx, (%rax)
jmp 0x1b136
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x18, %esi
callq 0x3260
jmp 0x1b180
movq 0x20(%rsp), %rcx
movq 0x35956(%rip), %rax     # 0x50a88
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x35931(%rip), %rcx     # 0x50a88
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x3591c(%rip)     # 0x50a88
movl 0x3591e(%rip), %eax     # 0x50a90
addl $0x1, %eax
movl %eax, 0x35915(%rip)     # 0x50a90
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x3440
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movl $0x0, 0x358f2(%rip)     # 0x50a90
leaq 0x354fb(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1b1ea
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x1b0a0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1b1ad
movq 0x2fddf(%rip), %rdi     # 0x4afd0
leaq 0x24291(%rip), %rsi     # 0x3f489
callq 0x3240
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/formlist.cpp
// Function: initiallevel()
void initiallevel()
{
	Node *currentc;
	OctCell *pc;
	currentc=HeadListAllGrid;
	while(currentc!=NULL)
	{
		pc=currentc->cell;

		pc->level0=pc->level;

		currentc=currentc->next;
	}
}

// Assembly:
leaq 0x35489(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x1b25d
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movw 0x1f8(%rax), %cx
movq -0x10(%rsp), %rax
movw %cx, 0x1fa(%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x1b21f
retq
nop
// File: 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:
subq $0x18, %rsp
leaq 0x35435(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1b2b2
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1b2a6
movq (%rsp), %rdi
movl $0x20, %esi
callq 0x3260
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1b273
movq 0x2fd17(%rip), %rdi     # 0x4afd0
leaq 0x241ef(%rip), %rsi     # 0x3f4af
callq 0x3240
leaq 0x353d4(%rip), %rax     # 0x506a0
movq $0x0, (%rax)
movq $0x0, 0x357a2(%rip) # 0x50a80
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
leaq 0x353ad(%rip), %rax     # 0x506a8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1b342
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1b336
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x3260
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x1b303
leaq 0x3535f(%rip), %rax     # 0x506a8
movq $0x0, (%rax)
movq $0x0, 0x3572d(%rip) # 0x50a88
movq 0x2fc6e(%rip), %rdi     # 0x4afd0
leaq 0x24164(%rip), %rsi     # 0x3f4cd
callq 0x3240
movq %rax, %rdi
movl 0x35719(%rip), %esi     # 0x50a90
callq 0x3420
movq %rax, %rdi
movq 0x2fc32(%rip), %rsi     # 0x4afb8
callq 0x3290
movq 0x2fc3e(%rip), %rdi     # 0x4afd0
leaq 0x2414f(%rip), %rsi     # 0x3f4e8
callq 0x3240
movl $0x0, 0x356e8(%rip)     # 0x50a90
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movl 0x24(%rsp), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x1c856
movq (%rsp), %rax
leaq 0x22da9(%rip), %rcx     # 0x3f5b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
jmp 0x1c856
movl $0x1, 0xc(%rsp)
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
jmp 0x1c856
movl $0x1, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
jmp 0x1c856
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movl $0x1, 0x8(%rsp)
movq 0x28(%rsp), %rax
movswl 0x1f8(%rax), %eax
addl $0x1, %eax
movw %ax, %cx
movq 0x30(%rsp), %rax
movw %cx, 0x1f8(%rax)
movq 0x28(%rsp), %rax
movl 0x200(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x200(%rax)
movl 0x24(%rsp), %eax
movw %ax, %cx
movq 0x30(%rsp), %rax
movw %cx, 0x204(%rax)
movq 0x28(%rsp), %rax
movw 0x1fa(%rax), %cx
movq 0x30(%rsp), %rax
movw %cx, 0x1fa(%rax)
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x250(%rax)
movsd 0x18(%rsp), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x288(%rax)
movsd 0x10(%rsp), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x290(%rax)
movq 0x30(%rsp), %rdi
callq 0x5010
movq 0x28(%rsp), %rax
movsd 0x278(%rax), %xmm1
cvtsi2sdl 0xc(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd 0x22829(%rip), %xmm2    # 0x3f140
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x278(%rax)
movq 0x28(%rsp), %rax
movsd 0x280(%rax), %xmm1
cvtsi2sdl 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd 0x227f3(%rip), %xmm2    # 0x3f140
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x280(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x1c9f6
movq (%rsp), %rax
leaq 0x22c19(%rip), %rcx     # 0x3f5c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
jmp 0x1c9f6
movl $0x1, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
jmp 0x1c9f6
movl $0x1, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
jmp 0x1c9f6
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movl $0x1, 0xc(%rsp)
movq 0x28(%rsp), %rax
movswl 0x1f8(%rax), %eax
addl $0x1, %eax
movw %ax, %cx
movq 0x30(%rsp), %rax
movw %cx, 0x1f8(%rax)
movq 0x28(%rsp), %rax
movl 0x200(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x200(%rax)
movq 0x28(%rsp), %rax
movw 0x1fa(%rax), %cx
movq 0x30(%rsp), %rax
movw %cx, 0x1fa(%rax)
movl 0x14(%rsp), %eax
movw %ax, %cx
movq 0x30(%rsp), %rax
movw %cx, 0x204(%rax)
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x250(%rax)
movsd 0x20(%rsp), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x288(%rax)
movsd 0x18(%rsp), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x290(%rax)
movq 0x30(%rsp), %rdi
callq 0x5010
movq 0x28(%rsp), %rax
movsd 0x278(%rax), %xmm1
cvtsi2sdl 0x10(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd 0x22689(%rip), %xmm2    # 0x3f140
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x278(%rax)
movq 0x28(%rsp), %rax
movsd 0x280(%rax), %xmm1
cvtsi2sdl 0xc(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd 0x22653(%rip), %xmm2    # 0x3f140
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x280(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movswl 0x1fc(%rax), %eax
movl %eax, 0x58(%rsp)
cmpl $0x1, 0x58(%rsp)
jne 0x1cb35
jmp 0x1cc35
movq 0x60(%rsp), %rax
movsd 0x225fe(%rip), %xmm0    # 0x3f140
mulsd 0x288(%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rax
movsd 0x225e3(%rip), %xmm0    # 0x3f140
mulsd 0x290(%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movl $0x0, 0x5c(%rsp)
cmpl $0x4, 0x5c(%rsp)
jge 0x1cc33
movl $0x360, %edi            # imm = 0x360
callq 0x3250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
callq 0x52b0
jmp 0x1cba6
movq 0x8(%rsp), %rcx
movslq 0x5c(%rsp), %rax
movq %rcx, 0x20(%rsp,%rax,8)
movslq 0x5c(%rsp), %rax
movq 0x20(%rsp,%rax,8), %rdx
movq 0x60(%rsp), %rax
movslq 0x5c(%rsp), %rcx
movq %rdx, 0x258(%rax,%rcx,8)
movslq 0x5c(%rsp), %rax
movq 0x20(%rsp,%rax,8), %rdi
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
callq 0x1c7d0
movslq 0x5c(%rsp), %rax
movq 0x20(%rsp,%rax,8), %rdi
callq 0x1bfe0
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x1cb73
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x360, %esi            # imm = 0x360
callq 0x3260
jmp 0x1cc3a
jmp 0x1cc35
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3150
cmpl $0x1, 0x5c(%rsp)
jl 0x1cfab
movq 0x60(%rsp), %rax
movw $0x1, 0x1fc(%rax)
movq 0x60(%rsp), %rax
movsd 0x2228c(%rip), %xmm0    # 0x3f140
mulsd 0x288(%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rax
movsd 0x22271(%rip), %xmm0    # 0x3f140
mulsd 0x290(%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0x1cfa9
movl $0x360, %edi            # imm = 0x360
callq 0x3250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
callq 0x52b0
jmp 0x1cf17
movq (%rsp), %rcx
movslq 0x1c(%rsp), %rax
movq %rcx, 0x20(%rsp,%rax,8)
movslq 0x1c(%rsp), %rax
movq 0x20(%rsp,%rax,8), %rdx
movq 0x60(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq %rdx, 0x258(%rax,%rcx,8)
movslq 0x1c(%rsp), %rax
movq 0x20(%rsp,%rax,8), %rdi
movq 0x60(%rsp), %rsi
movl 0x1c(%rsp), %edx
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
callq 0x1c7d0
movslq 0x1c(%rsp), %rax
movq 0x20(%rsp,%rax,8), %rdi
movl 0x5c(%rsp), %esi
subl $0x1, %esi
callq 0x1ce70
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1cee5
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x360, %esi            # imm = 0x360
callq 0x3260
jmp 0x1cfb2
jmp 0x1cfad
jmp 0x1cfad
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x3440
nopl (%rax)
// File: 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, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm1
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
retq
nopl (%rax)
// File: jamesliu516[P]amrdg2d/vec2d.cpp
// Function: Vec2D::operator=(Vec2D const&)
Vec2D &Vec2D::operator= (const Vec2D &right) {
	comp[0]=right.comp[0];
	comp[1]=right.comp[1];
//	comp[2]=right.comp[2];
	return *this;
}

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x1e1a0
movq (%rsp), %rax
movsd (%rax), %xmm0
movq 0x8(%rsp), %rcx
movsd (%rcx), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: jamesliu516[P]amrdg2d/vec2d.cpp
// Function: Vec2D::operator+=(Vec2D const&)
Vec2D &Vec2D::operator+= (const Vec2D &right) {
	comp[0]+=right.comp[0];
	comp[1]+=right.comp[1];
//	comp[2]+=right.comp[2];
	return *this;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/vec2d.cpp
// Function: operator*(double const&, Vec2D const&)
Vec2D operator*(const double &left, const Vec2D &right) {
	Vec2D 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:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x1e1a0
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movq 0x8(%rsp), %rax
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: jamesliu516[P]amrdg2d/vec2d.cpp
// Function: operator+(Vec2D const&, Vec2D const&)
Vec2D operator+ (const Vec2D &left, const Vec2D &right) {
	Vec2D 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:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x1e1a0
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
movq 0x8(%rsp), %rax
movsd (%rax), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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 %xmm0, -0x8(%rsp)
movsd %xmm1, -0x10(%rsp)
movq %rdi, -0x18(%rsp)
movl %esi, -0x1c(%rsp)
cmpl $0x6, -0x1c(%rsp)
jne 0x1f58b
movq -0x18(%rsp), %rax
movsd (%rax), %xmm1
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd -0x8(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movsd 0x10(%rax), %xmm1
movsd -0x10(%rsp), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x18(%rsp), %rax
movsd 0x18(%rax), %xmm0
mulsd -0x8(%rsp), %xmm0
movsd -0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movsd 0x20(%rax), %xmm1
movsd -0x8(%rsp), %xmm2
movsd -0x8(%rsp), %xmm3
mulsd %xmm3, %xmm2
movsd 0x201e7(%rip), %xmm3    # 0x3f730
addsd %xmm3, %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x18(%rsp), %rax
movsd 0x28(%rax), %xmm0
movsd -0x10(%rsp), %xmm2
movsd -0x10(%rsp), %xmm3
mulsd %xmm3, %xmm2
movsd 0x201b9(%rip), %xmm3    # 0x3f730
addsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
jmp 0x1f5ed
cmpl $0x3, -0x1c(%rsp)
jne 0x1f5d3
movq -0x18(%rsp), %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm1
movsd -0x8(%rsp), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x18(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd -0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
jmp 0x1f5eb
cmpl $0x1, -0x1c(%rsp)
jne 0x1f5e9
movq -0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rsp)
jmp 0x1f5eb
jmp 0x1f5ed
movsd -0x28(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: 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 %xmm0, -0x8(%rsp)
movsd %xmm1, -0x10(%rsp)
movsd %xmm2, -0x18(%rsp)
movsd %xmm3, -0x20(%rsp)
movsd %xmm4, -0x28(%rsp)
movsd %xmm5, -0x30(%rsp)
movq %rdi, -0x38(%rsp)
movl %esi, -0x3c(%rsp)
cmpl $0x6, -0x3c(%rsp)
jne 0x1f796
movq -0x38(%rsp), %rax
movsd (%rax), %xmm0
movq -0x38(%rsp), %rax
movsd 0x1fa52(%rip), %xmm1    # 0x3f0a0
mulsd 0x8(%rax), %xmm1
movsd -0x8(%rsp), %xmm2
subsd -0x18(%rsp), %xmm2
mulsd %xmm2, %xmm1
divsd -0x28(%rsp), %xmm1
addsd %xmm1, %xmm0
movq -0x38(%rsp), %rax
movsd 0x1fa26(%rip), %xmm1    # 0x3f0a0
mulsd 0x10(%rax), %xmm1
movsd -0x10(%rsp), %xmm2
subsd -0x20(%rsp), %xmm2
mulsd %xmm2, %xmm1
divsd -0x30(%rsp), %xmm1
addsd %xmm1, %xmm0
movq -0x38(%rsp), %rax
movsd 0x2009a(%rip), %xmm1    # 0x3f740
mulsd 0x18(%rax), %xmm1
movsd -0x8(%rsp), %xmm2
subsd -0x18(%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd -0x10(%rsp), %xmm2
subsd -0x20(%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd -0x28(%rsp), %xmm2
mulsd -0x30(%rsp), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movq -0x38(%rsp), %rax
movsd 0x20(%rax), %xmm1
movsd -0x8(%rsp), %xmm2
subsd -0x18(%rsp), %xmm2
movsd -0x8(%rsp), %xmm3
subsd -0x18(%rsp), %xmm3
mulsd %xmm3, %xmm2
movsd 0x20033(%rip), %xmm3    # 0x3f740
mulsd %xmm3, %xmm2
movsd -0x28(%rsp), %xmm3
mulsd -0x28(%rsp), %xmm3
divsd %xmm3, %xmm2
movsd 0x2000f(%rip), %xmm3    # 0x3f738
subsd %xmm3, %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x38(%rsp), %rax
movsd 0x28(%rax), %xmm0
movsd -0x10(%rsp), %xmm2
subsd -0x20(%rsp), %xmm2
movsd -0x10(%rsp), %xmm3
subsd -0x20(%rsp), %xmm3
mulsd %xmm3, %xmm2
movsd 0x1ffdd(%rip), %xmm3    # 0x3f740
mulsd %xmm3, %xmm2
movsd -0x30(%rsp), %xmm3
mulsd -0x30(%rsp), %xmm3
divsd %xmm3, %xmm2
movsd 0x1ffb9(%rip), %xmm3    # 0x3f738
subsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rsp)
jmp 0x1f820
cmpl $0x3, -0x3c(%rsp)
jne 0x1f806
movq -0x38(%rsp), %rax
movsd (%rax), %xmm0
movq -0x38(%rsp), %rax
movsd 0x1f8ed(%rip), %xmm1    # 0x3f0a0
mulsd 0x8(%rax), %xmm1
movsd -0x8(%rsp), %xmm2
subsd -0x18(%rsp), %xmm2
mulsd %xmm2, %xmm1
divsd -0x28(%rsp), %xmm1
addsd %xmm1, %xmm0
movq -0x38(%rsp), %rax
movsd 0x1f8c1(%rip), %xmm1    # 0x3f0a0
mulsd 0x10(%rax), %xmm1
movsd -0x10(%rsp), %xmm2
subsd -0x20(%rsp), %xmm2
mulsd %xmm2, %xmm1
divsd -0x30(%rsp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rsp)
jmp 0x1f81e
cmpl $0x1, -0x3c(%rsp)
jne 0x1f81c
movq -0x38(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rsp)
jmp 0x1f81e
jmp 0x1f820
movsd -0x48(%rsp), %xmm0
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
callq 0x233d0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f23d(%rip), %rdi     # 0x50710
callq 0x13310
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x2150e
movq 0x10(%rsp), %rsi
leaq 0x2f21f(%rip), %rdi     # 0x50710
callq 0x13340
movq %rax, %rdi
callq 0x1fa90
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x214c2
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
leaq 0x2ed95(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x21a8c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl $0x0, %eax
jne 0x21a79
movq 0x20(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x21a79
movq 0x18(%rsp), %rax
movsd 0x288(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd 0x288(%rax), %xmm2
movq 0x18(%rsp), %rax
movsd 0x290(%rax), %xmm1
movq 0x18(%rsp), %rax
mulsd 0x290(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x31c0
movaps %xmm0, %xmm1
movsd 0x1d7a1(%rip), %xmm0    # 0x3f140
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd 0x220(%rax), %xmm0
movaps 0x1d843(%rip), %xmm1    # 0x3f200
pand %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x1dd7b(%rip), %xmm1    # 0x3f750
callq 0x3430
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
movq 0x18(%rsp), %rax
divsd 0x230(%rax), %xmm0
movq 0x18(%rsp), %rax
divsd 0x228(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x218(%rax)
movq 0x18(%rsp), %rax
movsd 0x218(%rax), %xmm0
movsd 0x1d635(%rip), %xmm1    # 0x3f058
ucomisd %xmm1, %xmm0
jbe 0x21a37
movq 0x18(%rsp), %rax
movb $0x1, 0x210(%rax)
jmp 0x21a43
movq 0x18(%rsp), %rax
movb $0x0, 0x210(%rax)
movq 0x18(%rsp), %rax
movsd 0x218(%rax), %xmm0
leaq 0x29849(%rip), %rax     # 0x4b2a0
ucomisd (%rax), %xmm0
jbe 0x21a6b
movq 0x18(%rsp), %rax
movb $0x1, 0x211(%rax)
jmp 0x21a77
movq 0x18(%rsp), %rax
movb $0x0, 0x211(%rax)
jmp 0x21a79
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x21913
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rsp), %rax
divsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rsp), %rax
divsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rsp), %rax
movsd 0x18(%rax), %xmm1
movq -0x8(%rsp), %rax
movsd 0x1d603(%rip), %xmm0    # 0x3f140
mulsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm2
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm4
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm3
movq -0x10(%rsp), %rax
mulsd 0x10(%rax), %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x1d650(%rip), %xmm1    # 0x3f1e8
mulsd %xmm1, %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x18(%rax)
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
leaq 0x2d2c5(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x60(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6530
leaq 0x10(%rsp), %rdi
callq 0x21aa0
leaq 0x2d5d2(%rip), %rax     # 0x509d0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0x2d5bc(%rip), %rax     # 0x509c8
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
cmpq $0x0, 0x60(%rsp)
je 0x23563
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl $0x0, %eax
jne 0x23550
movq 0x60(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x23550
movq 0x58(%rsp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x58(%rsp), %rax
movsd 0x60(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x58(%rsp), %rax
movsd 0x90(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x58(%rsp), %rax
movsd 0xc0(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x21ad0
movsd 0x1bd28(%rip), %xmm0    # 0x3f1d8
mulsd 0x48(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
callq 0x31c0
movsd %xmm0, 0x50(%rsp)
movsd 0x38(%rsp), %xmm0
movaps 0x1bd2c(%rip), %xmm1    # 0x3f200
pand %xmm1, %xmm0
addsd 0x50(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x40(%rsp), %xmm0
movaps 0x1bd10(%rip), %xmm1    # 0x3f200
pand %xmm1, %xmm0
addsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x2d4c1(%rip), %rax     # 0x509c8
movsd (%rax), %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x23526
movsd (%rsp), %xmm0
leaq 0x2d4a6(%rip), %rax     # 0x509c8
movsd %xmm0, (%rax)
leaq 0x2d4a3(%rip), %rax     # 0x509d0
movsd (%rax), %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2354e
movsd 0x8(%rsp), %xmm0
leaq 0x2d486(%rip), %rax     # 0x509d0
movsd %xmm0, (%rax)
jmp 0x23550
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x60(%rsp)
jmp 0x23413
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: jamesliu516[P]amrdg2d/./non_uniform_grid.h
// Function: jbblToShbl(privariables*, conservedvariables*)
inline void jbblToShbl(JBBL *jbu, SHBL *ush)
{
    ush->q=jbu->q;
    ush->qu=jbu->u * jbu->q;
    ush->qv=jbu->v * jbu->q;

    ush->te=jbu->p/GAM11+ 0.5 * ush->q * ( jbu->u * jbu->u
        + jbu->v * jbu->v );

}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rsp), %rax
mulsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rsp), %rax
mulsd (%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rsp), %rax
movsd 0x18(%rax), %xmm1
movsd 0x1bc10(%rip), %xmm0    # 0x3f1e8
divsd %xmm0, %xmm1
movq -0x10(%rsp), %rax
movsd 0x1bb57(%rip), %xmm0    # 0x3f140
mulsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm2
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm4
movq -0x8(%rsp), %rax
movsd 0x10(%rax), %xmm3
movq -0x8(%rsp), %rax
mulsd 0x10(%rax), %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x18(%rax)
retq