LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jamesliu516[P]amrdg2d/spatial_discretization.cpp
// Function: spatial_discretization_all()
void spatial_discretization_all()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag % 2 == 0 && current->flg<=2 ) {
            for(int im=0;im<4; ++im){
                for(int jm=0;jm<6; ++jm){
                    pcell0->residual[im][jm]=0.0;
                }
            }
        }

        current = current->next;
    }


    for(vector<Face>::size_type isz=0; isz!=faces_comp.size(); ++isz){
        spatial_discretize_f(faces_comp[isz]);
    }

    current = HeadListAllGrid;     
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag == 0 && current->flg<=2 ) 
            spatial_discretize_v(pcell0);
        current = current->next;
    }
}

// Assembly:
subq $0x28, %rsp
leaq 0x2ac75(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x25ae6
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movswl 0x1b0(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x25ad3
movq 0x20(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x25ad3
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x25ad1
movl $0x0, 0x10(%rsp)
cmpl $0x6, 0x10(%rsp)
jge 0x25ac2
movq 0x18(%rsp), %rax
addq $0x2a0, %rax            # imm = 0x2A0
movslq 0x14(%rsp), %rcx
imulq $0x30, %rcx, %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 0x25a8a
jmp 0x25ac4
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x25a7b
jmp 0x25ad3
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x25a33
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x2ac11(%rip), %rdi     # 0x50710
callq 0x13310
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
je 0x25b39
movq 0x8(%rsp), %rsi
leaq 0x2abf4(%rip), %rdi     # 0x50710
callq 0x13340
movq %rax, %rdi
callq 0x238d0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x25aef
leaq 0x2ab60(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x25b96
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl $0x0, %eax
jne 0x25b86
movq 0x20(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x25b86
movq 0x18(%rsp), %rdi
callq 0x24b50
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x25b48
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: reflection(privariables const*, pointxy const*, privariables*)
void reflection(const JBBL *jbu, const PXYZ *nxyz, JBBL *jbugst)
{
    jbugst->q = jbu->q;
    jbugst->p = jbu->p;

    jbugst->u = (- nxyz->x * nxyz->x + nxyz->y * nxyz->y) * jbu->u - 2 * nxyz->x * nxyz->y * jbu->v; 
    jbugst->v = - 2 * nxyz->x * nxyz->y * jbu->u + (nxyz->x * nxyz->x - nxyz->y * nxyz->y)* jbu->v; 
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x10(%rsp), %rax
movsd (%rax), %xmm2
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rsp), %rax
mulsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm2
movq -0x10(%rsp), %rax
movsd 0x1891f(%rip), %xmm1    # 0x3f0a0
mulsd (%rax), %xmm1
movq -0x10(%rsp), %rax
mulsd 0x8(%rax), %xmm1
movq -0x8(%rsp), %rax
mulsd 0x10(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movsd 0x188d9(%rip), %xmm0    # 0x3f0a8
mulsd (%rax), %xmm0
movq -0x10(%rsp), %rax
mulsd 0x8(%rax), %xmm0
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm2
movq -0x10(%rsp), %rax
movsd (%rax), %xmm1
movq -0x10(%rsp), %rax
movsd (%rax), %xmm4
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm3
movq -0x10(%rsp), %rax
mulsd 0x8(%rax), %xmm3
movq %xmm3, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm3
mulsd %xmm4, %xmm1
addsd %xmm3, %xmm1
movq -0x8(%rsp), %rax
mulsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, 0x10(%rax)
retq
nopl (%rax)
// File: jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: reflection(double, double, privariables const*, pointxy const*, privariables*)
void reflection(double hr, double hg,const JBBL *jbu, const PXYZ *nxyz, JBBL *jbugst)
{
    double tx,ty,nx,ny;
    nx=nxyz->x;
    ny=nxyz->y;
    tx=ny;
    ty=-nx;
    Vec2D ndir(nx,ny);
    Vec2D tdir(tx,ty);
    Vec2D ur(jbu->u,jbu->v);
    double un1,ut1,un2,ut2;
    un1=ur.dot(ndir);
    ut1=ur.dot(tdir);
    un2=-(hg/hr)*un1;
    ut2=ut1;

    jbugst->q = jbu->q;
    jbugst->p = jbu->p;
    jbugst->u = (ny * ut2 - ty * un2)/(tx * ny - nx * ty);
    jbugst->v = (tx * un2 - nx * ut2)/(tx * ny - nx * ty);			
}

// Assembly:
subq $0x98, %rsp
movsd %xmm0, 0x90(%rsp)
movsd %xmm1, 0x88(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0x78(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movsd 0x58(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x58(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
leaq 0x40(%rsp), %rdi
callq 0x1e1a0
movsd 0x68(%rsp), %xmm0
movsd 0x60(%rsp), %xmm1
leaq 0x30(%rsp), %rdi
callq 0x1e1a0
movq 0x80(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x80(%rsp), %rax
movsd 0x10(%rax), %xmm1
leaq 0x20(%rsp), %rdi
callq 0x1e1a0
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1e1d0
movsd %xmm0, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1e1d0
movsd %xmm0, 0x10(%rsp)
movsd 0x88(%rsp), %xmm0
divsd 0x90(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x80(%rsp), %rax
movsd (%rax), %xmm0
movq 0x70(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x80(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq 0x70(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movsd 0x50(%rsp), %xmm0
movsd (%rsp), %xmm2
movsd 0x60(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x68(%rsp), %xmm1
movsd 0x50(%rsp), %xmm3
movsd 0x58(%rsp), %xmm2
mulsd 0x60(%rsp), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x70(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd 0x68(%rsp), %xmm0
movsd 0x8(%rsp), %xmm2
movsd 0x58(%rsp), %xmm1
mulsd (%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x68(%rsp), %xmm1
movsd 0x50(%rsp), %xmm3
movsd 0x58(%rsp), %xmm2
mulsd 0x60(%rsp), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x70(%rsp), %rax
movsd %xmm0, 0x10(%rax)
addq $0x98, %rsp
retq
nopl (%rax)
// File: jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: getInterAB(pointxy const*, pointxy const*, pointxy const*, pointxy*)
void getInterAB(const PXYZ *gst, const PXYZ *pA, const PXYZ *pB, PXYZ *jiaodian)
{
    double ls1;
    double ls2;
    double b1, b2, xjd, yjd, jl;

    if(fabs(pB->y-pA->y) < 1e-10)
    {
        jiaodian->x = gst->x;
        jiaodian->y = pA->y;
    }
    else if(fabs(pA->x - pB->x) < 1e-10)
    {
        jiaodian->x = pA->x;
        jiaodian->y = gst->y;
    }
    else
    {
        ls1 = (pA->y-pB->y)/(pA->x-pB->x);
        ls2 = - 1.0/ls1;
        b1 = pA->y - ls1 * pA->x;
        b2 = gst->y - ls2 * gst->x;

        xjd = (b2 - b1)/(ls1-ls2);
        yjd = ls1 * xjd + b1;

        jiaodian->x = xjd;
        jiaodian->y = yjd;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rsp), %rax
subsd 0x8(%rax), %xmm1
movaps 0x17921(%rip), %xmm0    # 0x3f200
pand %xmm0, %xmm1
movsd 0x17b25(%rip), %xmm0    # 0x3f410
ucomisd %xmm1, %xmm0
jbe 0x2791c
movq -0x8(%rsp), %rax
movsd (%rax), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x27a95
movq -0x10(%rsp), %rax
movsd (%rax), %xmm1
movq -0x18(%rsp), %rax
subsd (%rax), %xmm1
movaps 0x178cb(%rip), %xmm0    # 0x3f200
pand %xmm0, %xmm1
movsd 0x17acf(%rip), %xmm0    # 0x3f410
ucomisd %xmm1, %xmm0
jbe 0x27972
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x27a93
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rsp), %rax
subsd 0x8(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd (%rax), %xmm1
movq -0x18(%rsp), %rax
subsd (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
movsd 0x179e6(%rip), %xmm0    # 0x3f390
divsd -0x28(%rsp), %xmm0
movsd %xmm0, -0x30(%rsp)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm1
movsd -0x28(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd (%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rsp)
movq -0x8(%rsp), %rax
movsd 0x8(%rax), %xmm1
movsd -0x30(%rsp), %xmm0
movq -0x8(%rsp), %rax
movsd (%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rsp)
movsd -0x40(%rsp), %xmm0
subsd -0x38(%rsp), %xmm0
movsd -0x28(%rsp), %xmm1
subsd -0x30(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rsp)
movsd -0x28(%rsp), %xmm0
movsd -0x48(%rsp), %xmm2
movsd -0x38(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rsp)
movsd -0x48(%rsp), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
movsd -0x50(%rsp), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x27a95
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: findPointInCell(pointxy const*, bodygridclass*)
OctCell *findPointInCell(const PXYZ *point, OctCell *cellflow)
{
    int m;
    //double plevel,hc;
    double hcx, hcy;
    OctCell *incell = NULL;

    if(cellflow->reflag == 0)	
    {	          	    
        //	plevel=cellflow->level;		           
        //	hc=h/pow(2.0,plevel);
        hcx=cellflow->dx;
        hcy=cellflow->dy;

        if(point->x < cellflow->xc1 + 0.5 * hcx + ERRS
            && point->x > cellflow->xc1 - 0.5 * hcx - ERRS
            && point->y < cellflow->yc1 + 0.5 * hcy + ERRS
            && point->y > cellflow->yc1 - 0.5 * hcy - ERRS)				
        {					
            incell=cellflow;   
       //     return incell;
        } 
      //  else
        //    return NULL;			
    }
    else
    {
        for(m=0; m<4; ++m)
        {
            incell = findPointInCell(point, cellflow->children[m]);
            if(incell!=NULL)break;//2008.2.22��
        }
    }

    return incell;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x0, %eax
jne 0x29d70
movq 0x28(%rsp), %rax
movsd 0x288(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movsd 0x290(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movsd (%rax), %xmm1
movq 0x28(%rsp), %rax
movsd 0x278(%rax), %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x154ba(%rip), %xmm3    # 0x3f140
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movsd 0x154b2(%rip), %xmm2    # 0x3f148
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x29d6e
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
movq 0x28(%rsp), %rax
movsd 0x278(%rax), %xmm2
movsd 0x18(%rsp), %xmm1
movsd 0x15470(%rip), %xmm3    # 0x3f138
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd 0x15470(%rip), %xmm2    # 0x3f148
subsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x29d6e
movq 0x30(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x28(%rsp), %rax
movsd 0x280(%rax), %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x15435(%rip), %xmm3    # 0x3f140
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movsd 0x1542d(%rip), %xmm2    # 0x3f148
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x29d6e
movq 0x30(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x28(%rsp), %rax
movsd 0x280(%rax), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x153ee(%rip), %xmm3    # 0x3f138
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd 0x153ee(%rip), %xmm2    # 0x3f148
subsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x29d6e
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x29dbb
movl $0x0, 0x24(%rsp)
cmpl $0x4, 0x24(%rsp)
jge 0x29db9
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq 0x258(%rax,%rcx,8), %rsi
callq 0x29c10
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x29daa
jmp 0x29db9
jmp 0x29dac
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x29d78
jmp 0x29dbb
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: insert_cell(bodygridclass*, std::set<bodygridclass*, std::less<bodygridclass*>, std::allocator<bodygridclass*>>&)
void insert_cell(OctCell *pp, set<OctCell*> &grid)
{
    if(pp->reflag==0){
        grid.insert(pp);
    }
    else {
        for(int m=0; m<4;++m) 
            insert_cell(pp->children[m], grid);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x0, %eax
jne 0x2a869
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xb680
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
jmp 0x2a8a3
movl $0x0, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jge 0x2a8a1
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq 0x258(%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0x2a830
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2a871
jmp 0x2a8a3
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: wall_treatment()
void wall_treatment()
{

    BndryNode *current;
    current = HeadFaceCell;
    while(current != NULL)
    {
        if(b_ARS)
            getGhostValueRiemann(current->cell);
        else
            getGhostValueMagazine(current->cell);
        current->cell->bAvg=true;  //2012/4/27 add
        current = current->next;
    }
}

// Assembly:
pushq %rax
leaq 0x238a0(%rip), %rax     # 0x506a8
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2ce3e
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x2c2a0
movq (%rsp), %rax
movq (%rax), %rax
movb $0x1, 0x206(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x2ce0f
popq %rax
retq
// File: jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: form_inter_cell_set()
void form_inter_cell_set()
{
    BndryNode *current;
    OctCell *lsbl;
    current =HeadFaceCell;
    interface_cell_set.clear();
    OctCell *pp[8]={NULL};
    while(current != NULL)
    {
        lsbl=current->cell;
        find_sol_refp(pp,bodygrid+lsbl->NOparent);
        insert_cell2(bodygrid+lsbl->NOparent,interface_cell_set);
        for(int i=0;i<8;++i)
            insert_cell2(pp[i],interface_cell_set);

        current = current->next;
    }
}

// Assembly:
subq $0x68, %rsp
leaq 0x2341d(%rip), %rax     # 0x506a8
movq (%rax), %rax
movq %rax, 0x60(%rsp)
leaq 0x31346(%rip), %rdi     # 0x5e5e0
callq 0xb670
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3150
cmpq $0x0, 0x60(%rsp)
je 0x2d362
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x58(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x1e09b(%rip), %rax     # 0x4b370
movq (%rax), %rsi
movq 0x58(%rsp), %rax
movl 0x200(%rax), %eax
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rax, %rsi
callq 0x3b130
leaq 0x1e077(%rip), %rax     # 0x4b370
movq (%rax), %rdi
movq 0x58(%rsp), %rax
movl 0x200(%rax), %eax
imulq $0x360, %rax, %rax      # imm = 0x360
addq %rax, %rdi
leaq 0x312c8(%rip), %rsi     # 0x5e5e0
callq 0x3d590
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jge 0x2d34f
movslq 0xc(%rsp), %rax
movq 0x10(%rsp,%rax,8), %rdi
leaq 0x312a3(%rip), %rsi     # 0x5e5e0
callq 0x3d590
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2d325
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x60(%rsp)
jmp 0x2d2b0
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: wherePoint(pointxy*, bodygridclass*&)
void wherePoint(PXYZ *xy, ptrOctCell &incell)
{
    double xc1,yc1, dx1,dy1;

    OctCell *lsbl;
    for(set<OctCell*>::iterator itset=interface_cell_set.begin();
        itset!=interface_cell_set.end();++itset){
        lsbl =*itset;

        xc1=lsbl->xc1;
        yc1=lsbl->yc1;
        dx1=lsbl->dx;
        dy1=lsbl->dy;

        if(xy->x >= xc1-0.5*dx1-1e-10 && xy->x <= xc1+0.5*dx1+1e-10 
            && xy->y >= yc1-0.5*dy1-1e-10 && xy->y <= yc1+0.5*dy1+1e-10)
        {
            incell=lsbl;
            break;
        }
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
leaq 0x3125b(%rip), %rdi     # 0x5e5e0
callq 0xb6f0
movq %rax, 0x8(%rsp)
leaq 0x3124a(%rip), %rdi     # 0x5e5e0
callq 0xb740
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0xb720
testb $0x1, %al
jne 0x2d3b5
jmp 0x2d515
leaq 0x8(%rsp), %rdi
callq 0xb770
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsd 0x278(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x10(%rsp), %rax
movsd 0x280(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x10(%rsp), %rax
movsd 0x288(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x10(%rsp), %rax
movsd 0x290(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x30(%rsp), %xmm2
movsd 0x20(%rsp), %xmm1
movsd 0x11d08(%rip), %xmm3    # 0x3f138
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd 0x11fd0(%rip), %xmm2    # 0x3f410
subsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2d504
movq 0x40(%rsp), %rax
movsd (%rax), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0x20(%rsp), %xmm0
movsd 0x11cd5(%rip), %xmm3    # 0x3f140
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movsd 0x11f95(%rip), %xmm2    # 0x3f410
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x2d504
movq 0x40(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
movsd 0x11c95(%rip), %xmm3    # 0x3f138
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd 0x11f5d(%rip), %xmm2    # 0x3f410
subsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2d504
movq 0x40(%rsp), %rax
movsd 0x8(%rax), %xmm1
movsd 0x28(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x11c65(%rip), %xmm3    # 0x3f140
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movsd 0x11f25(%rip), %xmm2    # 0x3f410
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x2d504
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2d515
jmp 0x2d506
leaq 0x8(%rsp), %rdi
callq 0xb850
jmp 0x2d38f
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: wherePointAll()
void wherePointAll()
{
    int i;

    for (int jj=0; jj<N_BODY;++jj){
        for(i=0; i < NWallPts[jj]; i++)
        {
            wherePoint(&MultiCircle[jj][i],MultiCompany[jj][i].incell );
        }
        MultiCompany[jj][NWallPts[jj]]=MultiCompany[jj][0];
    }
}

// Assembly:
pushq %rax
movl $0x0, (%rsp)
cmpl $0x1, (%rsp)
jge 0x2d5f9
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movslq (%rsp), %rdx
leaq 0x1dd47(%rip), %rcx     # 0x4b290
cmpl (%rcx,%rdx,4), %eax
jge 0x2d5a6
movslq (%rsp), %rax
leaq 0x1deb7(%rip), %rdi     # 0x4b410
imulq $0x1f40, %rax, %rax     # imm = 0x1F40
addq %rax, %rdi
movslq 0x4(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movslq (%rsp), %rax
leaq 0x235a6(%rip), %rsi     # 0x50b20
imulq $0x6d60, %rax, %rax     # imm = 0x6D60
addq %rax, %rsi
movslq 0x4(%rsp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
addq $0x18, %rsi
callq 0x2d370
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2d53a
movslq (%rsp), %rax
leaq 0x2356f(%rip), %rsi     # 0x50b20
imulq $0x6d60, %rax, %rax     # imm = 0x6D60
addq %rax, %rsi
movslq (%rsp), %rax
leaq 0x2355a(%rip), %rdi     # 0x50b20
imulq $0x6d60, %rax, %rax     # imm = 0x6D60
addq %rax, %rdi
movslq (%rsp), %rcx
leaq 0x1dcb5(%rip), %rax     # 0x4b290
movslq (%rax,%rcx,4), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0x2e210
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x2d528
popq %rax
retq
nopl (%rax,%rax)
// File: jamesliu516[P]amrdg2d/wall4amrdg2013.cpp
// Function: computeNormalArea()
void computeNormalArea()
{
    int i=0;

    for (int jj=0; jj<N_BODY;++jj){
        for(i=0; i<NWallPts[jj]; i++)
        {
            MultiCompany[jj][i].normS[0]= MultiCircle[jj][i+1].y-MultiCircle[jj][i].y;
            MultiCompany[jj][i].normS[1]= MultiCircle[jj][i].x-MultiCircle[jj][i+1].x;
        }
    }
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x1, 0x10(%rsp)
jge 0x2d779
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movslq 0x10(%rsp), %rdx
leaq 0x1dc59(%rip), %rcx     # 0x4b290
cmpl (%rcx,%rdx,4), %eax
jge 0x2d767
movslq 0x10(%rsp), %rcx
leaq 0x1ddc4(%rip), %rax     # 0x4b410
imulq $0x1f40, %rcx, %rcx     # imm = 0x1F40
addq %rcx, %rax
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movslq 0x10(%rsp), %rcx
leaq 0x1dd98(%rip), %rax     # 0x4b410
imulq $0x1f40, %rcx, %rcx     # imm = 0x1F40
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movslq 0x10(%rsp), %rax
leaq 0x2347c(%rip), %rdi     # 0x50b20
imulq $0x6d60, %rax, %rax     # imm = 0x6D60
addq %rax, %rdi
movslq 0x14(%rsp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x1e9b0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movslq 0x10(%rsp), %rcx
leaq 0x1dd3a(%rip), %rax     # 0x4b410
imulq $0x1f40, %rcx, %rcx     # imm = 0x1F40
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movslq 0x10(%rsp), %rcx
leaq 0x1dd14(%rip), %rax     # 0x4b410
imulq $0x1f40, %rcx, %rcx     # imm = 0x1F40
addq %rcx, %rax
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
subsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x10(%rsp), %rax
leaq 0x233f3(%rip), %rdi     # 0x50b20
imulq $0x6d60, %rax, %rax     # imm = 0x6D60
addq %rax, %rdi
movslq 0x14(%rsp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x1e9b0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2d627
jmp 0x2d769
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2d614
addq $0x18, %rsp
retq
nop
// File: jamesliu516[P]amrdg2d/./non_uniform_grid.h
// Function: wallp::wallp()
wallp()
    {
        pre=0.0;
        incell=NULL;
        cp=cf=0.0;
        T=0.0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x1e1a0
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
addq $0x18, %rsp
retq
// File: jamesliu516[P]amrdg2d/rk.cpp
// Function: dof2dof0()
void dof2dof0()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag % 2 == 0 ) {
            for(int im=0;im<4; ++im)
                for(int jm=0;jm<nDOF; ++jm)
                    pcell0->dof0[im][jm]=pcell0->dof[im][jm];
        }        
        current = current->next;
    }
}

// Assembly:
leaq 0x21fc9(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x2e7a1
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movswl 0x1b0(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x2e78e
movl $0x0, -0x14(%rsp)
cmpl $0x4, -0x14(%rsp)
jge 0x2e78c
movl $0x0, -0x18(%rsp)
cmpl $0x6, -0x18(%rsp)
jge 0x2e77d
movq -0x10(%rsp), %rax
addq $0x30, %rax
movslq -0x14(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rsp), %rax
addq $0xf0, %rax
movslq -0x14(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x2e729
jmp 0x2e77f
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x2e71a
jmp 0x2e78e
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x2e6df
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/rk.cpp
// Function: fn_RKTVDAll(int, int)
void fn_RKTVDAll(int tstp, int rkstp)
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag == 0 && current->flg<=2 ) {
            fn_RKTVD(pcell0,tstp, rkstp);
        }        
        current = current->next;
    }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
leaq 0x21b4d(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2ebae
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl $0x0, %eax
jne 0x2eb9e
movq 0x8(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x2eb9e
movq (%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x2e7b0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2eb5b
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/farfield_boundary.cpp
// Function: inlet_outletBndry()
void inlet_outletBndry()
{
    for(vector<OctCell *> ::size_type isz=0; isz<InletBndry.size();++isz){
        getInletOutletBndry(InletBndry[isz], 0);
    }

    for(vector<OctCell *> ::size_type isz=0; isz<OutletBndry.size();++isz){
        getInletOutletBndry(OutletBndry[isz], 1);
    }
}

// Assembly:
subq $0x28, %rsp
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x1fbba(%rip), %rdi     # 0x506c8
callq 0x1bd50
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x30b4b
movq 0x20(%rsp), %rsi
leaq 0x1fb9c(%rip), %rdi     # 0x506c8
callq 0x1e180
movq (%rax), %rdi
xorl %esi, %esi
callq 0x30760
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x30afd
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x1fb7b(%rip), %rdi     # 0x506e0
callq 0x1bd50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x30ba5
movq 0x18(%rsp), %rsi
leaq 0x1fb5d(%rip), %rdi     # 0x506e0
callq 0x1e180
movq (%rax), %rdi
movl $0x1, %esi
callq 0x30760
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x30b54
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: jamesliu516[P]amrdg2d/time_step.cpp
// Function: getTimeStep(bodygridclass*)
void getTimeStep(OctCell *unp)
{

	double u, v;

	double dx,dy;

	double a;
	JBBL jbu;
	SHBL shu;

	dx=unp->dx;
	dy=unp->dy;
	shu.q=unp->dof[0][0];
	shu.qu=unp->dof[1][0];
	shu.qv=unp->dof[2][0];
	shu.te=unp->dof[3][0];	
			
	shblToJbbl(&shu,&jbu);

	u = jbu.u;
	v = jbu.v; 

	a = sqrt(GAMMA * jbu.p / jbu.q);

    	unp->dt1 = CFL * dx * dy/ ((fabs(u) + a)*dy + (fabs(v) + a)*dx);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6530
leaq 0x8(%rsp), %rdi
callq 0x21aa0
movq 0x70(%rsp), %rax
movsd 0x288(%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0x70(%rsp), %rax
movsd 0x290(%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x70(%rsp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x70(%rsp), %rax
movsd 0x60(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x70(%rsp), %rax
movsd 0x90(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x70(%rsp), %rax
movsd 0xc0(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x21ad0
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0xae90(%rip), %xmm0     # 0x3f1d8
mulsd 0x40(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
callq 0x31c0
movsd %xmm0, 0x48(%rsp)
leaq 0x16f4a(%rip), %rax     # 0x4b2b0
movsd (%rax), %xmm0
mulsd 0x58(%rsp), %xmm0
mulsd 0x50(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
movaps 0xae7d(%rip), %xmm2     # 0x3f200
pand %xmm2, %xmm1
addsd 0x48(%rsp), %xmm1
movsd 0x50(%rsp), %xmm3
movsd 0x60(%rsp), %xmm2
movaps 0xae60(%rip), %xmm4     # 0x3f200
pand %xmm4, %xmm2
addsd 0x48(%rsp), %xmm2
mulsd 0x58(%rsp), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x70(%rsp), %rax
movsd %xmm0, 0x298(%rax)
addq $0x78, %rsp
retq
nop
// File: jamesliu516[P]amrdg2d/time_step.cpp
// Function: timestep()
void timestep()
{		
  Node *current;
  current = HeadListAllGrid;  
  OctCell *pcell0;
  
  dt=2000.0;			
  current = HeadListAllGrid;     
  while(current != NULL)
  {		
    pcell0 = current->cell;
    if(pcell0->flag == 0 && current->flg<=2 ) {
        getTimeStep(pcell0);
#ifndef LOCAL_TIME         
       getMinTimeStep(pcell0); 
#endif       
     }
    current = current->next;
  }			
}

// Assembly:
subq $0x18, %rsp
leaq 0x1c2c5(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x1c3b6(%rip), %rax     # 0x507a0
movsd 0xb4fe(%rip), %xmm0     # 0x3f8f0
movsd %xmm0, (%rax)
leaq 0x1c2a3(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x3445d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl $0x0, %eax
jne 0x3444d
movq 0x10(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x3444d
movq 0x8(%rsp), %rdi
callq 0x34290
movq 0x8(%rsp), %rdi
callq 0x34240
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x34405
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jamesliu516[P]amrdg2d/initial_data.cpp
// Function: left_shock_sol(double, double, double, double, double&, double&, double&)
void left_shock_sol(double qr,double ur, double pr,double Ms,
	double &ql, double &ul, double &pl)//Ms shock wave Mach number
{
	double Mr;
	double ar;
	double gr;
	double mrs2;
	gr=GAMMA;
	ar=sqrt(gr*pr/qr);
	Mr=ur/ar;
	mrs2=(Mr-Ms)*(Mr-Ms);
	ql=qr*(gr+1)*mrs2/((gr-1)*mrs2+2.0);
	pl=pr*(2.0*gr*mrs2-(gr-1))/(gr+1);
	ul=(1.0-qr/ql)*Ms*ar+ur*qr/ql;
}

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movsd %xmm2, 0x40(%rsp)
movsd %xmm3, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movsd 0xad35(%rip), %xmm0     # 0x3f1d8
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x40(%rsp), %xmm0
divsd 0x50(%rsp), %xmm0
callq 0x31c0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
subsd 0x38(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
subsd 0x38(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0xab51(%rip), %xmm1     # 0x3f058
addsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0xab34(%rip), %xmm2     # 0x3f058
subsd %xmm2, %xmm1
movsd (%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd 0xab67(%rip), %xmm2     # 0x3f0a0
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x40(%rsp), %xmm0
movsd 0xab48(%rip), %xmm1     # 0x3f0a0
mulsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
movsd 0xaae7(%rip), %xmm4     # 0x3f058
subsd %xmm4, %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0xaab8(%rip), %xmm1     # 0x3f058
addsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x50(%rsp), %xmm1
movq 0x30(%rsp), %rax
divsd (%rax), %xmm1
movsd 0xaa8e(%rip), %xmm0     # 0x3f058
subsd %xmm1, %xmm0
mulsd 0x38(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x48(%rsp), %xmm1
mulsd 0x50(%rsp), %xmm1
movq 0x30(%rsp), %rax
divsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/initial_data.cpp
// Function: right_shock_sol(double, double, double, double, double&, double&, double&)
void right_shock_sol(double ql,double ul, double pl,double Ms,
	double &qr, double &ur, double &pr)//Ms shock wave Mach number
{
	double Ml;
	double al;
	double gr;
	double mrs2;
	gr=GAMMA;
	al=sqrt(gr*pl/ql);
	Ml=ul/al;
	mrs2=(Ml-Ms)*(Ml-Ms);
	qr=ql*(gr+1)*mrs2/((gr-1)*mrs2+2.0);
	pr=pl*(2.0*gr*mrs2-(gr-1))/(gr+1);
	ur=(1.0-ql/qr)*Ms*al+ul*ql/qr;
}

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movsd %xmm2, 0x40(%rsp)
movsd %xmm3, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movsd 0xab95(%rip), %xmm0     # 0x3f1d8
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x40(%rsp), %xmm0
divsd 0x50(%rsp), %xmm0
callq 0x31c0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
subsd 0x38(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
subsd 0x38(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0xa9b1(%rip), %xmm1     # 0x3f058
addsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0xa994(%rip), %xmm2     # 0x3f058
subsd %xmm2, %xmm1
movsd (%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd 0xa9c7(%rip), %xmm2     # 0x3f0a0
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x40(%rsp), %xmm0
movsd 0xa9a8(%rip), %xmm1     # 0x3f0a0
mulsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
movsd 0xa947(%rip), %xmm4     # 0x3f058
subsd %xmm4, %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0xa918(%rip), %xmm1     # 0x3f058
addsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x50(%rsp), %xmm1
movq 0x30(%rsp), %rax
divsd (%rax), %xmm1
movsd 0xa8ee(%rip), %xmm0     # 0x3f058
subsd %xmm1, %xmm0
mulsd 0x38(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x48(%rsp), %xmm1
mulsd 0x50(%rsp), %xmm1
movq 0x30(%rsp), %rax
divsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/tvbm_limiter4all.cpp
// Function: minmod3n(double, double, double)
double minmod3n(double a1, double a2, double a3)
{

    double tmp;
    if(a1>0.0 && a2>0.0 && a3>0.0) 
        tmp=min3(a1,a2,a3);
    else if(a1<0.0 && a2 < 0.0 && a3<0.0)
        tmp=max3(a1,a2,a3);
    else 
        tmp=0.0;
    return tmp;

}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movsd %xmm1, -0x10(%rsp)
movsd %xmm2, -0x18(%rsp)
movsd -0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x35720
movsd -0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x35720
movsd -0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x35720
movsd -0x8(%rsp), %xmm1
movsd -0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x356ab
movsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x28(%rsp)
jmp 0x356b7
movsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x28(%rsp), %xmm1
movsd -0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x35703
movsd -0x8(%rsp), %xmm1
movsd -0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x356e9
movsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x30(%rsp)
jmp 0x356f5
movsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x30(%rsp)
movsd -0x30(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
jmp 0x3570f
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
movsd -0x38(%rsp), %xmm0
movsd %xmm0, -0x20(%rsp)
jmp 0x357de
xorps %xmm0, %xmm0
ucomisd -0x8(%rsp), %xmm0
jbe 0x357d3
xorps %xmm0, %xmm0
ucomisd -0x10(%rsp), %xmm0
jbe 0x357d3
xorps %xmm0, %xmm0
ucomisd -0x18(%rsp), %xmm0
jbe 0x357d3
movsd -0x8(%rsp), %xmm0
ucomisd -0x10(%rsp), %xmm0
jbe 0x35769
movsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x40(%rsp)
jmp 0x35775
movsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x40(%rsp)
movsd -0x40(%rsp), %xmm0
ucomisd -0x18(%rsp), %xmm0
jbe 0x357b9
movsd -0x8(%rsp), %xmm0
ucomisd -0x10(%rsp), %xmm0
jbe 0x3579f
movsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x48(%rsp)
jmp 0x357ab
movsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x48(%rsp)
movsd -0x48(%rsp), %xmm0
movsd %xmm0, -0x50(%rsp)
jmp 0x357c5
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x50(%rsp)
movsd -0x50(%rsp), %xmm0
movsd %xmm0, -0x20(%rsp)
jmp 0x357dc
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rsp)
jmp 0x357de
movsd -0x20(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/tvbm_limiter4all.cpp
// Function: tvdm_limiter4all()
void tvdm_limiter4all()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag == 0 && current->flg<=2 ) {
#ifdef KXRCF_LIM
            if(pcell0->trb==true)
#endif
            tvbm_limiter(pcell0);
        }        
        current = current->next;
    }
}

// Assembly:
subq $0x18, %rsp
leaq 0x19415(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x372f8
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl $0x0, %eax
jne 0x372e8
movq 0x10(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x372e8
movq 0x8(%rsp), %rax
movb 0x210(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x372e6
movq 0x8(%rsp), %rdi
callq 0x35870
jmp 0x372e8
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x37293
addq $0x18, %rsp
retq
nopl (%rax)
// File: jamesliu516[P]amrdg2d/tvbm_limiter4all.cpp
// Function: pos_limiter4all()
void pos_limiter4all()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag == 0 && current->flg<=2 ) {
            pos_limiter(pcell0);
        }        
        current = current->next;
    }
}

// Assembly:
subq $0x18, %rsp
leaq 0x18885(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x37e71
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl $0x0, %eax
jne 0x37e61
movq 0x10(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x37e61
movq 0x8(%rsp), %rdi
callq 0x37300
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x37e23
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: setAllLeafbAvgFalse()
void setAllLeafbAvgFalse()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;

    current = HeadListAllGrid;     
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag%2 == 0 && current->flg<=2 ) {
            pcell0->bAvg=false;
        }
        current = current->next;
    }			
}

// Assembly:
leaq 0x18819(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, -0x8(%rsp)
leaq 0x1880a(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x37ef6
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movswl 0x1b0(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x37ee6
movq -0x8(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x37ee6
movq -0x10(%rsp), %rax
movb $0x0, 0x206(%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x37e9e
retq
nopw (%rax,%rax)
// File: jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: parent0bAvg(bodygridclass*)
void parent0bAvg(OctCell *pcell)
{
    int lev=pcell->level;
    OctCell *parent;
    parent=pcell->parent;
    int isum=0;

    // while(lev>=0) { //>0 or >=0 ?? TODO
    while(parent!=NULL) {
        if(parent->bAvg!=false){
            if(parent->children[0]->bAvg== false 
                && parent->children[1]->bAvg== false
                && parent->children[2]->bAvg== false
                && parent->children[3]->bAvg== false){
                parent->bAvg=false;
            }
            else{
                break;
            }

        }   
        ++isum;
        if(isum>back_para) break;
        parent=parent->parent;
    }        
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movswl 0x1f8(%rax), %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x37fff
movq -0x18(%rsp), %rax
movb 0x206(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x37fd5
movq -0x18(%rsp), %rax
movq 0x258(%rax), %rax
movb 0x206(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x37fd1
movq -0x18(%rsp), %rax
movq 0x260(%rax), %rax
movb 0x206(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x37fd1
movq -0x18(%rsp), %rax
movq 0x268(%rax), %rax
movb 0x206(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x37fd1
movq -0x18(%rsp), %rax
movq 0x270(%rax), %rax
movb 0x206(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x37fd1
movq -0x18(%rsp), %rax
movb $0x0, 0x206(%rax)
jmp 0x37fd3
jmp 0x37fff
jmp 0x37fd5
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x4, -0x1c(%rsp)
jle 0x37fe9
jmp 0x37fff
movq -0x18(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x37f2e
retq
// File: jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: parent_avg(bodygridclass*)
void parent_avg(OctCell *pcell)
{
    int lev=pcell->level;

    OctCell *parent;
    parent=pcell->parent;
    int isum=0;

    // while(lev>=0) { //>0 or >=0 ?? TODO
    while(parent!=NULL) {
        if(parent->bAvg!=true){
            if(parent->children[0]->bAvg== true 
                && parent->children[1]->bAvg== true
                && parent->children[2]->bAvg== true 
                && parent->children[3]->bAvg== true){
                limit_cell_avg(parent); //由儿子的单元平均获得父亲的单元平均
            }
            else{
                break;
            }

        }   
        ++isum;
        if(isum>back_para) break;
        parent=parent->parent;

    }        
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movswl 0x1f8(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x38101
movq 0x10(%rsp), %rax
movb 0x206(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
je 0x380d7
movq 0x10(%rsp), %rax
movq 0x258(%rax), %rax
movb 0x206(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x380d3
movq 0x10(%rsp), %rax
movq 0x260(%rax), %rax
movb 0x206(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x380d3
movq 0x10(%rsp), %rax
movq 0x268(%rax), %rax
movb 0x206(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x380d3
movq 0x10(%rsp), %rax
movq 0x270(%rax), %rax
movb 0x206(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x380d3
movq 0x10(%rsp), %rdi
callq 0x38110
jmp 0x380d5
jmp 0x38101
jmp 0x380d7
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jle 0x380eb
jmp 0x38101
movq 0x10(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x38032
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: limit_cell_avg(bodygridclass*)
void limit_cell_avg(OctCell *pcell)
{
    pcell->bAvg=true;

    for(int i=0; i<4;++i) {
        pcell->dof[i][0]=0.25*(pcell->children[0]->dof[i][0] 
            + pcell->children[1]->dof[i][0] 
            + pcell->children[2]->dof[i][0] +pcell->children[3]->dof[i][0] );
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x1, 0x206(%rax)
movl $0x0, -0xc(%rsp)
cmpl $0x4, -0xc(%rsp)
jge 0x381e9
movq -0x8(%rsp), %rax
movq 0x258(%rax), %rax
addq $0x30, %rax
movslq -0xc(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movq -0x8(%rsp), %rax
movq 0x260(%rax), %rax
addq $0x30, %rax
movslq -0xc(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
addsd (%rax), %xmm1
movq -0x8(%rsp), %rax
movq 0x268(%rax), %rax
addq $0x30, %rax
movslq -0xc(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
addsd (%rax), %xmm1
movq -0x8(%rsp), %rax
movq 0x270(%rax), %rax
addq $0x30, %rax
movslq -0xc(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
addsd (%rax), %xmm1
movsd 0x75e4(%rip), %xmm0     # 0x3f7a0
mulsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
addq $0x30, %rax
movslq -0xc(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x38129
retq
nopw (%rax,%rax)
// File: jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: tree_0bAvg()
void tree_0bAvg()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    short lev0;
    OctCell *pnbr[4]={NULL};
    short levnbr[4];

    current = HeadListAllGrid;     
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag%2 == 0 && current->flg<=2 ) {
            lev0=pcell0->level;

            pnbr[0]=EastNeighbor(pcell0);
            pnbr[1]=SouthNeighbor(pcell0);
            pnbr[2]=WestNeighbor(pcell0);
            pnbr[3]=NorthNeighbor(pcell0);

            for(int i=0;i<4;++i){
                levnbr[i]=pnbr[i]->level;
              //  reflg0[i]=pnbr[i]->reflag;
                if(lev0>levnbr[i]){
                    parent0bAvg(pcell0);     
                    //for(int j=0;j<4;++j){
                    //    parent0bAvg(pnbr[j]);     
                    //}
                    break;
                }
            }
        }
        current = current->next;
    }			
}

// Assembly:
subq $0x48, %rsp
leaq 0x184a5(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3150
leaq 0x18485(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x38325
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movswl 0x1b0(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x38312
movq 0x40(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x38312
movq 0x38(%rsp), %rax
movw 0x1f8(%rax), %ax
movw %ax, 0x36(%rsp)
movq 0x38(%rsp), %rdi
callq 0x118d0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11a00
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x117a0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11670
movq %rax, 0x28(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jge 0x38310
movslq 0x4(%rsp), %rax
movq 0x10(%rsp,%rax,8), %rax
movw 0x1f8(%rax), %cx
movslq 0x4(%rsp), %rax
movw %cx, 0x8(%rsp,%rax,2)
movswl 0x36(%rsp), %eax
movslq 0x4(%rsp), %rcx
movswl 0x8(%rsp,%rcx,2), %ecx
cmpl %ecx, %eax
jle 0x38301
movq 0x38(%rsp), %rdi
callq 0x37f00
jmp 0x38310
jmp 0x38303
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x382c0
jmp 0x38312
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x38223
addq $0x48, %rsp
retq
nopw (%rax,%rax)