LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mxy161610207[P]codesim/src/main.cpp
// Function: main
int main(int argc, char* argv[])
{
    char* filename1, *filename2;
    if (argc == 3) {
        filename1 = argv[1];
        filename2 = argv[2];
    }
    else {
        ShowHelp();
        exit(-1);
    }

    double res = MyPaser::PaserCompare(filename1, filename2);
    res = min(res, 1.0);
    printf("%.2lf\n", res);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jne 0x92f6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9305
callq 0x92a0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22e0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4320
movsd %xmm0, -0x28(%rbp)
movsd 0xd09(%rip), %xmm0      # 0xa028
movsd %xmm0, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9360
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
leaq 0xe86(%rip), %rdi       # 0xa1cc
movb $0x1, %al
callq 0x2060
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: lhartmann[P]orangepi-i2s-steppers/cnt.cpp
// Function: main
int main() {
	uint32_t buff[1024];
	while (true) {
		for (uint32_t i=0; i<1024; ++i) {
			buff[i] = step();
		}
		write(STDOUT_FILENO, buff, sizeof(buff));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movl $0x0, -0x4(%rbp)
movl $0x0, -0x1014(%rbp)
cmpl $0x400, -0x1014(%rbp)   # imm = 0x400
jae 0x13cd
callq 0x11f0
movl %eax, %ecx
movl -0x1014(%rbp), %eax
movl %ecx, -0x1010(%rbp,%rax,4)
movl -0x1014(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1014(%rbp)
jmp 0x139c
leaq -0x1010(%rbp), %rsi
movl $0x1, %edi
movl $0x1000, %edx           # imm = 0x1000
callq 0x1030
jmp 0x1392
nopw %cs:(%rax,%rax)
nop
// File: lhartmann[P]orangepi-i2s-steppers/./stepper.h
// Function: Stepper::prepare(unsigned int, unsigned int)
void prepare(
        uint32_t D,
        uint32_t T
    ) {
        current = 0;
        end = D;
        rate_up = D;
        rate_dn = T;
        acc = -int32_t(T)/2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
xorl %eax, %eax
subl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lhartmann[P]orangepi-i2s-steppers/./throttle.h
// Function: Throttle::prepare(unsigned int, unsigned int, unsigned int, unsigned int)
void prepare(
            uint32_t nN,
            uint32_t nrd,
            uint32_t nr0,
            uint32_t nr1
    ) {
        n   = 0;
        N   = nN;
        rd  = nrd;
        r0  = nr0;
        r1  = nr1 ? nr1 : 1; // Zero could cause a deadlock
        paused = false;

        acc = -int32_t(r0); // 1 sample delay, for DIR bits.
        r   = r0;
        uint32_t dk = rd-r1;
        if (rd) n1 = N - dk + dk*1.*dk/(2.*rd);
        else    n1 = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, -0x18(%rbp)
je 0x1533
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x153d
movl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x153d
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x14(%rax)
movb $0x0, 0x20(%rax)
xorl %ecx, %ecx
subl 0x10(%rax), %ecx
movl %ecx, 0x1c(%rax)
movl 0x10(%rax), %ecx
movl %ecx, 0x18(%rax)
movl 0xc(%rax), %ecx
subl 0x14(%rax), %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, 0xc(%rax)
je 0x15a4
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
movl %edx, %edi
movl 0x8(%rax), %esi
movl 0xc(%rax), %ecx
subl %edi, %esi
cvtsi2sd %rsi, %xmm0
cvtsi2sd %rdx, %xmm1
mulsd %xmm1, %xmm1
cvtsi2sd %rcx, %xmm2
addsd %xmm2, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movl %ecx, 0x4(%rax)
jmp 0x15af
movq -0x28(%rbp), %rax
movl $0x0, 0x4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: lhartmann[P]orangepi-i2s-steppers/./throttle.h
// Function: Throttle::step()
bool step() {
        if (paused) {
            // On pause, decelerate gracefully to zero.
            if (r) r--;
        } else {
            // If before brake point
            if (n<n1) {
                // Then accelerate to max-speed
                if (r < rd) r++;
            } else {
                // Otherwise decelerate to end-speed
                if (r > r1) r--;

                // On resume, accelerate to end-speed
                if (r < r1) r++;
            }
        }
        acc += r;
        if (acc > 0) {
            acc -= rd;
            if (n < N) n++;
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x20(%rax)
je 0x15ef
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x15ed
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x164b
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
cmpl 0x4(%rcx), %eax
jae 0x1615
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0xc(%rcx), %eax
jae 0x1613
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x1649
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x14(%rcx), %eax
jbe 0x162e
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x14(%rcx), %eax
jae 0x1647
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x1649
jmp 0x164b
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
cmpl $0x0, 0x1c(%rax)
jle 0x1685
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %edx
movl 0x1c(%rcx), %eax
subl %edx, %eax
movl %eax, 0x1c(%rcx)
movl (%rcx), %eax
cmpl 0x8(%rcx), %eax
jae 0x167f
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1689
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: lhartmann[P]orangepi-i2s-steppers/./stepper.h
// Function: Stepper::step()
bool step() {
        acc += rate_up;
        if (acc>0) {
            acc -= rate_dn;
            if (++current == end) {
                prepare (0,0);
            }
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %ecx
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jle 0x16e1
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %edx
movl 0x10(%rcx), %eax
subl %edx, %eax
movl %eax, 0x10(%rcx)
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
cmpl 0x4(%rcx), %eax
jne 0x16db
movq -0x18(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x14a0
movb $0x1, -0x1(%rbp)
jmp 0x16e5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: lhartmann[P]orangepi-i2s-steppers/./maskedtransportdelay.h
// Function: MaskedTransportDelay<unsigned int, 1, 2147483647u>::operator()(unsigned int)
T operator() (T x) {
        // Advance pointer
        if (p == buff) p += N-1;
        else p--;

        // Exchange data
        T y = *p;
        *p = x;

        return y & M | x & ~M;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rcx), %rax
cmpq %rcx, %rax
jne 0x171a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x172a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x4, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movl (%rcx), %ecx
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl -0xc(%rbp), %ecx
andl $0x80000000, %ecx       # imm = 0x80000000
orl %ecx, %eax
popq %rbp
retq
// File: 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:
subq $0x238, %rsp            # imm = 0x238
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x32e0
movq 0x10(%rsp), %rdi
leaq 0x3a286(%rip), %rsi     # 0x3f078
movl $0x8, %edx
callq 0x3170
jmp 0x4dfe
movl $0x1, 0x230(%rsp)
cmpl $0x15061, 0x230(%rsp) # imm = 0x15061
jge 0x4e93
movq 0x46513(%rip), %rsi     # 0x4b330
movslq 0x230(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x31e0
movq %rax, 0x8(%rsp)
jmp 0x4e3d
movq 0x8(%rsp), %rdi
movq 0x464e7(%rip), %rax     # 0x4b330
movslq 0x230(%rsp), %rcx
shlq $0x4, %rcx
leaq 0x8(%rax,%rcx), %rsi
callq 0x31e0
jmp 0x4e61
jmp 0x4e63
movl 0x230(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x230(%rsp)
jmp 0x4e09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x30c0
jmp 0x5002
movl $0x1, 0x230(%rsp)
cmpl $0x14e17, 0x230(%rsp) # imm = 0x14E17
jge 0x4f18
movl $0x0, 0x234(%rsp)
cmpl $0x4, 0x234(%rsp)
jge 0x4f03
movq 0x46471(%rip), %rax     # 0x4b338
movslq 0x230(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x234(%rsp), %rcx
leaq (%rax,%rcx,4), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3160
jmp 0x4eee
jmp 0x4ef0
movl 0x234(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x234(%rsp)
jmp 0x4eb6
jmp 0x4f05
movl 0x230(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x230(%rsp)
jmp 0x4e9e
movl $0x1, 0x234(%rsp)
cmpl $0x41, 0x234(%rsp)
jg 0x4fe4
movl $0x1, 0x230(%rsp)
cmpl $0x7b, 0x230(%rsp)
jg 0x4fcc
movq 0x463e7(%rip), %rcx     # 0x4b338
movl 0x230(%rsp), %eax
subl $0x1, %eax
imull $0x41, %eax, %eax
addl $0x41, %eax
movl 0x234(%rsp), %edx
subl $0x1, %edx
subl %edx, %eax
cltq
shlq $0x4, %rax
addq %rax, %rcx
movq 0x463ab(%rip), %rax     # 0x4b328
movl 0x234(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0x7b0, %rdx, %rdx      # imm = 0x7B0
addq %rdx, %rax
movl 0x230(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl 0x230(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x230(%rsp)
jmp 0x4f3c
jmp 0x4fce
movl 0x234(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x234(%rsp)
jmp 0x4f23
leaq 0x28(%rsp), %rdi
callq 0x3080
jmp 0x4ff0
leaq 0x28(%rsp), %rdi
callq 0x30c0
addq $0x238, %rsp            # imm = 0x238
retq
movq 0x20(%rsp), %rdi
callq 0x3440
nopl (%rax)
// File: jamesliu516[P]amrdg2d/./non_uniform_grid.h
// Function: bodygridclass::set_invM()
void set_invM() {
        invM[0]=1.0/dx/dy;   
        invM[1]=3.0/dx/dy;
        invM[2]=3.0/dx/dy;
        invM[3]=9.0/dx/dy;
        invM[4]=45.0/4.0/dx/dy;
        invM[5]=45.0/4.0/dx/dy;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movsd 0x3a036(%rip), %xmm0    # 0x3f058
divsd 0x288(%rax), %xmm0
divsd 0x290(%rax), %xmm0
movsd %xmm0, (%rax)
movsd 0x3a012(%rip), %xmm0    # 0x3f050
divsd 0x288(%rax), %xmm0
divsd 0x290(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x39ff5(%rip), %xmm0    # 0x3f050
divsd 0x288(%rax), %xmm0
divsd 0x290(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x39fd0(%rip), %xmm0    # 0x3f048
divsd 0x288(%rax), %xmm0
divsd 0x290(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x39fab(%rip), %xmm0    # 0x3f040
divsd 0x288(%rax), %xmm0
divsd 0x290(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x39f8e(%rip), %xmm0    # 0x3f040
divsd 0x288(%rax), %xmm0
divsd 0x290(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
retq
nopl (%rax,%rax)
// File: jamesliu516[P]amrdg2d/bodygridclass.cpp
// Function: bodygridclass::bodygridclass()
bodygridclass::bodygridclass()
{
    //   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;
        }
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movw $0x0, 0x1b0(%rax)
movw $0xffff, 0x1b2(%rax)    # imm = 0xFFFF
movw $0x0, 0x1f8(%rax)
movw $0x0, 0x1fc(%rax)
movb $0x0, 0x1fe(%rax)
movl $0x0, 0x200(%rax)
movw $0x0, 0x204(%rax)
movq $0x0, 0x250(%rax)
movb $0x0, 0x206(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x238(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x240(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x248(%rax)
movb $0x0, 0x210(%rax)
movb $0x0, 0x211(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x218(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x220(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x230(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x228(%rax)
movb $0x0, 0x1b4(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x208(%rax)
movl $0x0, -0xc(%rsp)
cmpl $0x4, -0xc(%rsp)
jge 0x51fe
movq -0x20(%rsp), %rax
movslq -0xc(%rsp), %rcx
movq $0x0, 0x258(%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x51d4
movl $0x0, -0x10(%rsp)
cmpl $0x4, -0x10(%rsp)
jge 0x52a6
movl $0x0, -0x14(%rsp)
cmpl $0x6, -0x14(%rsp)
jge 0x5294
movq -0x20(%rsp), %rax
movq %rax, %rcx
addq $0xf0, %rcx
movslq -0x10(%rsp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movslq -0x14(%rsp), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq %rax, %rcx
addq $0x30, %rcx
movslq -0x10(%rsp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movslq -0x14(%rsp), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
addq $0x2a0, %rax            # imm = 0x2A0
movslq -0x10(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x5219
jmp 0x5296
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x5206
retq
nopw (%rax,%rax)
// File: jamesliu516[P]amrdg2d/bodygridclass.cpp
// Function: Face::Face()
Face::Face()
{
    parent=NULL; //left cell
    neighbor=NULL; //right cell
    //parent is the id of the cell owning this face
    // A cell owns a face if the face normal is pointing outwards from it
    // The other cell is called the neighbor
    //  Vec2D nml;
    nml[0]=0.0;
    nml[1]=0.0; 

    bHang=false;
    for(int ii=0; ii<3; ++ii){
        gs_pt[ii][0]=gs_pt[ii][1]=0.0;
        for(int jj=0; jj<4; ++jj)
            faceflux[ii][jj]=0.0; //face flux at 3 gauss points
    }         
    area=0.0; //the area of the face in 3d or lenth in 2d
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movb $0x0, 0xb8(%rax)
movl $0x0, -0xc(%rsp)
cmpl $0x3, -0xc(%rsp)
jge 0x555f
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $0x20, %rcx
movslq -0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rcx)
addq $0x20, %rax
movslq -0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x10(%rsp)
cmpl $0x4, -0x10(%rsp)
jge 0x554d
movq -0x18(%rsp), %rax
addq $0x50, %rax
movslq -0xc(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x10(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x5517
jmp 0x554f
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x54cd
movq -0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0xb0(%rax)
retq
// File: jamesliu516[P]amrdg2d/./non_uniform_grid.h
// Function: bodygridclass::set_invM(double, double)
void set_invM(double dsx, double dsy) {
        invM[0]=1.0/dsx/dsy;   
        invM[1]=3.0/dsx/dsy;
        invM[2]=3.0/dsx/dsy;
        invM[3]=9.0/dsx/dsy;
        invM[4]=45.0/4.0/dsx/dsy;
        invM[5]=45.0/4.0/dsx/dsy;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movq -0x8(%rsp), %rax
movsd 0x399ea(%rip), %xmm0    # 0x3f058
divsd -0x10(%rsp), %xmm0
divsd -0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x399ca(%rip), %xmm0    # 0x3f050
divsd -0x10(%rsp), %xmm0
divsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x399b1(%rip), %xmm0    # 0x3f050
divsd -0x10(%rsp), %xmm0
divsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x39990(%rip), %xmm0    # 0x3f048
divsd -0x10(%rsp), %xmm0
divsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x3996f(%rip), %xmm0    # 0x3f040
divsd -0x10(%rsp), %xmm0
divsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x39956(%rip), %xmm0    # 0x3f040
divsd -0x10(%rsp), %xmm0
divsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x5700
movq (%rsp), %rcx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movsd 0x8(%rcx), %xmm0
movq 0x18(%rsp), %rdx
movsd 0x10(%rdx), %xmm2
movsd 0x10(%rcx), %xmm1
movq 0x18(%rsp), %rdx
mulsd 0x8(%rdx), %xmm1
movq %xmm1, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd (%rcx), %xmm0
movq %xmm0, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorq %rsi, %rdx
movq %rdx, %xmm0
movq 0x18(%rsp), %rdx
movsd 0x10(%rdx), %xmm2
movsd 0x10(%rcx), %xmm1
movq 0x18(%rsp), %rdx
mulsd (%rdx), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rdx
movsd 0x8(%rdx), %xmm2
movsd 0x8(%rcx), %xmm1
movq 0x18(%rsp), %rcx
mulsd (%rcx), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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, -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)
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm1
movsd 0x10(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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, -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 (%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x5700
movq (%rsp), %rcx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rdx
mulsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rcx), %xmm0
movq 0x18(%rsp), %rdx
mulsd (%rdx), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rcx), %xmm0
movq 0x18(%rsp), %rcx
mulsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rdi)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x5700
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
mulsd (%rcx), %xmm0
movsd %xmm0, (%rdi)
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
mulsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rdi)
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
mulsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rdi)
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x5700
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
divsd (%rcx), %xmm0
movsd %xmm0, (%rdi)
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
divsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rdi)
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
divsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rdi)
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x5700
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
addsd (%rcx), %xmm0
movsd %xmm0, (%rdi)
movq 0x20(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movq 0x18(%rsp), %rcx
addsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rdi)
movq 0x20(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
movq 0x18(%rsp), %rcx
addsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rdi)
addq $0x28, %rsp
retq
// File: 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:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm2, -0x20(%rsp)
movsd %xmm3, -0x28(%rsp)
movq -0x8(%rsp), %rax
movsd -0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
retq
nop
// File: 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, -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)
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm1
movsd 0x10(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm1
movsd 0x18(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
retq
nopw (%rax,%rax)
// File: 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, -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 (%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rax)
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x7f30
movq (%rsp), %rcx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rdx
mulsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rcx), %xmm0
movq 0x18(%rsp), %rdx
mulsd (%rdx), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rcx), %xmm0
movq 0x18(%rsp), %rdx
mulsd (%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rcx), %xmm0
movq 0x18(%rsp), %rcx
mulsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x7f30
movq (%rsp), %rcx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rdx
divsd (%rdx), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rcx), %xmm0
movq 0x18(%rsp), %rdx
divsd (%rdx), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rcx), %xmm0
movq 0x18(%rsp), %rdx
divsd (%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rcx), %xmm0
movq 0x18(%rsp), %rcx
divsd (%rcx), %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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, -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)
movq -0x10(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rcx
movsd 0x18(%rcx), %xmm0
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x7f30
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
mulsd (%rcx), %xmm0
movsd %xmm0, (%rdi)
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
mulsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rdi)
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
mulsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rdi)
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
mulsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x7f30
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rsp), %rcx
addsd (%rcx), %xmm0
movsd %xmm0, (%rdi)
movq 0x20(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movq 0x18(%rsp), %rcx
addsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rdi)
movq 0x20(%rsp), %rcx
movsd 0x10(%rcx), %xmm0
movq 0x18(%rsp), %rcx
addsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rdi)
movq 0x20(%rsp), %rcx
movsd 0x18(%rcx), %xmm0
movq 0x18(%rsp), %rcx
addsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x258, %rsp            # imm = 0x258
leaq 0x3f622(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x250(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3410
leaq 0x3f896(%rip), %rsi     # 0x50930
leaq 0x2e2de(%rip), %rdx     # 0x3f37f
leaq 0x20(%rsp), %rdi
callq 0x114c0
jmp 0x110ad
leaq 0x20(%rsp), %rdi
callq 0x3110
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
movl $0x10, %edx
callq 0x3050
jmp 0x110cb
leaq 0x3f5ce(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x250(%rsp)
cmpq $0x0, 0x250(%rsp)
je 0x111c6
movq 0x250(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x240(%rsp)
movl $0x0, 0x24c(%rsp)
cmpl $0x4, 0x24c(%rsp)
jge 0x1119a
movq 0x240(%rsp), %rax
movslq 0x24c(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movsd 0x30(%rax,%rcx), %xmm0
leaq 0x40(%rsp), %rdi
callq 0x3480
movq %rax, 0x8(%rsp)
jmp 0x11148
movq 0x8(%rsp), %rdi
leaq 0x2eb39(%rip), %rsi     # 0x3fc8d
callq 0x3240
jmp 0x1115b
jmp 0x1115d
movl 0x24c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24c(%rsp)
jmp 0x1110b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x111ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x34d8
jmp 0x111ee
leaq 0x2e149(%rip), %rsi     # 0x3f2ea
leaq 0x40(%rsp), %rdi
callq 0x3240
jmp 0x111ad
movq 0x250(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x250(%rsp)
jmp 0x110dd
leaq 0x40(%rsp), %rdi
callq 0x3390
jmp 0x111d2
leaq 0x20(%rsp), %rdi
callq 0x34d8
leaq 0x40(%rsp), %rdi
callq 0x33b0
addq $0x258, %rsp            # imm = 0x258
retq
leaq 0x40(%rsp), %rdi
callq 0x33b0
movq 0x18(%rsp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x238, %rsp            # imm = 0x238
leaq 0x3f482(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x230(%rsp)
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x32e0
movq (%rsp), %rdi
leaq 0x2e139(%rip), %rsi     # 0x3f37b
movl $0x8, %edx
callq 0x3170
jmp 0x1124e
leaq 0x3f44b(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x230(%rsp)
cmpq $0x0, 0x230(%rsp)
je 0x113a3
movq 0x230(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x220(%rsp)
movl $0x0, 0x22c(%rsp)
cmpl $0x4, 0x22c(%rsp)
jge 0x1138a
movq 0x220(%rsp), %rax
movslq 0x22c(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq 0x30(%rax,%rcx), %rsi
leaq 0x18(%rsp), %rdi
callq 0x31e0
jmp 0x112c5
movq 0x220(%rsp), %rax
addq $0x30, %rax
movslq 0x22c(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq 0x220(%rsp), %rax
addq $0xf0, %rax
movslq 0x22c(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movl $0x1, 0x228(%rsp)
cmpl $0x6, 0x228(%rsp)
jge 0x11372
movq 0x220(%rsp), %rax
addq $0x30, %rax
movslq 0x22c(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq 0x228(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x228(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x228(%rsp)
jmp 0x11310
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x30c0
jmp 0x113c1
jmp 0x11374
movl 0x22c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x22c(%rsp)
jmp 0x1128e
movq 0x230(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x230(%rsp)
jmp 0x11260
leaq 0x18(%rsp), %rdi
callq 0x3080
jmp 0x113af
leaq 0x18(%rsp), %rdi
callq 0x30c0
addq $0x238, %rsp            # imm = 0x238
retq
movq 0x10(%rsp), %rdi
callq 0x3440
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x1168f
movq $0x0, 0x30(%rsp)
jmp 0x1178c
movq 0x28(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl 0x200(%rax), %eax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x116df
leaq 0x39cb1(%rip), %rax     # 0x4b370
movq (%rax), %rax
movq 0x18(%rsp), %rcx
addq $0x7b, %rcx
imulq $0x360, %rcx, %rcx      # imm = 0x360
addq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x1178c
movq 0x28(%rsp), %rax
movswl 0x204(%rax), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x1170c
movq 0x10(%rsp), %rax
movq 0x270(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1178c
cmpl $0x1, 0x24(%rsp)
jne 0x11726
movq 0x10(%rsp), %rax
movq 0x268(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1178c
movq 0x10(%rsp), %rdi
callq 0x11670
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x258(%rax)
jne 0x11750
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1178c
cmpl $0x3, 0x24(%rsp)
jne 0x1176a
movq 0x8(%rsp), %rax
movq 0x258(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1178c
cmpl $0x2, 0x24(%rsp)
jne 0x11784
movq 0x8(%rsp), %rax
movq 0x260(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1178c
jmp 0x11786
jmp 0x11788
jmp 0x1178a
ud2
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x117bf
movq $0x0, 0x30(%rsp)
jmp 0x118bc
movq 0x28(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl 0x200(%rax), %eax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1180f
leaq 0x39b81(%rip), %rax     # 0x4b370
movq (%rax), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
imulq $0x360, %rcx, %rcx      # imm = 0x360
addq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x118bc
movq 0x28(%rsp), %rax
movswl 0x204(%rax), %eax
movl %eax, 0x24(%rsp)
cmpl $0x1, 0x24(%rsp)
jne 0x1183c
movq 0x10(%rsp), %rax
movq 0x258(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x118bc
cmpl $0x2, 0x24(%rsp)
jne 0x11856
movq 0x10(%rsp), %rax
movq 0x270(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x118bc
movq 0x10(%rsp), %rdi
callq 0x117a0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x258(%rax)
jne 0x11880
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x118bc
cmpl $0x0, 0x24(%rsp)
jne 0x1189a
movq 0x8(%rsp), %rax
movq 0x260(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x118bc
cmpl $0x3, 0x24(%rsp)
jne 0x118b4
movq 0x8(%rsp), %rax
movq 0x268(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x118bc
jmp 0x118b6
jmp 0x118b8
jmp 0x118ba
ud2
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x118ef
movq $0x0, 0x30(%rsp)
jmp 0x119ec
movq 0x28(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl 0x200(%rax), %eax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1193f
leaq 0x39a51(%rip), %rax     # 0x4b370
movq (%rax), %rax
movq 0x18(%rsp), %rcx
addq $0x1, %rcx
imulq $0x360, %rcx, %rcx      # imm = 0x360
addq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x119ec
movq 0x28(%rsp), %rax
movswl 0x204(%rax), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x1196c
movq 0x10(%rsp), %rax
movq 0x260(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x119ec
cmpl $0x3, 0x24(%rsp)
jne 0x11986
movq 0x10(%rsp), %rax
movq 0x268(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x119ec
movq 0x10(%rsp), %rdi
callq 0x118d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x258(%rax)
jne 0x119b0
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x119ec
cmpl $0x1, 0x24(%rsp)
jne 0x119ca
movq 0x8(%rsp), %rax
movq 0x258(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x119ec
cmpl $0x2, 0x24(%rsp)
jne 0x119e4
movq 0x8(%rsp), %rax
movq 0x270(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x119ec
jmp 0x119e6
jmp 0x119e8
jmp 0x119ea
ud2
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x11a1f
movq $0x0, 0x30(%rsp)
jmp 0x11b1c
movq 0x28(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl 0x200(%rax), %eax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x11a6f
leaq 0x39921(%rip), %rax     # 0x4b370
movq (%rax), %rax
movq 0x18(%rsp), %rcx
subq $0x7b, %rcx
imulq $0x360, %rcx, %rcx      # imm = 0x360
addq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x11b1c
movq 0x28(%rsp), %rax
movswl 0x204(%rax), %eax
movl %eax, 0x24(%rsp)
cmpl $0x3, 0x24(%rsp)
jne 0x11a9c
movq 0x10(%rsp), %rax
movq 0x258(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x11b1c
cmpl $0x2, 0x24(%rsp)
jne 0x11ab6
movq 0x10(%rsp), %rax
movq 0x260(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x11b1c
movq 0x10(%rsp), %rdi
callq 0x11a00
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x258(%rax)
jne 0x11ae0
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x11b1c
cmpl $0x0, 0x24(%rsp)
jne 0x11afa
movq 0x8(%rsp), %rax
movq 0x270(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x11b1c
cmpl $0x1, 0x24(%rsp)
jne 0x11b14
movq 0x8(%rsp), %rax
movq 0x268(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x11b1c
jmp 0x11b16
jmp 0x11b18
jmp 0x11b1a
ud2
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl $0x0, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6310
leaq 0x10(%rsp), %rdi
callq 0x6310
movq %rsp, %rdi
callq 0x6310
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl 0x44(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x161db
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x38(%rsp), %rax
movslq 0x34(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jne 0x160ec
jp 0x160ec
jmp 0x161c9
movsd 0x28(%rsp), %xmm0
ucomisd 0x18(%rsp), %xmm0
jb 0x1610c
movsd 0x28(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x16134
movsd 0x28(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jb 0x161c9
movsd 0x28(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x161c9
movsd 0x20(%rsp), %xmm0
movsd (%rsp), %xmm1
subsd 0x10(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
subsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd 0x8(%rsp), %xmm2
subsd 0x18(%rsp), %xmm2
divsd %xmm2, %xmm1
addsd 0x10(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jne 0x1617d
jp 0x1617d
movl $0xffffffff, 0x30(%rsp) # imm = 0xFFFFFFFF
jmp 0x161db
movsd 0x20(%rsp), %xmm1
movsd (%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
subsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm2
subsd 0x18(%rsp), %xmm2
divsd %xmm2, %xmm0
addsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x161c5
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x161c7
jmp 0x161c9
jmp 0x161cb
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1604d
movl 0x30(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovgl %ecx, %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x17e60
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x16e00
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x17fb0
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x17fb0
movsd (%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x16d8b
movsd 0x18(%rsp), %xmm0
callq 0x31c0
addq $0x28, %rsp
retq
// 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 0x16ef2
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x182c0
movsd 0x8(%rsp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x16e91
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)