LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jamesliu516[P]amrdg2d/tree_avg.cpp
// Function: tree_avg()
void tree_avg()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    OctCell *pnbr[4]={NULL};
    short levnbr[4]={0};
   // short reflgnbr[4]={0};
    short lev0;
    //short reflg0;

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

            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]){
                    parent_avg(pcell0);     
                    // for(int j=0;j<4;++j){
                   //   parent_avg(pnbr[j]);     
                     //}
                    break;
                }
            }
        }
        current = current->next;
    }			
}

// Assembly:
subq $0x48, %rsp
leaq 0x18365(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3150
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3150
leaq 0x18334(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x3846f
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 0x3845c
movq 0x40(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x3845c
movq 0x38(%rsp), %rax
movw 0x1f8(%rax), %ax
movw %ax, 0x6(%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, (%rsp)
cmpl $0x4, (%rsp)
jge 0x3845a
movslq (%rsp), %rax
movq 0x10(%rsp,%rax,8), %rax
movw 0x1f8(%rax), %cx
movslq (%rsp), %rax
movw %cx, 0x8(%rsp,%rax,2)
movswl 0x6(%rsp), %eax
movslq (%rsp), %rcx
movswl 0x8(%rsp,%rcx,2), %ecx
cmpl %ecx, %eax
jle 0x3844d
movq 0x38(%rsp), %rdi
callq 0x38000
jmp 0x3845a
jmp 0x3844f
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x38410
jmp 0x3845c
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x38374
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: getAdaptiveParameters(bodygridclass*)
void getAdaptiveParameters(OctCell *unp)
{
    double li;
    li=pow(sqrt(unp->dx*unp->dy),1.5);
    unp->tcur=fabs(unp->Ux[2]-unp->Uy[1])*li;
    unp->vorM=(unp->Ux[2]-unp->Uy[1])*unp->dx*unp->dy;
    unp->tdiv=fabs(unp->Ux[1]+unp->Uy[2])*li;
//0:den,1:press, 2:entropy,3:
#if ADAPTIVE_INDICATOR==0
    unp->pio=sqrt((unp->Ux[0]*unp->Ux[0])+(unp->Uy[0]*unp->Uy[0]))*li;
#elif ADAPTIVE_INDICATOR==1 
    unp->pio=sqrt((unp->Ux[3]*unp->Ux[3])+(unp->Uy[3]*unp->Uy[3]))*li;
#elif ADAPTIVE_INDICATOR==2
    double ason2, a2;//ason2:pressure
    ason2=GAM11*(unp->dof[3][0]-0.5*(unp->dof[1][0]*unp->dof[1][0]
   /unp->dof[0][0]+unp->dof[2][0]*unp->dof[2][0]/unp->dof[0][0]));
    a2=GAMMA*ason2/unp->dof[0][0];
    unp->pio=(fabs(unp->Ux[3]-a2*unp->Ux[0])
        +fabs(unp->Uy[3]-a2*unp->Uy[0]))*li;
#elif ADAPTIVE_INDICATOR==3
#else
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsd 0x288(%rax), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x290(%rax), %xmm0
callq 0x31c0
movsd 0x4df0(%rip), %xmm1     # 0x3f750
callq 0x3430
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsd 0x1c8(%rax), %xmm0
movq 0x10(%rsp), %rax
subsd 0x1e0(%rax), %xmm0
movaps 0x4874(%rip), %xmm1     # 0x3f200
pand %xmm1, %xmm0
mulsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x238(%rax)
movq 0x10(%rsp), %rax
movsd 0x1c8(%rax), %xmm0
movq 0x10(%rsp), %rax
subsd 0x1e0(%rax), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x288(%rax), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x290(%rax), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x208(%rax)
movq 0x10(%rsp), %rax
movsd 0x1c0(%rax), %xmm0
movq 0x10(%rsp), %rax
addsd 0x1e8(%rax), %xmm0
movaps 0x47fb(%rip), %xmm1     # 0x3f200
pand %xmm1, %xmm0
mulsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x240(%rax)
movq 0x10(%rsp), %rax
movsd 0x1b8(%rax), %xmm0
movq 0x10(%rsp), %rax
movsd 0x1b8(%rax), %xmm2
movq 0x10(%rsp), %rax
movsd 0x1d8(%rax), %xmm1
movq 0x10(%rsp), %rax
mulsd 0x1d8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x31c0
mulsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x248(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: charg_sol_gridAll()
void charg_sol_gridAll()//判断哪些网格单元需要加密
{
	Node *current;
	OctCell *lsbl;
	current = HeadListAllGrid;
//	Namr=0; //需要加密网格单元数目初始化
    solrefcell.clear();
	while(current != NULL)
	{
		lsbl = current->cell;
		if(current->flg==0 && lsbl->flag==0
#if NAR_MAXAMR==1
            && lsbl->level < lsbl->level0+Nar
#elif NAR_MAXAMR==0
            && lsbl->level < MaxAMR
#endif
            ) //最多只作MaxAMR次解自适应
            //20121111---------------------
  //          && lsbl->level < lsbl->level0+Nar) //最多只作Nar次解自适应
        {
            charg_sol_grid(lsbl);
        }
		current = current->next;
	}
}

// Assembly:
subq $0x18, %rsp
leaq 0x155f5(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x10326(%rip), %rdi     # 0x4b3e0
callq 0x1b440
cmpq $0x0, 0x10(%rsp)
je 0x3b11e
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movswl (%rax), %eax
cmpl $0x0, %eax
jne 0x3b10e
movq 0x8(%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl $0x0, %eax
jne 0x3b10e
movq 0x8(%rsp), %rax
movswl 0x1f8(%rax), %eax
cmpl $0x4, %eax
jge 0x3b10e
movq 0x8(%rsp), %rdi
callq 0x3ae20
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x3b0bf
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: find_sol_refp(bodygridclass**, bodygridclass*)
void find_sol_refp(OctCell *pp[],OctCell *parent)
{ 		
	pp[0]=EastNeighbor(parent);	
	pp[1]=WestNeighbor(parent);		
	pp[2]=NorthNeighbor(parent);
	pp[3]=SouthNeighbor(parent);	
	pp[4]=WestNeighbor(pp[2]);
	pp[5]=EastNeighbor(pp[2]);		
	pp[6]=WestNeighbor(pp[3]); 	
	pp[7]=EastNeighbor(pp[3]);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x118d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x117a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x11670
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdi
callq 0x11a00
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x117a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x118d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x117a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x118d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargeleveldifference(bodygridclass*)
int chargeleveldifference(OctCell *parent)
{
	int i;
	OctCell *pp[8]={NULL}; 
	int plevel,nlevel;//目标单元的层次-1，邻居单元的层次
	plevel=parent->level+1;
	find_sol_refp(pp,parent);
	for(i=0;i<8;i++)
	{
        if(pp[i]!=NULL)//here don't need if TODO
		{
			nlevel=pp[i]->level;
			if(abs(nlevel-plevel)>1)
			{break;}
		}
	}
	if(i==8) return(0);
	else return(1);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3150
movq 0x58(%rsp), %rax
movswl 0x1f8(%rax), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x3b130
movl $0x0, 0x54(%rsp)
cmpl $0x8, 0x54(%rsp)
jge 0x3b314
movslq 0x54(%rsp), %rax
cmpq $0x0, 0x10(%rsp,%rax,8)
je 0x3b305
movslq 0x54(%rsp), %rax
movq 0x10(%rsp,%rax,8), %rax
movswl 0x1f8(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
subl 0xc(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0x1, %eax
jle 0x3b303
jmp 0x3b314
jmp 0x3b305
jmp 0x3b307
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x3b2c4
cmpl $0x8, 0x54(%rsp)
jne 0x3b325
movl $0x0, 0x64(%rsp)
jmp 0x3b32d
movl $0x1, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: creat_sol_children(bodygridclass*)
void creat_sol_children(OctCell *parent)
{
	int j,m,preflag,dlevel;
	OctCell *children[4]={NULL};
	//double plevel,hx,hy;
	double hx1,hy1;
	if(parent!=NULL)//here do not need if TODO
	{
		preflag=parent->reflag;	
		dlevel=chargeleveldifference(parent);
		if(preflag==1||dlevel==1) return;//判断该网格单元是否加密
		else
		{
		//	plevel=parent->level+1;		
		//	hx=Hx/pow(2.0,plevel);hy=Hy/pow(2.0,plevel);//子网格的步长	
            hx1=0.5*parent->dx;
            hy1=0.5*parent->dy;
			for(m=0;m<4;++m)
			{
				//children[m]=(struct cell*)malloc(LENC);
                children[m]=new OctCell(hx1,hy1);

				parent->children[m]=children[m];
				childrenvalue(children[m],parent,hx1,hy1,m);
				charggrid0(children[m]);// here I omit is right TODO
			}
			parent->reflag=1;
//            parent->p_node=NULL;
		}
	}

	for(m=0;m<4;m++)
	{
		children[m]->level0=parent->level0;//
        son_cell_value(parent,m,children[m]);
	}				
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3150
cmpq $0x0, 0x60(%rsp)
je 0x3b4a5
movq 0x60(%rsp), %rax
movswl 0x1fc(%rax), %eax
movl %eax, 0x54(%rsp)
movq 0x60(%rsp), %rdi
callq 0x3b280
movl %eax, 0x50(%rsp)
cmpl $0x1, 0x54(%rsp)
je 0x3b392
cmpl $0x1, 0x50(%rsp)
jne 0x3b397
jmp 0x3b4f6
movq 0x60(%rsp), %rax
movsd 0x3d9c(%rip), %xmm0     # 0x3f140
mulsd 0x288(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x60(%rsp), %rax
movsd 0x3d81(%rip), %xmm0     # 0x3f140
mulsd 0x290(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x58(%rsp)
cmpl $0x4, 0x58(%rsp)
jge 0x3b495
movl $0x360, %edi            # imm = 0x360
callq 0x3250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x52b0
jmp 0x3b408
movq 0x8(%rsp), %rcx
movslq 0x58(%rsp), %rax
movq %rcx, 0x30(%rsp,%rax,8)
movslq 0x58(%rsp), %rax
movq 0x30(%rsp,%rax,8), %rdx
movq 0x60(%rsp), %rax
movslq 0x58(%rsp), %rcx
movq %rdx, 0x258(%rax,%rcx,8)
movslq 0x58(%rsp), %rax
movq 0x30(%rsp,%rax,8), %rdi
movq 0x60(%rsp), %rsi
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movl 0x58(%rsp), %edx
callq 0x1c970
movslq 0x58(%rsp), %rax
movq 0x30(%rsp,%rax,8), %rdi
callq 0x1c3f0
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x3b3d5
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x360, %esi            # imm = 0x360
callq 0x3260
jmp 0x3b4fb
movq 0x60(%rsp), %rax
movw $0x1, 0x1fc(%rax)
jmp 0x3b4a5
movl $0x0, 0x58(%rsp)
cmpl $0x4, 0x58(%rsp)
jge 0x3b4f6
movq 0x60(%rsp), %rax
movw 0x1fa(%rax), %cx
movslq 0x58(%rsp), %rax
movq 0x30(%rsp,%rax,8), %rax
movw %cx, 0x1fa(%rax)
movq 0x60(%rsp), %rdi
movl 0x58(%rsp), %esi
movslq 0x58(%rsp), %rax
movq 0x30(%rsp,%rax,8), %rdx
callq 0x3b510
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x3b4ad
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargsolgridforcoarse(bodygridclass*)
void chargsolgridforcoarse(OctCell *pg)//pg为网格单元的指针
{
    //	int refflag;
    bool refflag;
    switch(COAR)
    {
    case 0: refflag=(pg->tcur <coarse_coe*Sigma_curl
                && pg->tdiv <coarse_coe1*Sigma_div);
            break;
    case 1: refflag=(pg->tdiv <coarse_coe*Sigma_div); break;
    case 2: refflag=(pg->tcur <coarse_coe*Sigma_curl); break;
    case 3: refflag=(pg->pio <coarse_coe*Sigma_pio); break;
    case 4: refflag=(pg->tdiv <coarse_coe*Sigma_div
                && pg->pio <coarse_coe1*Sigma_pio);
            break;
    case 5:
            refflag=((!pg->trbamr)
                && pg->tdiv <coarse_coe*Sigma_div);
            if(pg->exflag!=0) refflag=true;
            break;
    }
#if IS_TUBE==1
//    if(pg->exflag!=0) refflag=true;//20121112
#endif
    if(refflag==true && pg->level>pg->level0)
    {
       // solcoacell[Ncoar]=pg;//用于存放需要粗化的网格单元地址的数组
        solcoacell.push_back(pg);
        pg->coflag=true;
       // Ncoar++;//记录需要粗化的网格单元的数目
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsd 0x240(%rax), %xmm1
movsd 0x3652(%rip), %xmm0     # 0x3f9e0
mulsd 0x22322(%rip), %xmm0    # 0x5e6b8
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, 0xe(%rsp)
jbe 0x3c3ca
movq 0x10(%rsp), %rax
movsd 0x248(%rax), %xmm1
movsd 0x3639(%rip), %xmm0     # 0x3f9f0
mulsd 0x22301(%rip), %xmm0    # 0x5e6c0
ucomisd %xmm1, %xmm0
seta %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x3c41b
movq 0x10(%rsp), %rax
movswl 0x1f8(%rax), %eax
movq 0x10(%rsp), %rcx
movswl 0x1fa(%rcx), %ecx
cmpl %ecx, %eax
jle 0x3c41b
leaq 0xeff3(%rip), %rdi      # 0x4b3f8
leaq 0x10(%rsp), %rsi
callq 0x1b460
movq 0x10(%rsp), %rax
movb $0x1, 0x1fe(%rax)
addq $0x18, %rsp
retq
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargegridforcoarse()
void chargegridforcoarse()
{
	Node *current;
	OctCell *lsbl;
	current = HeadListAllGrid;
    solcoacell.clear();
	//Ncoar=0; //需要粗化网格单元数目初始化
	while(current != NULL)
	{
		lsbl = current->cell;
#if IS_TUBE==0
		if(lsbl->flag== 0
#elif IS_TUBE==1
        if((lsbl->flag== 0 || lsbl->exflag!=0)
#endif
            && current->flg<=2)
			chargsolgridforcoarse(lsbl);
		current = current->next;
	}
}

// Assembly:
subq $0x18, %rsp
leaq 0x14275(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0xefbe(%rip), %rdi      # 0x4b3f8
callq 0x1b440
cmpq $0x0, 0x10(%rsp)
je 0x3c49e
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl $0x0, %eax
je 0x3c477
movq 0x8(%rsp), %rax
movswl 0x1b2(%rax), %eax
cmpl $0x0, %eax
je 0x3c48e
movq 0x10(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x3c48e
movq 0x8(%rsp), %rdi
callq 0x3c370
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x3c43f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargecoarselevel(bodygridclass*)
int chargecoarselevel(OctCell *pc)
{
	int i;
	OctCell *pp[8]={NULL};
	find_sol_refp(pp,pc);
	for(i=0;i<4;i++)
	{
		if(pp[i]!=NULL&&pp[i]->reflag==1) 
		//if(pp[i]->reflag==1) 
		{
			break;
		}
	}
	if(i==4) return(0);
	else return(1);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3150
movq %rsp, %rdi
movq 0x48(%rsp), %rsi
callq 0x3b130
movl $0x0, 0x44(%rsp)
cmpl $0x4, 0x44(%rsp)
jge 0x3cdb6
movslq 0x44(%rsp), %rax
cmpq $0x0, (%rsp,%rax,8)
je 0x3cda7
movslq 0x44(%rsp), %rax
movq (%rsp,%rax,8), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x1, %eax
jne 0x3cda7
jmp 0x3cdb6
jmp 0x3cda9
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x3cd7d
cmpl $0x4, 0x44(%rsp)
jne 0x3cdc7
movl $0x0, 0x54(%rsp)
jmp 0x3cdcf
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: creatcoarsegrid()
void creatcoarsegrid()
{   
    int kr,Nk;
    int i,ppflag;
    OctCell *parent,*p;
   // Nk=Ncoar-1;//需要加密的网格
   Nk=solcoacell.size()-1;
    //printf("coarse solution grid number: Nk=%d\n",Nk);		   

    for(kr=0;kr<=Nk;kr++)//Nk与解自适应网格数	 		  
    {		 		   		  		  
        OctCell *pp[4];
        //需要粗化的网格单元的兄弟网格单元的地址网格单元地址        		  			   
        p= solcoacell[kr];
        parent=p->parent;
        //	   printf("Kr=%d\n",kr);
        ppflag=0;
        if(parent!=NULL&&parent->reflag==1)
       // if(parent->reflag==1)
        {	   
          //  NOchild=p->NOchildren;
            for(i=0;i<4;i++)
            {
                pp[i]=parent->children[i];
                ppflag+=chargecoarselevel(pp[i]);
            } 
            if(ppflag==0 && pp[0]->coflag==true 
                && pp[1]->coflag==true && pp[2]->coflag==true 
                && pp[3]->coflag==true )//四个子节点都要粗华则粗化	   	   
            {				   
                creatsolcoarseparent(parent,pp);
                parent->coflag=false;
                parent->reflag=0;
            }
        }
    }
    cout<<"coarse solution grid number: Nk= "<<Nk<<endl;
}

// Assembly:
subq $0x48, %rsp
leaq 0xe60d(%rip), %rdi      # 0x4b3f8
callq 0x1bd50
subq $0x1, %rax
movl %eax, 0x40(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0x40(%rsp), %eax
jg 0x3cf43
movslq 0x44(%rsp), %rsi
leaq 0xe5de(%rip), %rdi      # 0x4b3f8
callq 0x1e180
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x38(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x3cf31
movq 0x30(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x1, %eax
jne 0x3cf31
movl $0x0, 0x3c(%rsp)
cmpl $0x4, 0x3c(%rsp)
jge 0x3ceae
movq 0x30(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movq 0x258(%rax,%rcx,8), %rcx
movslq 0x3c(%rsp), %rax
movq %rcx, (%rsp,%rax,8)
movslq 0x3c(%rsp), %rax
movq (%rsp,%rax,8), %rdi
callq 0x3cd50
addl 0x38(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x3ce69
cmpl $0x0, 0x38(%rsp)
jne 0x3cf2f
movq (%rsp), %rax
movb 0x1fe(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x3cf2f
movq 0x8(%rsp), %rax
movb 0x1fe(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x3cf2f
movq 0x10(%rsp), %rax
movb 0x1fe(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x3cf2f
movq 0x18(%rsp), %rax
movb 0x1fe(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x3cf2f
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
callq 0x3c4b0
movq 0x30(%rsp), %rax
movb $0x0, 0x1fe(%rax)
movq 0x30(%rsp), %rax
movw $0x0, 0x1fc(%rax)
jmp 0x3cf31
jmp 0x3cf33
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x3ce00
movq 0xe086(%rip), %rdi      # 0x4afd0
leaq 0x2cb1(%rip), %rsi      # 0x3fc02
callq 0x3240
movq %rax, %rdi
movl 0x40(%rsp), %esi
callq 0x3420
movq %rax, %rdi
movq 0xe04c(%rip), %rsi      # 0x4afb8
callq 0x3290
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargeholegrid(bodygridclass*)
int chargeholegrid(OctCell *pc)
{
	OctCell *pp[8];
	find_sol_refp(pp,pc);
     if((pp[0]!=NULL&&pp[0]->reflag==1&&pp[1]!=NULL&&pp[1]->reflag==1)
     ||(pp[2]!=NULL&&pp[2]->reflag==1&&pp[3]!=NULL&&pp[3]->reflag==1))
    //if((pp[0]->reflag==1&&pp[1]->reflag==1) 
      //  ||(pp[2]->reflag==1&&pp[3]->reflag==1))
        return(1);
	else
		return(0);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsp, %rdi
movq 0x48(%rsp), %rsi
callq 0x3b130
cmpq $0x0, (%rsp)
je 0x3cfc6
movq (%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x1, %eax
jne 0x3cfc6
cmpq $0x0, 0x8(%rsp)
je 0x3cfc6
movq 0x8(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x1, %eax
je 0x3cff8
cmpq $0x0, 0x10(%rsp)
je 0x3d002
movq 0x10(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x1, %eax
jne 0x3d002
cmpq $0x0, 0x18(%rsp)
je 0x3d002
movq 0x18(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x1, %eax
jne 0x3d002
movl $0x1, 0x54(%rsp)
jmp 0x3d00a
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: chargehillgrid(bodygridclass*)
int chargehillgrid(OctCell *pc)
{
    OctCell *pp[8],*parent;
    parent=pc->parent;
    if(parent!=NULL)
    {
        if(parent->reflag==1)
        {
            find_sol_refp(pp,parent);
            if((pp[0]!=NULL&&pp[0]->reflag==0
                    &&pp[1]!=NULL&&pp[1]->reflag==0)
                &&(pp[2]!=NULL&&pp[2]->reflag==0
                    &&pp[3]!=NULL&&pp[3]->reflag==0))
     // if((pp[0]->reflag==0&&pp[1]->reflag==0)
      //          &&(pp[2]->reflag==0&&pp[3]->reflag==0))
                return(1);	
            else		
                return(0);
        }
    }
    return(0);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq 0x250(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3d0e4
movq 0x8(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x1, %eax
jne 0x3d0e2
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3b130
cmpq $0x0, 0x10(%rsp)
je 0x3d0d8
movq 0x10(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x0, %eax
jne 0x3d0d8
cmpq $0x0, 0x18(%rsp)
je 0x3d0d8
movq 0x18(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x0, %eax
jne 0x3d0d8
cmpq $0x0, 0x20(%rsp)
je 0x3d0d8
movq 0x20(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x0, %eax
jne 0x3d0d8
cmpq $0x0, 0x28(%rsp)
je 0x3d0d8
movq 0x28(%rsp), %rax
movswl 0x1fc(%rax), %eax
cmpl $0x0, %eax
jne 0x3d0d8
movl $0x1, 0x64(%rsp)
jmp 0x3d0ec
movl $0x0, 0x64(%rsp)
jmp 0x3d0ec
jmp 0x3d0e4
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: solveEdge4Gradient(Face&, double*, double*)
void solveEdge4Gradient(Face &fc, double fjbx[],double fjby[])
{
    OctCell *lsbl,*lsbl0;

    lsbl0=fc.parent;
    lsbl=fc.neighbor;
    double ush0[4],ush[4];
    double ujb0[4],ujb[4];
    for(int i=0;i<4;++i)
    {
        ush0[i]=lsbl0->dof[i][0];
        ush[i]=lsbl->dof[i][0];
    }
    shbl2jbbl(ush0,ujb0);
    shbl2jbbl(ush,ujb);

    for(int i=0; i<4;++i){
        fjbx[i]=0.5*(ujb0[i]+ujb[i])*fc.nml[0]*fc.area;
        fjby[i]=0.5*(ujb0[i]+ujb[i])*fc.nml[1]*fc.area;
    }
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x90(%rsp)
movq 0xb0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x98(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jge 0x3d380
movq 0x90(%rsp), %rax
addq $0x30, %rax
movslq 0xc(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movslq 0xc(%rsp), %rax
movsd %xmm0, 0x70(%rsp,%rax,8)
movq 0x98(%rsp), %rax
addq $0x30, %rax
movslq 0xc(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movslq 0xc(%rsp), %rax
movsd %xmm0, 0x50(%rsp,%rax,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3d31e
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2e130
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2e130
movl $0x0, 0x8(%rsp)
cmpl $0x4, 0x8(%rsp)
jge 0x3d463
movslq 0x8(%rsp), %rax
movsd 0x30(%rsp,%rax,8), %xmm1
movslq 0x8(%rsp), %rax
addsd 0x10(%rsp,%rax,8), %xmm1
movsd 0x1d71(%rip), %xmm0     # 0x3f140
mulsd %xmm1, %xmm0
movq 0xb0(%rsp), %rax
mulsd 0x10(%rax), %xmm0
movq 0xb0(%rsp), %rax
mulsd 0xb0(%rax), %xmm0
movq 0xa8(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movslq 0x8(%rsp), %rax
movsd 0x30(%rsp,%rax,8), %xmm1
movslq 0x8(%rsp), %rax
addsd 0x10(%rsp,%rax,8), %xmm1
movsd 0x1d20(%rip), %xmm0     # 0x3f140
mulsd %xmm1, %xmm0
movq 0xb0(%rsp), %rax
mulsd 0x18(%rax), %xmm0
movq 0xb0(%rsp), %rax
mulsd 0xb0(%rax), %xmm0
movq 0xa0(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3d3a6
addq $0xb8, %rsp
retq
nopl (%rax,%rax)
// File: jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: SolutionAMR(int)
void SolutionAMR(int i)
{	
#ifndef KXRCF_AMR
    solveGradient();
	getAllAdpParametersList();
#else
    kxrcf_relate();
    face_kxrcf_all();
    set_kxrcf();
#endif
	charg_sol_gridAll();
	chargegridforcoarse();
	creatcoarsegrid();
	creat_amr_grid();
//    release_ColCoa();
    solrefcell.clear();//solution AMR cell
    solcoacell.clear();//solution coase cell

	cout<<"Adaptively Refine and Coarsen Mesh Complete>>>>>\n";
	smoothcell();		
	cout<<"Smooth Adaptively Mesh Complete>>>>>\n";
    releaseList();
    formListForAllGrid();

    setFlagForAll();

    releaseFaceCellList();
    formListFaceCellAll();   
#if IS_TUBE==1
    set_exFlag4All(NPT_EXT_WALL, ext_wall);
    formExtWallInOutBndry();
#endif
    face_vec();
    point_vec();     
 // outputcell_new(i);//output mesh
  //outputcell_sol(i);//output solution
#if HAVE_MV!=0
    for(int wy=0; wy<N_BODY;++wy){
        for(int i_t=0;i_t<MVptNum[wy];++i_t){  
            find_multivalue_cell(MBsharp_point[wy][i_t]);
        }
    }
#endif
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
callq 0x3a5d0
callq 0x3aa80
callq 0x3b0a0
callq 0x3c420
callq 0x3cde0
callq 0x3c050
leaq 0xdf43(%rip), %rdi      # 0x4b3e0
callq 0x1b440
leaq 0xdf4f(%rip), %rdi      # 0x4b3f8
callq 0x1b440
movq 0xdb1b(%rip), %rdi      # 0x4afd0
leaq 0x2771(%rip), %rsi      # 0x3fc2d
callq 0x3240
callq 0x3d100
movq 0xdb03(%rip), %rdi      # 0x4afd0
leaq 0x278b(%rip), %rsi      # 0x3fc5f
callq 0x3240
callq 0x1b260
callq 0x1abd0
callq 0x78d0
callq 0x1b2f0
callq 0x1b190
movl $0x138, %edi            # imm = 0x138
leaq 0x11e12(%rip), %rsi     # 0x4f310
callq 0x7c70
callq 0x1ae80
callq 0x11bb0
callq 0x8c40
movl $0x0, 0x10(%rsp)
cmpl $0x1, 0x10(%rsp)
jge 0x3d57e
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movslq 0x10(%rsp), %rdx
leaq 0x2697(%rip), %rcx      # 0x3fbd0
cmpl (%rcx,%rdx,4), %eax
jge 0x3d56f
movslq 0x10(%rsp), %rax
leaq 0x13296(%rip), %rdi     # 0x507e0
shlq $0x7, %rax
addq %rax, %rdi
movslq 0xc(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3d630
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3d529
jmp 0x3d571
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x3d51a
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jamesliu516[P]amrdg2d/multi_value_cell.cpp
// Function: insert_cell2(bodygridclass*, std::set<bodygridclass*, std::less<bodygridclass*>, std::allocator<bodygridclass*>>&)
void insert_cell2(OctCell *pp, set<OctCell*> &grid)
{
    if(pp->reflag==0){
        if(pp->flag%2==0)grid.insert(pp);
    }
    else {
        for(int m=0; m<4;++m) 
            insert_cell2(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 0x3d5e2
movq 0x20(%rsp), %rax
movswl 0x1b0(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3d5e0
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xb680
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
jmp 0x3d61c
movl $0x0, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jge 0x3d61a
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq 0x258(%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rsi
callq 0x3d590
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3d5ea
jmp 0x3d61c
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jamesliu516[P]amrdg2d/cal_te_res.cpp
// Function: cal_te_res()
void cal_te_res()
{
    Node *current;
    current = HeadListAllGrid;  
    OctCell *pcell0;
    double db_tmp=0.0;
    while(current != NULL)
    {		
        pcell0 = current->cell;
        if(pcell0->flag == 0 && current->flg<=2 ) {
            db_tmp+=pcell0->residual[0][0]*pcell0->residual[0][0]
                *pcell0->dx*pcell0->dy;
        }        
        current = current->next;
    }
    db_tmp=sqrt(db_tmp);
//    cout<<"rhoE ie. residual[3][0]->"<<scientific<<db_tmp<<"\n";
    cout<<"rho       "<<scientific<<db_tmp<<"\n";
}

// Assembly:
subq $0x18, %rsp
leaq 0x12de5(%rip), %rax     # 0x506a0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x3d95c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movswl 0x1b0(%rax), %eax
cmpl $0x0, %eax
jne 0x3d949
movq 0x10(%rsp), %rax
movswl (%rax), %eax
cmpl $0x2, %eax
jg 0x3d949
movq 0x8(%rsp), %rax
movsd 0x2a0(%rax), %xmm0
movq 0x8(%rsp), %rax
mulsd 0x2a0(%rax), %xmm0
movq 0x8(%rsp), %rax
mulsd 0x288(%rax), %xmm0
movq 0x8(%rsp), %rax
movsd 0x290(%rax), %xmm2
movsd (%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x3d8cb
movsd (%rsp), %xmm0
callq 0x31c0
movsd %xmm0, (%rsp)
movq 0xd65e(%rip), %rdi      # 0x4afd0
leaq 0x230c(%rip), %rsi      # 0x3fc85
callq 0x3240
movq %rax, %rdi
leaq 0x28(%rip), %rsi        # 0x3d9b0
callq 0x30e0
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x3480
movq %rax, %rdi
leaq 0x1946(%rip), %rsi      # 0x3f2ea
callq 0x3240
addq $0x18, %rsp
retq
nop
// File: jamesliu516[P]amrdg2d/riemannWallBound.cpp
// Function: solveERS(double, double, double, double, double*, double*)
void  solveERS(double dl,double ul, double pl, 
			  double uw, double *di,double *pi)
{
    double cM, A_M,B_M,aM;
    double du0;
    cM=ul-uw;
    A_M=g5/dl;
    B_M=pl*g6;

    du0=ul-uw;
    aM=sqrt(gama*pl/dl);

    if(du0<0.0){
        *pi=pl*pow(1.0+g7*cM/aM, g3);
        *di=dl*pow(*pi/pl, 1.0/gama);
    }
    else
    {
        *pi=pl+cM*0.5/A_M*(cM+sqrt(cM*cM+4.0*A_M*(B_M+pl)));
        *di=dl*(*pi/pl+g6)/(g6*(*pi)/pl+1.0);
    }
}

// Assembly:
subq $0x88, %rsp
movsd %xmm0, 0x80(%rsp)
movsd %xmm1, 0x78(%rsp)
movsd %xmm2, 0x70(%rsp)
movsd %xmm3, 0x68(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movsd 0x78(%rsp), %xmm0
subsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x2282(%rip), %xmm0     # 0x3fc98
divsd 0x80(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x2263(%rip), %xmm0     # 0x3fc90
mulsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x78(%rsp), %xmm0
subsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x1785(%rip), %xmm0     # 0x3f1d8
mulsd 0x70(%rsp), %xmm0
divsd 0x80(%rsp), %xmm0
callq 0x31c0
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x30(%rsp), %xmm0
jbe 0x3db11
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x2218(%rip), %xmm1     # 0x3fca8
mulsd 0x50(%rsp), %xmm1
divsd 0x38(%rsp), %xmm1
movsd 0x15b4(%rip), %xmm0     # 0x3f058
addsd %xmm1, %xmm0
movsd 0x21f0(%rip), %xmm1     # 0x3fca0
callq 0x3430
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x58(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x80(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x58(%rsp), %rax
movsd (%rax), %xmm0
divsd 0x70(%rsp), %xmm0
movsd 0x1cf7(%rip), %xmm1     # 0x3f7e8
callq 0x3430
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
mulsd %xmm1, %xmm0
movq 0x60(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x3dbfc
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x161b(%rip), %xmm0     # 0x3f140
mulsd 0x50(%rsp), %xmm0
divsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x50(%rsp), %xmm0
movsd 0x50(%rsp), %xmm2
movsd 0x1be9(%rip), %xmm1     # 0x3f740
mulsd 0x48(%rsp), %xmm1
movsd 0x40(%rsp), %xmm3
addsd 0x70(%rsp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x31c0
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movaps %xmm0, %xmm3
movsd 0x18(%rsp), %xmm0
addsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x58(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x80(%rsp), %xmm0
movq 0x58(%rsp), %rax
movsd (%rax), %xmm1
divsd 0x70(%rsp), %xmm1
movsd 0x20cc(%rip), %xmm2     # 0x3fc90
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movq 0x58(%rsp), %rax
movsd 0x20b7(%rip), %xmm1     # 0x3fc90
mulsd (%rax), %xmm1
divsd 0x70(%rsp), %xmm1
movsd 0x146d(%rip), %xmm2     # 0x3f058
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq 0x60(%rsp), %rax
movsd %xmm0, (%rax)
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/tests/midiclock.cpp
// Function: mycallback(double, std::vector<unsigned char, std::allocator<unsigned char>>*, void*)
void mycallback( double deltatime, std::vector< unsigned char > *message, void *user )
{
  unsigned int *clock_count = reinterpret_cast<unsigned int*>(user);

  // Ignore longer messages
  if (message->size() != 1)
    return;

  unsigned int msg = message->at(0);
  if (msg == 0xFA)
    std::cout << "START received" << std::endl;
  if (msg == 0xFB)
    std::cout << "CONTINUE received" << std::endl;
  if (msg == 0xFC)
    std::cout << "STOP received" << std::endl;
  if (msg == 0xF8) {
    if (++*clock_count == 24) {
      double bpm = 60.0 / 24.0 / deltatime;
      std::cout << "One beat, estimated BPM = " << bpm <<std::endl;
      *clock_count = 0;
    }
  }
  else
    *clock_count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e60
cmpq $0x1, %rax
je 0x3471
jmp 0x3575
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3e80
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0xfa, -0x24(%rbp)
jne 0x34af
movq 0x5b3c(%rip), %rdi      # 0x8fd0
leaq 0x2b85(%rip), %rsi      # 0x6020
callq 0x3150
movq %rax, %rdi
movq 0x5b16(%rip), %rsi      # 0x8fc0
callq 0x3180
cmpl $0xfb, -0x24(%rbp)
jne 0x34da
movq 0x5b11(%rip), %rdi      # 0x8fd0
leaq 0x2b69(%rip), %rsi      # 0x602f
callq 0x3150
movq %rax, %rdi
movq 0x5aeb(%rip), %rsi      # 0x8fc0
callq 0x3180
cmpl $0xfc, -0x24(%rbp)
jne 0x3505
movq 0x5ae6(%rip), %rdi      # 0x8fd0
leaq 0x2b50(%rip), %rsi      # 0x6041
callq 0x3150
movq %rax, %rdi
movq 0x5ac0(%rip), %rsi      # 0x8fc0
callq 0x3180
cmpl $0xf8, -0x24(%rbp)
jne 0x356b
movq -0x20(%rbp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
cmpl $0x18, %eax
jne 0x3569
movsd 0x2ae2(%rip), %xmm0     # 0x6008
divsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x5a99(%rip), %rdi      # 0x8fd0
leaq 0x2b11(%rip), %rsi      # 0x604f
callq 0x3150
movq %rax, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x32d0
movq %rax, %rdi
movq 0x5a66(%rip), %rsi      # 0x8fc0
callq 0x3180
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
jmp 0x3575
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tobias93[P]piano/rtmidi_build/tests/midiclock.cpp
// Function: clock_in()
int clock_in()
{
  RtMidiIn *midiin = 0;
  unsigned int clock_count = 0;

  try {

    // RtMidiIn constructor
    midiin = new RtMidiIn();

    // Call function to select port.
    if ( chooseInputPort( midiin ) == false ) goto cleanup;

    // Set our callback function.  This should be done immediately after
    // opening the port to avoid having incoming messages written to the
    // queue instead of sent to the callback function.
    midiin->setCallback( &mycallback, &clock_count );

    // Don't ignore sysex, timing, or active sensing messages.
    midiin->ignoreTypes( false, false, false );

    std::cout << "\nReading MIDI input ... press <enter> to quit.\n";
    char input;
    std::cin.get(input);

  } catch ( RtMidiError &error ) {
    error.printMessage();
  }

 cleanup:

  delete midiin;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x10, %edi
callq 0x3160
movq %rax, -0x58(%rbp)
jmp 0x35a7
movb $0x1, -0x42(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x32b0
movq -0x60(%rbp), %rdx
leaq 0x2aa7(%rip), %rsi      # 0x606a
leaq -0x40(%rbp), %rdi
callq 0x3ec0
jmp 0x35ce
movq -0x58(%rbp), %rdi
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
movl $0x64, %ecx
callq 0x30e0
jmp 0x35e4
movq -0x58(%rbp), %rax
movb $0x0, -0x42(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x30b0
leaq -0x41(%rbp), %rdi
callq 0x31a0
movq -0x8(%rbp), %rdi
callq 0x3720
movb %al, -0x61(%rbp)
jmp 0x3610
movb -0x61(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x36c6
jmp 0x36a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3678
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3657
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x30b0
leaq -0x41(%rbp), %rdi
callq 0x31a0
testb $0x1, -0x42(%rbp)
jne 0x3668
jmp 0x3676
movq -0x58(%rbp), %rdi
movl $0x10, %esi
callq 0x3170
jmp 0x3678
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x3716
movq -0x18(%rbp), %rdi
callq 0x3080
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
callq 0x3290
jmp 0x36a6
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x36be
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
leaq -0x291(%rip), %rsi      # 0x3440
leaq -0xc(%rbp), %rdx
callq 0x3f70
jmp 0x36dc
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x3fa0
jmp 0x36ed
movq 0x58dc(%rip), %rdi      # 0x8fd0
leaq 0x2983(%rip), %rsi      # 0x607e
callq 0x3150
jmp 0x3702
movq 0x58d7(%rip), %rdi      # 0x8fe0
leaq -0x43(%rbp), %rsi
callq 0x3220
jmp 0x3714
jmp 0x36a4
movq -0x18(%rbp), %rdi
callq 0x32a0
nop
// File: tobias93[P]piano/rtmidi_build/tests/midiclock.cpp
// Function: main
int main( int, const char *argv[] )
{
  std::string prog(argv[0]);
  if (prog.find("midiclock_in") != prog.npos) {
    clock_in();
  }
  else if (prog.find("midiclock_out") != prog.npos) {
    clock_out();
  }
  else {
    std::cout << "Don't know what to do as " << prog << std::endl;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x32b0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3ec0
jmp 0x3d71
leaq -0x31(%rbp), %rdi
callq 0x31a0
leaq -0x30(%rbp), %rdi
leaq 0x2398(%rip), %rsi      # 0x611d
xorl %eax, %eax
movl %eax, %edx
callq 0x32f0
cmpq $-0x1, %rax
je 0x3dd1
callq 0x3580
jmp 0x3d9b
jmp 0x3e36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x31a0
jmp 0x3e4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30b0
jmp 0x3e4f
leaq -0x30(%rbp), %rdi
leaq 0x234e(%rip), %rsi      # 0x612a
xorl %eax, %eax
movl %eax, %edx
callq 0x32f0
cmpq $-0x1, %rax
je 0x3df4
callq 0x3750
jmp 0x3df2
jmp 0x3e34
movq 0x51d5(%rip), %rdi      # 0x8fd0
leaq 0x2336(%rip), %rsi      # 0x6138
callq 0x3150
movq %rax, -0x60(%rbp)
jmp 0x3e0d
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3130
movq %rax, -0x68(%rbp)
jmp 0x3e20
movq -0x68(%rbp), %rdi
movq 0x5195(%rip), %rsi      # 0x8fc0
callq 0x3180
jmp 0x3e32
jmp 0x3e34
jmp 0x3e36
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30b0
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x32a0
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::addReporter(Catch::Ptr<Catch::IStreamingReporter> const&, Catch::Ptr<Catch::IStreamingReporter> const&)
Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter ) {
    Ptr<IStreamingReporter> resultingReporter;

    if( existingReporter ) {
        MultipleReporters* multi = existingReporter->tryAsMulti();
        if( !multi ) {
            multi = new MultipleReporters;
            resultingReporter = Ptr<IStreamingReporter>( multi );
            if( existingReporter )
                multi->add( existingReporter );
        }
        else
            resultingReporter = existingReporter;
        multi->add( additionalReporter );
    }
    else
        resultingReporter = additionalReporter;

    return resultingReporter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2abc0
movq -0x10(%rbp), %rdi
callq 0x2e620
movq %rax, -0x48(%rbp)
jmp 0xd5da
movq -0x48(%rbp), %rax
cmpq $0x0, %rax
je 0xd6fc
movq -0x10(%rbp), %rdi
callq 0x2bc90
movq %rax, -0x60(%rbp)
jmp 0xd5f7
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq 0x88(%rax), %rax
callq *%rax
movq %rax, -0x68(%rbp)
jmp 0xd60d
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xd6da
movl $0x28, %edi
callq 0xc560
movq %rax, -0x70(%rbp)
jmp 0xd630
movq -0x70(%rbp), %rdi
callq 0x2e650
jmp 0xd63b
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2a960
jmp 0xd652
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2ace0
jmp 0xd661
leaq -0x40(%rbp), %rdi
callq 0x2aa00
movq -0x10(%rbp), %rdi
callq 0x2e620
movq %rax, -0x78(%rbp)
jmp 0xd679
movq -0x78(%rbp), %rax
cmpq $0x0, %rax
je 0xd6d8
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e690
jmp 0xd692
jmp 0xd6d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xd72d
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0xc580
jmp 0xd72d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2aa00
jmp 0xd72d
jmp 0xd6eb
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ace0
jmp 0xd6e9
jmp 0xd6eb
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2e690
jmp 0xd6fa
jmp 0xd70d
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ace0
jmp 0xd70b
jmp 0xd70d
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xd720
movq -0x58(%rbp), %rdi
callq 0x2aa00
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2aa00
movq -0x28(%rbp), %rdi
callq 0xc990
nop
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::(anonymous namespace)::platformColourInstance()
IColourImpl* platformColourInstance() {
        Ptr<IConfig const> config = getCurrentContext().getConfig();
        UseColour::YesOrNo colourMode = config
            ? config->useColour()
            : UseColour::Auto;
        if( colourMode == UseColour::Auto )
            colourMode = (!isDebuggerActive() && isatty(STDOUT_FILENO) )
                ? UseColour::Yes
                : UseColour::No;
        return colourMode == UseColour::Yes
            ? PosixColourImpl::instance()
            : NoColourImpl::instance();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
callq 0xd0e0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq *%rax
movq -0x30(%rbp), %rdi
callq 0x43f50
movq %rax, -0x28(%rbp)
jmp 0xf830
movq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0xf866
leaq -0x8(%rbp), %rdi
callq 0x2be00
movq %rax, -0x38(%rbp)
jmp 0xf849
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x80(%rax), %rax
callq *%rax
movl %eax, -0x3c(%rbp)
jmp 0xf85e
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0xf86d
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0xf86d
movl -0x40(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xf8d4
callq 0x43f80
movb %al, -0x41(%rbp)
jmp 0xf883
movb -0x41(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x42(%rbp)
jne 0xf8a5
jmp 0xf892
movl $0x1, %edi
callq 0xc980
cmpl $0x0, %eax
setne %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %dl
movl $0x2, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0xf8d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x2a9a0
jmp 0xf91f
cmpl $0x1, -0xc(%rbp)
jne 0xf8ef
callq 0x2a5e0
movq %rax, -0x50(%rbp)
jmp 0xf8e5
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0xf904
callq 0x2a630
movq %rax, -0x60(%rbp)
jmp 0xf8fa
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0xf904
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x2a9a0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc990
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Session::run(int, char const* const*)
int run( int argc, char const* const* const argv ) {

            int returnCode = applyCommandLine( argc, argv );
            if( returnCode == 0 )
                returnCode = run();
            return returnCode;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x51300
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x2f0d1
movq -0x28(%rbp), %rdi
callq 0x51630
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static SectionTracker& acquire( TrackerContext& ctx, std::string const& name ) {
            SectionTracker* section = CATCH_NULL;

            ITracker& currentTracker = ctx.currentTracker();
            if( ITracker* childTracker = currentTracker.findChild( name ) ) {
                assert( childTracker );
                assert( childTracker->isSectionTracker() );
                section = static_cast<SectionTracker*>( childTracker );
            }
            else {
                section = new SectionTracker( name, ctx, &currentTracker );
                currentTracker.addChild( section );
            }
            if( !ctx.completedCycle() && !section->isComplete() ) {

                section->open();
            }
            return *section;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x37880
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x37777
cmpq $0x0, -0x28(%rbp)
je 0x37717
jmp 0x37736
leaq 0x3f546(%rip), %rdi     # 0x76c64
leaq 0x3f337(%rip), %rsi     # 0x76a5c
movl $0x164a, %edx           # imm = 0x164A
leaq 0x3f540(%rip), %rcx     # 0x76c71
callq 0xc3b0
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
testb $0x1, %al
jne 0x37749
jmp 0x3774b
jmp 0x3776a
leaq 0x3f58e(%rip), %rdi     # 0x76ce0
leaq 0x3f303(%rip), %rsi     # 0x76a5c
movl $0x164b, %edx           # imm = 0x164B
leaq 0x3f50c(%rip), %rcx     # 0x76c71
callq 0xc3b0
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x37810
movl $0x60, %edi
callq 0xc560
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x378a0
jmp 0x3779e
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x378f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq (%rdi), %rax
movq 0x68(%rax), %rax
callq *%rax
jmp 0x377d2
leaq -0x40(%rbp), %rdi
callq 0x35c50
jmp 0x37810
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x60, %esi
callq 0xc580
jmp 0x3783e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35c50
jmp 0x3783e
movq -0x8(%rbp), %rdi
callq 0x37930
testb $0x1, %al
jne 0x37834
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x37834
movq -0x18(%rbp), %rdi
callq 0x37950
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xc990
nopw (%rax,%rax)