LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/background_grid.cpp
// Function: load_grid()
void load_grid()
{
	int iy,ix;

	ifstream infile;
	infile.open(GRID_FILE);

	for(ix=1; ix < NPOINT+1; ix++)
		infile >> gpoint[ix].x >> gpoint[ix].y;

	for(ix=1; ix < NCELL+1; ix++)
		for(iy=0; iy<4; iy++) 
			infile >> gcell[ix].pn[iy];
        
	//for(iy=1; iy<=Ny4grd+2; iy++)
	for(iy=1; iy<=Ny; iy++)
	{
	//	for(ix=1; ix<=Nx4grd+2; ix++)
	for(ix=1; ix<=Nx; ix++)
		{
			//bgrid[iy-1][ix-1]=gcell[(ix-1)*(Ny4grd+2)+Ny4grd+2-(iy-1)];
			bgrid[iy-1][ix-1]=gcell[(ix-1)*Ny+Ny-(iy-1)];
		}
	}
	infile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3240
leaq 0x19b75(%rip), %rsi     # 0x1e088
movq %rbx, %rdi
movl $0x8, %edx
callq 0x3140
movl $0x18, %r14d
movq %rsp, %rbx
movq 0x20d70(%rip), %rax     # 0x252a0
leaq (%rax,%r14), %rsi
addq $-0x8, %rsi
movq %rbx, %rdi
callq 0x3150
movq 0x20d59(%rip), %rsi     # 0x252a0
addq %r14, %rsi
movq %rax, %rdi
callq 0x3150
addq $0x10, %r14
cmpq $0x150618, %r14         # imm = 0x150618
jne 0x4529
movl $0x1, %r14d
movl $0x10, %r15d
movq %rsp, %rbx
xorl %r12d, %r12d
movq 0x20d30(%rip), %rsi     # 0x252a8
addq %r15, %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x3130
addq $0x4, %r12
cmpq $0x10, %r12
jne 0x4571
incq %r14
addq $0x10, %r15
cmpq $0x14e17, %r14          # imm = 0x14E17
jne 0x456e
movq 0x20cf1(%rip), %rax     # 0x25298
movl $0x410, %ecx            # imm = 0x410
addq 0x20cf5(%rip), %rcx     # 0x252a8
movl $0x1, %edx
movq $-0x7b0, %rsi           # imm = 0xF850
movq %rcx, %rdi
movups (%rdi), %xmm0
movups %xmm0, 0x7b0(%rax,%rsi)
addq $0x410, %rdi            # imm = 0x410
addq $0x10, %rsi
jne 0x45c2
incq %rdx
addq $-0x10, %rcx
addq $0x7b0, %rax            # imm = 0x7B0
cmpq $0x42, %rdx
jne 0x45b8
movq %rsp, %rdi
callq 0x3070
movq %rsp, %rdi
callq 0x3080
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4610
jmp 0x4610
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3370
nop
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/bodygridclass.cpp
// Function: bodygridclass::bodygridclass(double, double)
bodygridclass::bodygridclass(double hhx, double hhy)
{
    //   pmvx=NULL;
    //   pmvy=NULL;

    flag=0;
    exflag=-1;
    level=0;//�������ڵĲ��� 
    reflag=0;//�Ƿ�����;0-δ����,1-�Ѽ���
    coflag=false;//�ж������Ƿ��ֻ���0-δ�ֻ�,1-�Ѵֻ�
    NOparent=0u;//��ʼ����������
    NOchildren=0;//��������Ԫ���������еı���
    parent=NULL; 
    bAvg=false;
    tcur=0.0; 
    tdiv=0.0;
    pio=0.0;
    trb=false;
    trbamr=false;
    kxq=kxrcf=0.0;
    maxqp=inlen=0.0;
    mvflg=false;
    vorM=0.0;
    //	struct bodygrid *children[4];

   // p_node=NULL;
    for(int m=0; m<4; ++m)  children[m]=NULL;

    for(int i=0; i<4; i++) { 
        for(int j=0; j<6; j++){
#ifdef RES_SMOOTH
            resd0[i][j]=resd1[i][j]=0.0;
#endif
            residual[i][j]=dof[i][j]=dof0[i][j]=0.0;
        }
    }
    set_invM(hhx,hhy);
}

// Assembly:
movl $0xffff0000, 0x1b0(%rdi) # imm = 0xFFFF0000
xorl %eax, %eax
movw %ax, 0x1f8(%rdi)
movw %ax, 0x1fc(%rdi)
movb %al, 0x1fe(%rdi)
movl $0x0, 0x200(%rdi)
movw %ax, 0x204(%rdi)
movb %al, 0x206(%rdi)
movw %ax, 0x210(%rdi)
movb %al, 0x1b4(%rdi)
movq $0x0, 0x208(%rdi)
xorps %xmm2, %xmm2
movups %xmm2, 0x218(%rdi)
movups %xmm2, 0x228(%rdi)
movups %xmm2, 0x238(%rdi)
movups %xmm2, 0x248(%rdi)
movups %xmm2, 0x258(%rdi)
movups %xmm2, 0x268(%rdi)
leaq 0x30(%rdi), %rcx
xorl %edx, %edx
movups %xmm2, 0xc0(%rcx,%rdx,8)
movups %xmm2, (%rcx,%rdx,8)
movups %xmm2, 0x270(%rcx,%rdx,8)
addq $0x2, %rdx
cmpq $0x6, %rdx
jne 0x476a
incq %rax
addq $0x30, %rcx
cmpq $0x4, %rax
jne 0x4768
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd 0x198af(%rip), %xmm2    # 0x1e050
divpd %xmm0, %xmm2
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
movhpd %xmm2, 0x10(%rdi)
movapd 0x198a2(%rip), %xmm2    # 0x1e060
divpd %xmm0, %xmm2
divpd %xmm1, %xmm2
movupd %xmm2, 0x18(%rdi)
movhpd %xmm2, 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: Vec3D::cross(Vec3D const&)
Vec3D Vec3D::cross(const Vec3D &right) {
	Vec3D temp;
	temp.comp[0]=comp[1]*right.comp[2]-comp[2]*right.comp[1];
	temp.comp[1]=-comp[0]*right.comp[2]+comp[2]*right.comp[0];
	temp.comp[2]=comp[0]*right.comp[1]-comp[1]*right.comp[0];
	return temp;
}

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
movapd 0x197d0(%rip), %xmm2    # 0x1e0a0
movsd 0x10(%rsi), %xmm3
movapd %xmm3, %xmm4
xorpd %xmm2, %xmm4
xorpd %xmm0, %xmm2
movupd (%rdx), %xmm5
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
mulpd %xmm5, %xmm3
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
movsd 0x10(%rdx), %xmm4
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm2, %xmm4
addpd %xmm3, %xmm4
shufpd $0x1, %xmm4, %xmm4      # xmm4 = xmm4[1,0]
movupd %xmm4, (%rdi)
mulsd %xmm5, %xmm1
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
mulsd %xmm0, %xmm5
subsd %xmm1, %xmm5
movsd %xmm5, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: Vec3D::operator/=(double const&)
Vec3D &Vec3D::operator/= (const double &right) {
	comp[0]/=right;
	comp[1]/=right;
	comp[2]/=right;
	return *this;
}

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

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

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movsd (%rdx), %xmm0
movupd (%rsi), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
mulsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: operator*(double const&, Vec3D const&)
Vec3D operator*(const double &left, const Vec3D &right) {
	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:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movsd (%rsi), %xmm0
movupd (%rdx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
mulsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: operator/(double const&, Vec3D const&)
Vec3D operator/ (const double &left, const Vec3D &right) {
	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:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movsd (%rsi), %xmm0
movupd (%rdx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm1, %xmm2
movupd %xmm2, (%rdi)
divsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec3d.cpp
// Function: operator+(Vec3D const&, Vec3D const&)
Vec3D operator+ (const Vec3D &left, const Vec3D &right) {
	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:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movupd (%rsi), %xmm0
movupd (%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
movsd 0x10(%rsi), %xmm0
addsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/setflag.cpp
// Function: set_exFlag4All(int, pointxy*)
void set_exFlag4All(int nmpnt, PXYZ wallpt[]) 
{
    Node *current;
    OctCell *lsbl;
    OctCell *lsbl1[4];
    double x1,y1;
    int value, flg=0;

    double xcn[4],ycn[4];
    int flgn[4], sflg;	

    current = HeadListAllGrid;
    while(current != NULL)
    {
        lsbl = current->cell;

        x1=lsbl->xc1;
        y1=lsbl->yc1;
        flg=0;

        value = newFlagpoint(x1,y1,nmpnt, wallpt);
        if(value==0 ) {
            flg=-1;
            lsbl->flag=-1; ///
        }
        lsbl->exflag=flg;
        current=current->next;
    }
    //cout<<"it is ok\n";

    current = HeadListAllGrid;
    while(current != NULL)
    {
        lsbl = current->cell;
        if(lsbl->exflag==-1){
            if(current->flg!=6)
            {
                //-----------------------
                lsbl1[0]=SouthNeighbor(lsbl);
                lsbl1[1]=EastNeighbor(lsbl);	
                lsbl1[2]=NorthNeighbor(lsbl);
                lsbl1[3]=WestNeighbor(lsbl);	        
                sflg=0;
                for(int i=0; i<4; ++i) {      
                    if(lsbl1[i]->exflag==0) {
                        flg=2;
                        ++sflg;
                        break;
                    }
                }  

                if(sflg==0) flg=-1;      
                lsbl->exflag=flg;
            }
        }
        current=current->next;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x25530(%rip), %r14     # 0x2a610
movq (%r14), %r15
testq %r15, %r15
je 0x5138
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%r15), %r12
movsd 0x278(%r12), %xmm0
movsd 0x280(%r12), %xmm1
movl %ebp, %edi
movq %rbx, %rsi
callq 0xa82f
testl %eax, %eax
je 0x5117
xorl %eax, %eax
jmp 0x5126
movw $0xffff, 0x1b0(%r12) # imm = 0xFFFF
movw $0xffff, %ax            # imm = 0xFFFF
movw %ax, 0x1b2(%r12)
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x50ed
movq (%r14), %r14
testq %r14, %r14
je 0x51b8
movq 0x8(%r14), %rbx
cmpw $-0x1, 0x1b2(%rbx)
jne 0x51b2
cmpw $0x6, (%r14)
je 0x51b2
movq %rbx, %rdi
callq 0x8f00
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x8e7f
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x8d78
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0x8dfc
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movq (%rsp,%rax,8), %rcx
cmpw $0x0, 0x1b2(%rcx)
je 0x51a7
incq %rax
cmpq $0x4, %rax
jne 0x518a
movw $0xffff, %ax            # imm = 0xFFFF
jmp 0x51ab
movw $0x2, %ax
movw %ax, 0x1b2(%rbx)
movq 0x10(%r14), %r14
jmp 0x513b
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec4d.cpp
// Function: Vec4D::Vec4D(double, double, double, double)
Vec4D::Vec4D(double x, double y, double z, double r) {
	comp[0]=x;
	comp[1]=y;
	comp[2]=z;
       comp[3]=r;
}

// Assembly:
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd %xmm2, 0x10(%rdi)
movsd %xmm3, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec4d.cpp
// Function: Vec4D::operator/=(double const&)
Vec4D &Vec4D::operator/= (const double &right) {
	comp[0]/=right;
	comp[1]/=right;
	comp[2]/=right;
	comp[3]/=right;	
	return *this;
}

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

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

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movupd (%rsi), %xmm0
movsd (%rdx), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm1, %xmm0
movupd %xmm0, (%rdi)
movupd 0x10(%rsi), %xmm0
mulpd %xmm1, %xmm0
movupd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec4d.cpp
// Function: Vec4D::operator/(double const&)
Vec4D Vec4D::operator/ (const double &right) {
	Vec4D temp;
	temp.comp[0]=comp[0]/right;
	temp.comp[1]=comp[1]/right;
	temp.comp[2]=comp[2]/right;
	temp.comp[3]=comp[3]/right;	
	
	return temp;
}

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movupd (%rsi), %xmm0
movsd (%rdx), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm0
movupd %xmm0, (%rdi)
movupd 0x10(%rsi), %xmm0
divpd %xmm1, %xmm0
movupd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec4d.cpp
// Function: Vec4D::operator+=(Vec4D const&)
Vec4D &Vec4D::operator+= (const Vec4D &right) {
	comp[0]+=right.comp[0];
	comp[1]+=right.comp[1];
	comp[2]+=right.comp[2];
	comp[3]+=right.comp[3];	
	return *this;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
addsd (%rdi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
addsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rsi), %xmm0
addsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec4d.cpp
// Function: operator*(double const&, Vec4D const&)
Vec4D operator*(const double &left, const Vec4D &right) {
	Vec4D temp;
	temp.comp[0]=left*right.comp[0];
	temp.comp[1]=left*right.comp[1];
	temp.comp[2]=left*right.comp[2];
	temp.comp[3]=left*right.comp[3];
	return temp;
}

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movupd (%rdx), %xmm0
movsd (%rsi), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm1, %xmm0
movupd %xmm0, (%rdi)
movupd 0x10(%rdx), %xmm0
mulpd %xmm1, %xmm0
movupd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/vec4d.cpp
// Function: operator+(Vec4D const&, Vec4D const&)
Vec4D operator+ (const Vec4D &left, const Vec4D &right) {
	Vec4D 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];
	temp.comp[3]=left.comp[3]+right.comp[3];
	return temp;
}

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movupd (%rsi), %xmm0
movupd (%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%rdi)
movupd 0x10(%rsi), %xmm0
movupd 0x10(%rdx), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/outputgrid.cpp
// Function: output4restart()
void output4restart()
{
    Node *current;
    int i;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    ofstream fp1;

	string  str1=str0+"restart_data";
    fp1.open(str1.c_str());
    current = HeadListAllGrid;     
    while(current != NULL)
    {       
        pcell0 = current->cell;
        for(i=0;i<4;++i) fp1<<pcell0->dof[i][0]<<"  ";
        fp1<<"\n";
        current = current->next;
    }           
    fp1.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
leaq 0x28(%rsp), %rdi
callq 0x3340
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x21eba(%rip), %rax     # 0x2a8a0
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x8c58
leaq 0x1594e(%rip), %rsi     # 0x1e34f
leaq 0x8(%rsp), %rdi
callq 0x3390
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movl $0x10, %edx
callq 0x3050
leaq 0x21bea(%rip), %rax     # 0x2a610
movq (%rax), %r13
testq %r13, %r13
je 0x8a90
leaq 0x28(%rsp), %rbx
leaq 0x163bb(%rip), %r14     # 0x1edf5
leaq 0x15879(%rip), %r15     # 0x1e2ba
movq 0x8(%r13), %rbp
movl $0x30, %r12d
movsd (%rbp,%r12), %xmm0
movq %rbx, %rdi
callq 0x3300
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3250
addq $0x30, %r12
cmpq $0xf0, %r12
jne 0x8a4b
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3250
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x8a41
leaq 0x28(%rsp), %rdi
callq 0x32a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8ab6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
movq 0x1c4fb(%rip), %rax     # 0x24fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x31d0
leaq 0x120(%rsp), %rdi
callq 0x30b0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8b05
movq %rax, %rbx
jmp 0x8b24
jmp 0x8b05
jmp 0x8b05
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8b24
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
leaq 0x28(%rsp), %rdi
callq 0x32c0
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/outputgrid.cpp
// Function: read4restart()
void read4restart()
{
    Node *current;
    int i,j;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    ifstream fp1;
    fp1.open("IN//restart_data");
    current = HeadListAllGrid;     
    while(current != NULL)
    {       
        pcell0 = current->cell;
        for(i=0;i<4;++i){
            fp1>>pcell0->dof[i][0];
            pcell0->dof0[i][0]=pcell0->dof[i][0];
            for(j=1;j<nDOF;++j)
                pcell0->dof[i][j]=0.0;
        }

        current = current->next;
    }           
    fp1.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3240
leaq 0x157f5(%rip), %rsi     # 0x1e34b
movq %rbx, %rdi
movl $0x8, %edx
callq 0x3140
leaq 0x21aa6(%rip), %rax     # 0x2a610
movq (%rax), %r14
testq %r14, %r14
je 0x8bc9
movq %rsp, %rbx
movq 0x8(%r14), %r15
movl $0x30, %r12d
leaq (%r15,%r12), %rsi
movq %rbx, %rdi
callq 0x3150
movsd (%r15,%r12), %xmm0
movsd %xmm0, 0xc0(%r15,%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15,%r12)
movups %xmm0, 0x18(%r15,%r12)
movq $0x0, 0x28(%r15,%r12)
addq $0x30, %r12
cmpq $0xf0, %r12
jne 0x8b7f
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x8b75
movq %rsp, %rdi
callq 0x3070
movq %rsp, %rdi
callq 0x3080
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8bea
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: NorthNeighbor(bodygridclass*)
OctCell *NorthNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;
	if(parent==NULL) 
	{
		return(&bodygrid[NOparent+Nx]);
	}
	
	NOchildren=pp->NOchildren;
	if(NOchildren==0) return(parent->children[3]);
    if(NOchildren==1) return(parent->children[2]);
    p=NorthNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==3) return(p->children[0]);
	else if(NOchildren==2) return(p->children[1]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x8da6
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x8da9
movzwl 0x204(%rax), %ebx
cmpl $0x1, %ebx
je 0x8dcb
testl %ebx, %ebx
jne 0x8dd4
movq 0x270(%rdi), %rax
jmp 0x8dfa
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1c52a(%rip), %rcx     # 0x252e0
movq (%rcx), %rcx
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rcx, %rax
addq $0x19f20, %rax          # imm = 0x19F20
jmp 0x8dfa
movq 0x268(%rdi), %rax
jmp 0x8dfa
callq 0x8d78
movq %rax, %rcx
movq 0x258(%rax), %rax
testq %rax, %rax
je 0x8df7
cmpw $0x3, %bx
je 0x8dfa
movq 0x260(%rcx), %rax
jmp 0x8dfa
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: WestNeighbor(bodygridclass*)
OctCell *WestNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;

	if(parent==NULL) return(&bodygrid[NOparent-1]);	

	NOchildren=pp->NOchildren;
	if(NOchildren==1) return(parent->children[0]);
    if(NOchildren==2) return(parent->children[3]);
    p=WestNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==0) return(p->children[1]);
	else if(NOchildren==3) return(p->children[2]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x8e2b
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x8e2e
movzwl 0x204(%rax), %ebx
cmpl $0x2, %ebx
je 0x8e50
cmpl $0x1, %ebx
jne 0x8e59
movq 0x258(%rdi), %rax
jmp 0x8e7d
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1c4a5(%rip), %rcx     # 0x252e0
movq (%rcx), %rcx
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rcx, %rax
addq $-0x360, %rax           # imm = 0xFCA0
jmp 0x8e7d
movq 0x270(%rdi), %rax
jmp 0x8e7d
callq 0x8dfc
cmpq $0x0, 0x258(%rax)
je 0x8e7d
testw %bx, %bx
je 0x8e76
movq 0x268(%rax), %rax
jmp 0x8e7d
movq 0x260(%rax), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: EastNeighbor(bodygridclass*)
OctCell *EastNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;
	if(parent==NULL) return(&bodygrid[NOparent+1]);	
	NOchildren=pp->NOchildren;
	if(NOchildren==0) return(parent->children[1]);
    if(NOchildren==3) return(parent->children[2]);
    p=EastNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==1) return(p->children[0]);
	else if(NOchildren==2) return(p->children[3]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x8ead
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x8eb0
movzwl 0x204(%rax), %ebx
cmpl $0x3, %ebx
je 0x8ecf
testl %ebx, %ebx
jne 0x8ed8
movq 0x260(%rdi), %rax
jmp 0x8efe
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1c423(%rip), %rcx     # 0x252e0
imulq $0x360, %rax, %rax      # imm = 0x360
addq (%rcx), %rax
addq $0x360, %rax            # imm = 0x360
jmp 0x8efe
movq 0x268(%rdi), %rax
jmp 0x8efe
callq 0x8e7f
movq %rax, %rcx
movq 0x258(%rax), %rax
testq %rax, %rax
je 0x8efb
cmpw $0x1, %bx
je 0x8efe
movq 0x270(%rcx), %rax
jmp 0x8efe
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/jamesliu516[P]amrdg2d/findneighbor.cpp
// Function: SouthNeighbor(bodygridclass*)
OctCell *SouthNeighbor(OctCell *pp)
{
	int NOchildren;
	long NOparent;
	OctCell *parent,*p;
    if(pp==NULL){
        return NULL;
    }
    else{
	parent=pp->parent;
	NOparent=pp->NOparent;
	if(parent==NULL) return(&bodygrid[NOparent-Nx]);	
	NOchildren=pp->NOchildren;
	if(NOchildren==3) return(parent->children[0]);
    if(NOchildren==2) return(parent->children[1]);
    p=SouthNeighbor(parent);
	if(p->children[0]==NULL) return(p);
	else if(NOchildren==0) return(p->children[3]);
	else if(NOchildren==1) return(p->children[2]);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x8f2f
pushq %rbx
movq %rdi, %rax
movq 0x250(%rdi), %rdi
testq %rdi, %rdi
je 0x8f32
movzwl 0x204(%rax), %ebx
cmpl $0x2, %ebx
je 0x8f54
cmpl $0x3, %ebx
jne 0x8f5d
movq 0x258(%rdi), %rax
jmp 0x8f81
xorl %eax, %eax
retq
movl 0x200(%rax), %eax
leaq 0x1c3a1(%rip), %rcx     # 0x252e0
movq (%rcx), %rcx
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rcx, %rax
addq $-0x19f20, %rax         # imm = 0xFFFE60E0
jmp 0x8f81
movq 0x260(%rdi), %rax
jmp 0x8f81
callq 0x8f00
cmpq $0x0, 0x258(%rax)
je 0x8f81
testw %bx, %bx
je 0x8f7a
movq 0x268(%rax), %rax
jmp 0x8f81
movq 0x270(%rax), %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1aa3b(%rip), %rax     # 0x25200
movslq (%rax), %rax
testq %rax, %rax
jle 0xa81c
movq %rax, %rcx
shlq $0x4, %rcx
xorl %edx, %edx
leaq 0x1aba3(%rip), %rsi     # 0x25380
xorpd %xmm0, %xmm0
movsd 0x13bef(%rip), %xmm1    # 0x1e3d8
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 0xa7e9
shlq $0x4, %rax
leaq 0x1ab59(%rip), %rcx     # 0x25380
movaps (%rcx), %xmm0
movaps %xmm0, (%rcx,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa8ab
movl %edi, %eax
shlq $0x4, %rax
xorl %edx, %edx
xorl %ecx, %ecx
movupd (%rsi,%rdx), %xmm2
movupd 0x10(%rsi,%rdx), %xmm3
movapd %xmm3, %xmm5
unpckhpd %xmm3, %xmm5            # xmm5 = xmm5[1],xmm3[1]
movapd %xmm2, %xmm4
unpckhpd %xmm2, %xmm4            # xmm4 = xmm4[1],xmm2[1]
ucomisd %xmm5, %xmm4
jne 0xa860
jnp 0xa8a0
ucomisd %xmm4, %xmm1
jb 0xa86c
ucomisd %xmm1, %xmm5
ja 0xa878
ucomisd %xmm1, %xmm4
jbe 0xa8a0
ucomisd %xmm5, %xmm1
jb 0xa8a0
subpd %xmm2, %xmm3
movapd %xmm1, %xmm5
subsd %xmm4, %xmm5
mulsd %xmm3, %xmm5
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
divsd %xmm3, %xmm5
addsd %xmm2, %xmm5
ucomisd %xmm0, %xmm5
jne 0xa89c
jnp 0xa8ae
jbe 0xa8a0
incl %ecx
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0xa83d
jmp 0xa8b3
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_O1/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 0xad08
sarq $0x3, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0xacf3
ucomisd %xmm1, %xmm0
jb 0x31b0
sqrtsd %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xadcb
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 0xadb5
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xae00
sarq $0x3, %rdx
xorl %edi, %edi
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0xadef
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xac34
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0xae77
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 0xae61
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaf2d
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 0xaf16
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xac34
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0xb025
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 0xb00f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xac34
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0xb078
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 0xb061
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xac34
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0xb0cb
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 0xb0b4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xac34
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0xb174
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 0xb15d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12db8(%rip), %rsi     # 0x1e0b0
movl $0x1, %edx
callq 0x3250
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
decq %rcx
je 0xb356
xorl %r12d, %r12d
leaq 0x12d93(%rip), %r15     # 0x1e0b2
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x3300
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3250
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
decq %rcx
cmpq %rcx, %r12
jne 0xb31f
movsd (%rax,%rcx,8), %xmm0
movq %rbx, %rdi
callq 0x3300
leaq 0x12d4a(%rip), %rsi     # 0x1e0b4
movl $0x1, %edx
movq %rax, %rdi
callq 0x3250
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x480e
testq %rbx, %rbx
je 0xbd4d
cmpw $0x0, 0x1fc(%rbx)
je 0xbd6d
xorl %r14d, %r14d
movq 0x258(%rbx,%r14,8), %rdi
movl %ebp, %esi
callq 0xbd27
incq %r14
cmpq $0x4, %r14
jne 0xbd50
jmp 0xbdf2
movl $0x20, %edi
callq 0x3210
movq %rax, %r14
movq %rax, %rdi
callq 0x4624
leaq 0x1e887(%rip), %rax     # 0x2a610
cmpq $0x0, (%rax)
je 0xbd9c
movq 0x1ec5a(%rip), %rax     # 0x2a9f0
movq %r14, 0x10(%rax)
jmp 0xbda7
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 0x1e8bd(%rip), %rdi     # 0x2a698
callq 0xc220
movq 0x1ec09(%rip), %rax     # 0x2a9f0
movq %rax, 0x18(%r14)
movq %r14, 0x1ebfe(%rip)     # 0x2a9f0
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_O1/jamesliu516[P]amrdg2d/formlist.cpp
// Function: formListFaceCell(bodygridclass*, int)
void formListFaceCell(OctCell *pg, int listflg)
{
	if(pg->flag==listflg)
	{
	    BndryNode *current;
	    current = new BndryNode;
	
	    if(HeadFaceCell == NULL)	
            HeadFaceCell = current;
	    else	
            PrevFacecell->next = current;
		
	    current->next = NULL;	  
	      
	    current->cell = pg;
	      
	    current->prev=PrevFacecell;
	    
//	    pg->pnode=current;
	    PrevFacecell=current;
	    ++sfcell;
	}
	
}

// Assembly:
movswl 0x1b0(%rdi), %eax
cmpl %esi, %eax
jne 0xc0ad
pushq %rbx
movq %rdi, %rbx
movl $0x18, %edi
callq 0x3210
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %ecx, %ecx
leaq 0x1e5a4(%rip), %rdx     # 0x2a618
movq 0x1e97d(%rip), %rsi     # 0x2a9f8
addq $0x8, %rsi
cmpq %rcx, (%rdx)
movq %rcx, 0x10(%rax)
cmoveq %rdx, %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rax)
movq %rbx, (%rax)
movq 0x1e95d(%rip), %rcx     # 0x2a9f8
movq %rcx, 0x10(%rax)
movq %rax, 0x1e952(%rip)     # 0x2a9f8
incl 0x1e954(%rip)           # 0x2aa00
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x1e947(%rip)     # 0x2aa00
leaq 0x1e550(%rip), %rax     # 0x2a610
movq (%rax), %rbx
testq %rbx, %rbx
je 0xc0dc
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rbx
movl $0x2, %esi
callq 0xc04c
jmp 0xc0c3
movq 0x18ee5(%rip), %rdi     # 0x24fc8
leaq 0x123b6(%rip), %rsi     # 0x1e4a0
movl $0x25, %edx
popq %rbx
jmp 0x3250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e4e8(%rip), %rbx     # 0x2a610
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc146
movq 0x10(%rdi), %r14
movl $0x20, %esi
callq 0x3220
movq %r14, %rdi
testq %r14, %r14
jne 0xc130
movq 0x18e7b(%rip), %rdi     # 0x24fc8
leaq 0x12372(%rip), %rsi     # 0x1e4c6
movl $0x1d, %edx
callq 0x3250
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x1e886(%rip)     # 0x2a9f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e49b(%rip), %rbx     # 0x2a618
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc19b
movq 0x8(%rdi), %r14
movl $0x18, %esi
callq 0x3220
movq %r14, %rdi
testq %r14, %r14
jne 0xc185
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x1e851(%rip)     # 0x2a9f8
movq 0x18e1a(%rip), %rbx     # 0x24fc8
leaq 0x1232f(%rip), %rsi     # 0x1e4e4
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x3250
movl 0x1e838(%rip), %esi     # 0x2aa00
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 0x122fe(%rip), %rsi     # 0x1e4ff
movl $0x22, %edx
movq %rbx, %rdi
callq 0x3250
movl $0x0, 0x1e7e8(%rip)     # 0x2aa00
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc74c
movl %edx, %eax
leaq 0x11efe(%rip), %rcx     # 0x1e638
leaq 0x11f17(%rip), %r8      # 0x1e658
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 0x118ad(%rip), %xmm4    # 0x1e050
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 0x1189c(%rip), %xmm4    # 0x1e060
divpd %xmm3, %xmm4
divpd %xmm1, %xmm4
movupd %xmm4, 0x18(%rdi)
movhpd %xmm4, 0x28(%rdi)
mulpd %xmm2, %xmm0
movupd 0x278(%rsi), %xmm1
mulpd 0x11de6(%rip), %xmm0    # 0x1e5d0
addpd %xmm1, %xmm0
movupd %xmm0, 0x278(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc81b
movl %edx, %eax
leaq 0x11e2f(%rip), %rcx     # 0x1e638
leaq 0x11e48(%rip), %r8      # 0x1e658
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 0x117de(%rip), %xmm4    # 0x1e050
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 0x117cd(%rip), %xmm4    # 0x1e060
divpd %xmm3, %xmm4
divpd %xmm1, %xmm4
movupd %xmm4, 0x18(%rdi)
movhpd %xmm4, 0x28(%rdi)
mulpd %xmm2, %xmm0
movupd 0x278(%rsi), %xmm1
mulpd 0x11d17(%rip), %xmm0    # 0x1e5d0
addpd %xmm1, %xmm0
movupd %xmm0, 0x278(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc958
movq %rdi, %rbx
movsd 0x11864(%rip), %xmm0    # 0x1e148
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 0xc728
movq %r15, %rdi
callq 0xc3f8
incq %r14
cmpq $0x4, %r14
jne 0xc906
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