LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movswl 0x1f8(%rsi), %ebx
notl %ebx
callq 0x18fcf
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x190db
movq (%rsp,%rcx,8), %rax
testq %rax, %rax
je 0x190d6
movswl 0x1f8(%rax), %eax
addl %ebx, %eax
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
cmpl $0x1, %edx
ja 0x190db
incq %rcx
jmp 0x190b2
xorl %eax, %eax
cmpq $0x8, %rcx
setne %al
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, 0x10(%rsp)
testq %rdi, %rdi
je 0x191bd
movzwl 0x1fc(%rbx), %ebp
movq %rbx, %rdi
callq 0x19085
cmpw $0x1, %bp
je 0x191e9
testl %eax, %eax
jne 0x191e9
movsd 0x203f(%rip), %xmm0     # 0x1b178
movsd 0x288(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
mulsd 0x290(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0x191b4
movl $0x360, %edi            # imm = 0x360
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x44e8
movq %r15, 0x10(%rsp,%r14,8)
movq %r15, 0x258(%rbx,%r14,8)
movq %r15, %rdi
movq %rbx, %rsi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movl %r14d, %edx
callq 0xb823
movq %r15, %rdi
callq 0xb5f4
incq %r14
jmp 0x1915b
movw $0x1, 0x1fc(%rbx)
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0x191e9
movzwl 0x1fa(%rbx), %eax
movq 0x10(%rsp,%r14,8), %rdx
movw %ax, 0x1fa(%rdx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1920c
incq %r14
jmp 0x191c0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x360, %esi            # imm = 0x360
movq %r15, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/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:
leaq 0xee24(%rip), %rax      # 0x28610
leaq 0x9b75(%rip), %rcx      # 0x23368
movq (%rcx), %rdx
cmpq %rdx, 0x8(%rcx)
je 0x19800
movq %rdx, 0x8(%rcx)
pushq %rbx
movq (%rax), %rbx
testq %rbx, %rbx
je 0x19832
movq 0x8(%rbx), %rdi
cmpw $0x0, 0x1b0(%rdi)
je 0x19821
cmpw $0x0, 0x1b2(%rdi)
je 0x1982c
cmpw $0x2, (%rbx)
jg 0x1982c
callq 0x19773
movq 0x10(%rbx), %rbx
jmp 0x19804
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x18fcf
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x19b32
movq (%rsp,%rcx,8), %rax
testq %rax, %rax
je 0x19b2d
cmpw $0x1, 0x1fc(%rax)
je 0x19b32
incq %rcx
jmp 0x19b14
xorl %eax, %eax
cmpq $0x4, %rcx
setne %al
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x18fcf
movq (%rbx), %rcx
pushq $0x1
popq %rax
testq %rcx, %rcx
je 0x19c9e
cmpw $0x1, 0x1fc(%rcx)
sete %dl
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x19c9e
cmpw $0x1, 0x1fc(%rcx)
je 0x19cd4
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
je 0x19cd2
cmpw $0x1, 0x1fc(%rcx)
sete %dl
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x19cd2
cmpw $0x1, 0x1fc(%rcx)
je 0x19cd4
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x250(%rdi), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x19d74
cmpw $0x1, 0x1fc(%rsi)
jne 0x19d74
movq %rsp, %r14
movq %r14, %rdi
callq 0x18fcf
movq (%r14), %rax
testq %rax, %rax
je 0x19d74
cmpw $0x0, 0x1fc(%rax)
sete %cl
movq 0x8(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x19d74
cmpw $0x0, 0x1fc(%rax)
sete %cl
movq 0x10(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x19d74
cmpw $0x0, 0x1fc(%rax)
sete %cl
movq 0x18(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x19d74
cmpw $0x0, 0x1fc(%rax)
jne 0x19d74
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/solveAMR.cpp
// Function: smoothcell()
void smoothcell()
{
    //	long Nac;
    int hoflag,hiflag,i,nncell;
    Node *current;//新生成的四个节点
    OctCell *pc,*parent,*pp[4];//定义4个叶子节点的地址   
    int n_smth=3;
    do
    {
        //		releaselist(0);
        //		releasecelllist(Adpcelllist);
        //创建新的链表				
        //		Nac=FormAdpCellList(cartcell,cNx,cNy);

        releaseList();
        formListForAllGrid();
     //   setFlagForAll0();
        nncell=0;
        //current=Adpcelllist;
        current = HeadListAllGrid;

        while(current!=NULL)
        {             			
            pc=current->cell;
            if(pc->flag==0 && current->flg==0){
            //if(current->flg!=6){
                hiflag=0;
                hoflag=0;
                hoflag=chargeholegrid(pc);//判断是否是hole grid
//cout<<"smooth\n";
                //if(hoflag==1){printf("hoflag=%d\n",hoflag);getchar();}
                hiflag=chargehillgrid(pc);//判断是否是hill grid
                //if(hiflag==1){printf("hiflag=%d\n",hiflag);getchar();}
                /**/			
                if(hoflag==1) 
                {
                    creat_sol_children(pc);
                  //  pc->reflag=1;
                    nncell++;
                }

                if(hiflag==1)
                {	
                    parent=pc->parent;
                    for(i=0;i<4;i++)
                    {
                        pp[i]=parent->children[i];
                        pp[i]->coflag=true;
                    }
                    creatsolcoarseparent(parent,pp);
                    parent->coflag=false;
                    parent->reflag=0;
                    nncell++;
                }
            }
            current=current->next;
        }
        //	printf("nncell=%d\n",nncell);
        cout<<"nncell= "<<nncell<<endl;
        --n_smth;
    }while(nncell>0&& n_smth>0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
pushq $0x3
popq %r14
callq 0xb199
callq 0xad30
xorl %ebp, %ebp
leaq 0xe86d(%rip), %r15      # 0x28610
movq (%r15), %r15
testq %r15, %r15
je 0x19e3f
movq 0x8(%r15), %r12
cmpw $0x0, 0x1b0(%r12)
jne 0x19e36
cmpw $0x0, (%r15)
jne 0x19e36
movq %r12, %rdi
callq 0x19c56
movl %eax, %ebx
movq %r12, %rdi
callq 0x19cda
movl %eax, %r13d
testl %ebx, %ebx
je 0x19de9
movq %r12, %rdi
callq 0x190ea
incl %ebp
testl %r13d, %r13d
je 0x19e36
movq 0x250(%r12), %r12
xorl %eax, %eax
cmpq $0x4, %rax
je 0x19e16
movq 0x258(%r12,%rax,8), %rcx
movq %rcx, (%rsp,%rax,8)
movb $0x1, 0x1fe(%rcx)
incq %rax
jmp 0x19df8
movq %r12, %rdi
movq %rsp, %rsi
callq 0x19834
movb $0x0, 0x1fe(%r12)
andw $0x0, 0x1fc(%r12)
incl %ebp
addq $0x10, %r15
jmp 0x19da3
movq 0x917a(%rip), %rdi      # 0x22fc0
leaq 0x1ec7(%rip), %rsi      # 0x1bd14
callq 0x31d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x3330
movq %rax, %rdi
callq 0x30d0
testl %ebp, %ebp
jle 0x19e79
leal -0x1(%r14), %eax
cmpl $0x1, %r14d
movl %eax, %r14d
ja 0x19d90
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x19ec1
movsd 0x30(%rax,%r8), %xmm0
movsd %xmm0, -0x20(%rsp,%r9,8)
movsd 0x30(%rcx,%r8), %xmm0
movsd %xmm0, -0x40(%rsp,%r9,8)
incq %r9
addq $0x30, %r8
jmp 0x19e96
movsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x60(%rsp)
movupd -0x18(%rsp), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
divpd %xmm2, %xmm1
movupd %xmm1, -0x58(%rsp)
movapd %xmm1, %xmm2
mulpd %xmm1, %xmm2
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulsd %xmm1, %xmm1
addsd %xmm2, %xmm1
movsd 0x126f(%rip), %xmm2     # 0x1b170
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
addsd -0x8(%rsp), %xmm0
movsd 0x1311(%rip), %xmm1     # 0x1b228
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rsp)
movsd -0x40(%rsp), %xmm0
movsd %xmm0, -0x80(%rsp)
movupd -0x38(%rsp), %xmm3
movapd %xmm0, %xmm4
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
divpd %xmm4, %xmm3
movupd %xmm3, -0x78(%rsp)
movapd %xmm3, %xmm4
mulpd %xmm3, %xmm4
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
mulsd %xmm3, %xmm3
addsd %xmm4, %xmm3
mulsd %xmm2, %xmm0
mulsd %xmm3, %xmm0
addsd -0x28(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rsp)
xorl %eax, %eax
movsd 0x11fd(%rip), %xmm0     # 0x1b178
cmpq $0x4, %rax
je 0x19fbe
movsd -0x60(%rsp,%rax,8), %xmm1
addsd -0x80(%rsp,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd 0x10(%rdi), %xmm2
mulsd %xmm1, %xmm2
mulsd 0xb0(%rdi), %xmm2
movsd %xmm2, (%rsi,%rax,8)
mulsd 0x18(%rdi), %xmm1
mulsd 0xb0(%rdi), %xmm1
movsd %xmm1, (%rdx,%rax,8)
incq %rax
jmp 0x19f7b
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1899b
callq 0x18bbf
callq 0x18f80
callq 0x197e5
callq 0x19b40
callq 0x195dc
leaq 0x9367(%rip), %rax      # 0x23350
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x19ff6
movq %rcx, 0x8(%rax)
leaq 0x936b(%rip), %rax      # 0x23368
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x1a00a
movq %rcx, 0x8(%rax)
movq 0x8faf(%rip), %rbx      # 0x22fc0
leaq 0x1d05(%rip), %rsi      # 0x1bd1d
movq %rbx, %rdi
callq 0x31d0
callq 0x19d7e
leaq 0x1d23(%rip), %rsi      # 0x1bd4f
movq %rbx, %rdi
callq 0x31d0
callq 0xb199
callq 0xad30
callq 0x4e00
callq 0xb1e6
callq 0xb129
leaq 0xd22c(%rip), %rsi      # 0x27280
movl $0x138, %edi            # imm = 0x138
callq 0x4f80
callq 0xaed8
callq 0x86c2
callq 0x55dc
xorl %ebx, %ebx
leaq 0xe6da(%rip), %r14      # 0x28750
cmpq $0x30, %rbx
je 0x1a08b
leaq (%rbx,%r14), %rdi
callq 0x1a0f1
addq $0x10, %rbx
jmp 0x1a076
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
cmpw $0x0, 0x1fc(%rdi)
je 0x1a0d0
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x1a0e7
movq 0x258(%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1a094
incq %r15
jmp 0x1a0b5
testb $0x1, 0x1b0(%r14)
jne 0x1a0e7
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6a56
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jamesliu516[P]amrdg2d/multi_value_cell.cpp
// Function: find_multivalue_cell(pointxy const&)
void find_multivalue_cell(const PXYZ &sharppoint)
{
    double hcx, hcy;
    OctCell *cellflow=NULL;
    OctCell *in_this_cell=NULL;
    OctCell *ppvec[9]={NULL};
   // PXYZ point;
   // point=wallpoint[n_sharp_point];
    mvalue_set.clear();
    for(int i=1;i<=Nx*Ny;++i){
        cellflow=bodygrid+i;
        hcx=cellflow->dx;
        hcy=cellflow->dy;

        if(sharppoint.x < cellflow->xc1 + 0.5 * hcx + ERRS
            && sharppoint.x > cellflow->xc1 - 0.5 * hcx - ERRS
            && sharppoint.y < cellflow->yc1 + 0.5 * hcy + ERRS
            && sharppoint.y > cellflow->yc1 - 0.5 * hcy - ERRS){
            in_this_cell=cellflow;
            break;
        }
    }

    find_sol_refp(ppvec,in_this_cell);
    ppvec[8]=in_this_cell;
    for(int i=0; i<9;++i)
        insert_cell2(ppvec[i],mvalue_set);

    for(set<OctCell*>::iterator it_set=mvalue_set.begin();
        it_set!=mvalue_set.end();++it_set) {
        (*it_set)->mvflg=true;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
andq $0x0, 0x40(%rsp)
leaq 0xe602(%rip), %rdi      # 0x28720
callq 0x6a28
leaq 0x91b6(%rip), %rax      # 0x232e0
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movl $0x360, %ebx            # imm = 0x360
addq (%rax), %rbx
movl $0x1f3b, %eax           # imm = 0x1F3B
movsd 0x1030(%rip), %xmm2     # 0x1b178
movsd 0x1030(%rip), %xmm3     # 0x1b180
movsd 0x1018(%rip), %xmm4     # 0x1b170
movsd 0x1740(%rip), %xmm5     # 0x1b8a0
subq $0x1, %rax
jb 0x1a1f0
movsd 0x278(%rbx), %xmm7
movsd 0x288(%rbx), %xmm6
movapd %xmm6, %xmm8
mulsd %xmm2, %xmm8
addsd %xmm7, %xmm8
addsd %xmm3, %xmm8
ucomisd %xmm0, %xmm8
jbe 0x1a1e4
mulsd %xmm4, %xmm6
addsd %xmm7, %xmm6
addsd %xmm5, %xmm6
ucomisd %xmm6, %xmm0
jbe 0x1a1e4
movsd 0x290(%rbx), %xmm6
movsd 0x280(%rbx), %xmm7
movapd %xmm6, %xmm8
mulsd %xmm2, %xmm8
addsd %xmm7, %xmm8
addsd %xmm3, %xmm8
ucomisd %xmm1, %xmm8
jbe 0x1a1e4
mulsd %xmm4, %xmm6
addsd %xmm7, %xmm6
addsd %xmm5, %xmm6
ucomisd %xmm6, %xmm1
ja 0x1a1f2
addq $0x360, %rbx            # imm = 0x360
jmp 0x1a160
xorl %ebx, %ebx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18fcf
movq %rbx, 0x40(%r14)
xorl %r14d, %r14d
leaq 0xe512(%rip), %rbx      # 0x28720
cmpq $0x9, %r14
je 0x1a225
movq (%rsp,%r14,8), %rdi
movq %rbx, %rsi
callq 0x1a094
incq %r14
jmp 0x1a20e
movq 0x18(%rbx), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x1a247
movq 0x20(%rax), %rcx
movb $0x1, 0x1b4(%rcx)
movq %rax, %rdi
callq 0x3220
jmp 0x1a22d
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
xorpd %xmm0, %xmm0
leaq 0xe3b4(%rip), %rax      # 0x28610
movq (%rax), %rax
testq %rax, %rax
je 0x1a29e
movq 0x8(%rax), %rcx
cmpw $0x0, 0x1b0(%rcx)
jne 0x1a298
cmpw $0x2, (%rax)
jg 0x1a298
movsd 0x2a0(%rcx), %xmm1
mulsd %xmm1, %xmm1
mulsd 0x288(%rcx), %xmm1
mulsd 0x290(%rcx), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rax
jmp 0x1a25c
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1a2ae
sqrtsd %xmm0, %xmm0
jmp 0x1a2b3
callq 0x3180
movsd %xmm0, (%rsp)
movq 0x8d01(%rip), %rdi      # 0x22fc0
leaq 0x1aaf(%rip), %rsi      # 0x1bd75
callq 0x31d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rax,%rcx), %edx
orl $0x100, %edx            # imm = 0x100
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x32e0
leaq 0x1021(%rip), %rsi      # 0x1b31a
movq %rax, %rdi
popq %rax
jmp 0x31d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movapd %xmm1, %xmm4
movapd %xmm0, %xmm1
subsd %xmm3, %xmm4
movsd 0xf0b(%rip), %xmm0      # 0x1b230
movapd %xmm2, 0x10(%rsp)
mulsd %xmm2, %xmm0
divsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movsd %xmm1, 0x8(%rsp)
jb 0x1a349
sqrtsd %xmm0, %xmm0
jmp 0x1a35c
movsd %xmm4, (%rsp)
callq 0x3180
xorpd %xmm2, %xmm2
movsd (%rsp), %xmm4
ucomisd %xmm4, %xmm2
jbe 0x1a3b6
mulsd 0x170e(%rip), %xmm4     # 0x1ba78
divsd %xmm0, %xmm4
addsd 0xeaa(%rip), %xmm4      # 0x1b220
movsd 0x1a12(%rip), %xmm1     # 0x1bd90
movapd %xmm4, %xmm0
callq 0x3340
movapd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, (%r14)
divsd %xmm1, %xmm0
movsd 0x14d6(%rip), %xmm1     # 0x1b878
callq 0x3340
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
jmp 0x1a47a
movsd 0x19c2(%rip), %xmm1     # 0x1bd80
movapd 0x10(%rsp), %xmm3
mulsd %xmm3, %xmm1
movsd 0x19b8(%rip), %xmm0     # 0x1bd88
movsd 0x8(%rsp), %xmm2
divsd %xmm2, %xmm0
movsd 0xd96(%rip), %xmm5      # 0x1b178
mulsd %xmm4, %xmm5
divsd %xmm0, %xmm5
mulsd 0x1396(%rip), %xmm0     # 0x1b788
addsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm4, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1a416
sqrtsd %xmm0, %xmm0
jmp 0x1a437
movsd %xmm4, (%rsp)
movapd %xmm5, 0x20(%rsp)
callq 0x3180
movapd 0x20(%rsp), %xmm5
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm2
addsd %xmm0, %xmm4
mulsd %xmm4, %xmm5
movapd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm5
movsd %xmm5, (%r14)
movsd 0x192a(%rip), %xmm0     # 0x1bd80
mulsd %xmm5, %xmm0
unpcklpd %xmm0, %xmm5            # xmm5 = xmm5[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm5
addpd 0x1932(%rip), %xmm5     # 0x1bda0
mulsd %xmm5, %xmm2
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
divsd %xmm5, %xmm2
movsd %xmm2, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
andl $0x0, 0x4(%rsp)
xorl %r12d, %r12d
pushq $0x10
popq %rdi
callq 0x2130
movq %rax, %rbx
leaq 0x1c32(%rip), %rsi      # 0x4076
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x297e
leaq 0x8(%rsp), %rdx
pushq $0x64
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20d0
leaq 0x8(%rsp), %rdi
callq 0x2080
movq %rbx, %r12
movq %rbx, %rdi
callq 0x2546
testb %al, %al
je 0x24cf
leaq -0x129(%rip), %rsi      # 0x235c
leaq 0x4(%rsp), %rdx
movq %rbx, %r12
movq %rbx, %rdi
callq 0x29ba
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %rbx, %r12
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x48(%rax)
movq 0x3b21(%rip), %rdi      # 0x5fd0
leaq 0x1bd4(%rip), %rsi      # 0x408a
movq %rbx, %r12
callq 0x2120
movq 0x3b1b(%rip), %rdi      # 0x5fe0
leaq 0x3(%rsp), %rsi
callq 0x2180
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
jmp 0x251e
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2080
jmp 0x2506
movq %rdx, %r15
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x2140
xorl %ebx, %ebx
jmp 0x251e
movq %rdx, %r15
movq %rax, %r14
movq %r12, %rbx
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x2541
callq 0x2060
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
callq 0x21e0
testq %rbx, %rbx
jne 0x24cf
jmp 0x24d8
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq (%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x297e
leaq 0x1850(%rip), %rsi      # 0x4129
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2220
cmpq $-0x1, %rax
je 0x28f0
callq 0x241f
jmp 0x2938
leaq 0x183f(%rip), %rsi      # 0x4136
leaq 0x10(%rsp), %rdi
xorl %edx, %edx
callq 0x2220
cmpq $-0x1, %rax
je 0x2910
callq 0x2552
jmp 0x2938
movq 0x36b9(%rip), %rdi      # 0x5fd0
leaq 0x1826(%rip), %rsi      # 0x4144
callq 0x2120
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2090
leaq 0x10(%rsp), %rdi
callq 0x2080
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, (%rdi)
movq %rdx, %r14
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xadcf
movq %rsi, %r12
movq (%rdi), %rax
callq *0x88(%rax)
movq %rax, %r15
testq %rax, %rax
je 0xaddc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1942e
jmp 0xae32
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1942e
jmp 0xae41
pushq $0x28
popq %rdi
callq 0xa3d0
movq %rax, %r15
leaq 0x44942(%rip), %rax     # 0x4f730
movq %rax, (%r15)
xorps %xmm0, %xmm0
andq $0x0, 0x20(%r15)
movups %xmm0, 0x10(%r15)
movq %rsp, %rsi
movq %r15, (%rsi)
movl $0x1, 0x8(%r15)
movq %rbx, %rdi
callq 0x1942e
movq %rsp, %rdi
callq 0x193d8
cmpq $0x0, (%r12)
je 0xae32
movq %r15, %rdi
addq $0x10, %rdi
movq %r12, %rsi
callq 0x22896
addq $0x10, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x22896
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x193d8
jmp 0xae62
jmp 0xae5f
movq %rax, %r14
movq %rbx, %rdi
callq 0x193d8
movq %r14, %rdi
callq 0xa690
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
pushq $0x1
popq %rcx
callq 0x259dc
testl %eax, %eax
je 0x1acc0
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x25bc0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::ConsoleReporter::printTestCaseAndSectionHeader()
Generic::AnyOf<ExpressionT> Matcher<ExpressionT>::operator || ( Matcher<ExpressionT> const& other ) const {
        Generic::AnyOf<ExpressionT> anyOfExpr;
        anyOfExpr.add( *this );
        anyOfExpr.add( other );
        return anyOfExpr;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x1b0(%rdi), %rax
cmpq 0x1b8(%rdi), %rax
je 0x2ed5b
movq %rdi, %rbx
movq 0x90(%rdi), %rsi
callq 0x2ee14
movq 0x1b0(%rbx), %rsi
movq 0x1b8(%rbx), %rax
subq %rsi, %rax
pushq $0x68
popq %rcx
cqto
idivq %rcx
cmpq $0x2, %rax
jb 0x2ec38
movb $0x0, 0x10(%rsp)
pushq $0x1
popq %rdi
callq 0xc0f2
movq 0x1b0(%rbx), %rsi
movq 0x1b8(%rbx), %r15
addq $0x68, %rsi
pushq $0x2
popq %r14
cmpq %r15, %rsi
je 0x2ec27
leaq 0x68(%rsi), %r12
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2eeb8
movq %r12, %rsi
jmp 0x2ec0e
leaq 0x10(%rsp), %rdi
callq 0xc21c
movq 0x1b0(%rbx), %rsi
addq $0x40, %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xd2da
cmpq $0x0, 0x8(%r14)
je 0x2ece4
movq 0x18(%rbx), %rdi
cmpb $0x0, 0x21961(%rip)     # 0x505c0
jne 0x2ec92
movaps 0x4b38(%rip), %xmm0     # 0x337a0
movups %xmm0, 0x21990(%rip)    # 0x505ff
movaps %xmm0, 0x2197a(%rip)    # 0x505f0
movaps %xmm0, 0x21963(%rip)    # 0x505e0
movaps %xmm0, 0x2194c(%rip)    # 0x505d0
movaps %xmm0, 0x21935(%rip)    # 0x505c0
movb $0x0, 0x2197d(%rip)     # 0x5060f
leaq 0x21927(%rip), %rsi     # 0x505c0
callq 0xa3c0
leaq 0x6c65(%rip), %rsi      # 0x3590a
movq %rax, %rdi
callq 0xa3c0
movb $0x0, 0xf(%rsp)
pushq $0x17
popq %rdi
callq 0xc0f2
movq 0x18(%rbx), %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xb799
leaq 0x6c38(%rip), %rsi      # 0x3590a
movq %r14, %rdi
callq 0xa3c0
leaq 0xf(%rsp), %rdi
callq 0xc21c
movq 0x18(%rbx), %rdi
cmpb $0x0, 0x21921(%rip)     # 0x50610
jne 0x2ed22
movaps 0x4ab8(%rip), %xmm0     # 0x337b0
movups %xmm0, 0x21950(%rip)    # 0x5064f
movaps %xmm0, 0x2193a(%rip)    # 0x50640
movaps %xmm0, 0x21923(%rip)    # 0x50630
movaps %xmm0, 0x2190c(%rip)    # 0x50620
movaps %xmm0, 0x218f5(%rip)    # 0x50610
movb $0x0, 0x2193d(%rip)     # 0x5065f
leaq 0x218e7(%rip), %rsi     # 0x50610
callq 0xa3c0
leaq 0x6bd5(%rip), %rsi      # 0x3590a
movq %rax, %rdi
callq 0xa3c0
movq %rax, %rdi
callq 0xa1d0
leaq 0x10(%rsp), %rdi
callq 0xa778
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6868(%rip), %rdi      # 0x355ca
leaq 0x4c9f(%rip), %rsi      # 0x33a08
leaq 0x6bbb(%rip), %rcx      # 0x3592b
movl $0x262b, %edx           # imm = 0x262B
callq 0xa280
jmp 0x2ed8b
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xc21c
jmp 0x2ed8e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa778
jmp 0x2eda7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc21c
movq %rbx, %rdi
callq 0xa690
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x70(%rax)
testq %rax, %rax
je 0x1e5da
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x80(%rax)
testb %al, %al
jne 0x1e61a
leaq 0x156bd(%rip), %rdi     # 0x33c7f
leaq 0x1543f(%rip), %rsi     # 0x33a08
leaq 0x15640(%rip), %rcx     # 0x33c10
movl $0x164b, %edx           # imm = 0x164B
callq 0xa280
pushq $0x60
popq %rdi
callq 0xa3d0
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1e668
movq %rsp, %r12
movq %rbx, (%r12)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x68(%rax)
movq %rsp, %rdi
callq 0x1dd80
cmpl $0x2, 0x10(%r14)
je 0x1e636
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x1e636
movq %rbx, %rdi
callq 0x1e67e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x1dd80
jmp 0x1e660
movq %rax, %r14
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0xa3f0
movq %r14, %rdi
callq 0xa690
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::setUseColour(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void setUseColour( ConfigData& config, std::string const& value ) {
        std::string mode = toLower( value );

        if( mode == "yes" )
            config.useColour = UseColour::Yes;
        else if( mode == "no" )
            config.useColour = UseColour::No;
        else if( mode == "auto" )
            config.useColour = UseColour::Auto;
        else
            throw std::runtime_error( "colour mode must be one of: auto, yes or no" );
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc577
leaq 0xf9ea(%rip), %rsi      # 0x34281
movq %r14, %rdi
callq 0x1a737
testb %al, %al
je 0x248a7
pushq $0x1
jmp 0x248be
leaq 0xfb80(%rip), %rsi      # 0x3442e
leaq 0x8(%rsp), %rdi
callq 0x1a737
testb %al, %al
je 0x248c1
pushq $0x2
popq %rcx
jmp 0x248d8
leaq 0xfb38(%rip), %rsi      # 0x34400
leaq 0x8(%rsp), %rdi
callq 0x1a737
xorl %ecx, %ecx
testb %al, %al
je 0x248ed
movl %ecx, 0x24(%rbx)
leaq 0x8(%rsp), %rdi
callq 0xa778
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0xa1e0
movq %rax, %rbx
leaq 0xfb06(%rip), %rsi      # 0x34405
movq %rax, %rdi
callq 0xa170
movq 0x2b6e2(%rip), %rsi     # 0x4fff0
movq 0x2b68b(%rip), %rdx     # 0x4ffa0
movq %rbx, %rdi
callq 0xa650
movq %rax, %r14
jmp 0x2492d
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2f0
leaq 0x8(%rsp), %rdi
callq 0xa778
movq %r14, %rdi
callq 0xa690
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::parseInto(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, Catch::ConfigData&) const
std::vector<Parser::Token> parseInto( std::vector<std::string> const& args, ConfigT& config ) const {
            std::string processName = args[0];
            std::size_t lastSlash = processName.find_last_of( "/\\" );
            if( lastSlash != std::string::npos )
                processName = processName.substr( lastSlash+1 );
            m_boundProcessName.set( config, processName );
            std::vector<Parser::Token> tokens;
            Parser parser;
            parser.parseIntoTokens( args, tokens );
            return populate( tokens, config );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0xa4f0
leaq 0xe782(%rip), %rsi      # 0x34446
pushq $-0x1
popq %rdx
movq %r13, %rdi
callq 0xa3a0
cmpq $-0x1, %rax
je 0x25d03
incq %rax
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %rax, %rdx
callq 0xa410
leaq 0x28(%rsp), %rdi
movq %rsp, %r13
movq %r13, %rsi
callq 0xa490
movq %r13, %rdi
callq 0xa778
movq (%r15), %rdi
movq (%rdi), %rax
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x48(%rsp), %rdi
andl $0x0, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %r12, %rsi
callq 0x2630e
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x263b0
movq %rsp, %rdi
callq 0x23e54
leaq 0x28(%rsp), %rdi
callq 0xa778
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x25d71
movq %rax, %rbx
jmp 0x25d81
movq %rax, %rbx
movq %rsp, %rdi
callq 0x23e54
leaq 0x28(%rsp), %rdi
callq 0xa778
movq %rbx, %rdi
callq 0xa690
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::argsToVector[abi:cxx11](int, char const* const*)
inline std::vector<std::string> argsToVector( int argc, char const* const* const argv ) {
        std::vector<std::string> args( static_cast<std::size_t>( argc ) );
        for( std::size_t i = 0; i < static_cast<std::size_t>( argc ); ++i )
            args[i] = argv[i];

        return args;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movslq %esi, %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x2765c
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x25dd9
movq (%r14,%r13,8), %rsi
movq (%rbx), %rdi
addq %r12, %rdi
callq 0xa710
incq %r13
addq $0x20, %r12
jmp 0x25dbc
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x19462
movq %r14, %rdi
callq 0xa690
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::parseIntoTokens(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
void parseIntoTokens( std::string const& arg, std::vector<Token>& tokens ) {
            for( std::size_t i = 0; i <= arg.size(); ++i ) {
                char c = arg[i];
                if( c == '"' )
                    inQuotes = !inQuotes;
                mode = handleMode( i, c, arg, tokens );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpq 0x8(%r14), %r12
ja 0x26498
movq (%r14), %rax
movb (%rax,%r12), %al
cmpb $0x22, %al
jne 0x2647c
xorb $0x1, 0x10(%r15)
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
movq %rbx, %r8
callq 0x264a4
movl %eax, (%r15)
incq %r12
jmp 0x26466
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::handleMode(unsigned long, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
Mode handleMode( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
            switch( mode ) {
                case None: return handleNone( i, c );
                case MaybeShortOpt: return handleMaybeShortOpt( i, c );
                case ShortOpt:
                case LongOpt:
                case SlashOpt: return handleOpt( i, c, arg, tokens );
                case Positional: return handlePositional( i, c, arg, tokens );
                default: throw std::logic_error( "Unknown mode" );
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x5, %rax
ja 0x26510
leaq 0xd2ad(%rip), %r9       # 0x33764
movslq (%r9,%rax,4), %rax
addq %r9, %rax
jmpq *%rax
movsbl %dl, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26554
cmpb $0x2d, %dl
jne 0x26501
cmpb $0x0, 0x10(%rdi)
jne 0x26501
pushq $0x1
jmp 0x26507
xorl %eax, %eax
cmpb $0x2d, %dl
sete %al
addq %rax, %rsi
addl $0x3, %eax
movq %rsi, 0x8(%rdi)
jmp 0x26508
movsbl %dl, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x266f2
movq %rsi, 0x8(%rdi)
pushq $0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0xa1e0
movq %rax, %rbx
leaq 0xdf27(%rip), %rsi      # 0x34449
movq %rax, %rdi
callq 0xa500
movq 0x29a9f(%rip), %rsi     # 0x4ffd0
movq 0x29a70(%rip), %rdx     # 0x4ffa8
movq %rbx, %rdi
callq 0xa650
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2f0
movq %r14, %rdi
callq 0xa690
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::handleOpt(unsigned long, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
Mode handleOpt( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
            if( std::string( ":=\0", 5 ).find( c ) == std::string::npos )
                return mode;

            std::string optName = arg.substr( from, i-from );
            if( mode == ShortOpt )
                for( std::size_t j = 0; j < optName.size(); ++j )
                    tokens.push_back( Token( Token::ShortOpt, optName.substr( j, 1 ) ) );
            else if( mode == SlashOpt && optName.size() == 1 )
                tokens.push_back( Token( Token::ShortOpt, optName ) );
            else
                tokens.push_back( Token( Token::LongOpt, optName ) );
            return None;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movl $0x3d3a, (%rax)         # imm = 0x3D3A
andw $0x0, 0x4(%rax)
movq $0x5, -0x8(%rax)
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0xa4d0
movq %rax, %rbp
movq %r13, %rdi
callq 0xa778
cmpq $-0x1, %rbp
je 0x2663a
movq 0x8(%r14), %rdx
subq %rdx, %r12
movq %rsp, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0xa410
movl (%r14), %eax
cmpl $0x2, %eax
je 0x2663f
cmpl $0x3, %eax
jne 0x2666e
leaq 0x28(%rsp), %r14
xorl %r15d, %r15d
leaq 0x48(%rsp), %r12
pushq $0x1
popq %rbp
leaq 0x20(%rsp), %r13
cmpq 0x8(%rsp), %r15
jae 0x2669b
movq %r12, %rdi
movq %rsp, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0xa410
movl $0x1, 0x20(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xa4f0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x26868
movq %r14, %rdi
callq 0xa778
movq %r12, %rdi
callq 0xa778
incq %r15
jmp 0x265eb
movl (%r14), %eax
jmp 0x266a5
cmpq $0x1, 0x8(%rsp)
jne 0x2666e
leaq 0x28(%rsp), %r14
movl $0x1, -0x8(%r14)
movq %rsp, %rsi
movq %r14, %rdi
callq 0xa4f0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x26868
jmp 0x26693
leaq 0x28(%rsp), %r14
movl $0x2, -0x8(%r14)
movq %rsp, %rsi
movq %r14, %rdi
callq 0xa4f0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x26868
movq %r14, %rdi
callq 0xa778
movq %rsp, %rdi
callq 0xa778
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x266b8
jmp 0x266c2
movq %rax, %rbx
movq %r14, %rdi
jmp 0x266dc
jmp 0x266c2
movq %rax, %rbx
jmp 0x266e1
movq %rax, %rbx
jmp 0x266d7
movq %rax, %rbx
movq %r14, %rdi
callq 0xa778
leaq 0x48(%rsp), %rdi
callq 0xa778
movq %rsp, %rdi
callq 0xa778
movq %rbx, %rdi
callq 0xa690
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::handlePositional(unsigned long, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
Mode handlePositional( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
            if( inQuotes || std::string( "\0", 3 ).find( c ) == std::string::npos )
                return mode;

            std::string data = arg.substr( from, i-from );
            tokens.push_back( Token( Token::Positional, data ) );
            return None;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r12
cmpb $0x0, 0x10(%rdi)
jne 0x2679c
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andl $0x0, (%rax)
movq $0x3, -0x8(%rax)
movsbl %dl, %esi
movq %rsp, %r13
movq %r13, %rdi
xorl %edx, %edx
callq 0xa4d0
movq %rax, %rbp
movq %r13, %rdi
callq 0xa778
cmpq $-0x1, %rbp
je 0x2679c
movq 0x8(%r12), %rdx
subq %rdx, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xa410
leaq 0x8(%rsp), %r14
andl $0x0, -0x8(%r14)
movq %r14, %rdi
movq %r12, %rsi
callq 0xa4f0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x26868
movq %r14, %rdi
callq 0xa778
leaq 0x28(%rsp), %rdi
callq 0xa778
xorl %eax, %eax
jmp 0x267a0
movl (%r12), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xa778
jmp 0x267bf
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa778
movq %rbx, %rdi
callq 0xa690
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::insert(std::pair<int const, myvalue> const&)
std::pair<iterator, bool> insert(const value_type& item)
		{
			if (_size >= max_size())
			{
				return std::pair<iterator, bool>(end(), false);
			}
			
			new (&_keys[_size]) key_type(item.first);
			new (&_values[_size]) mapped_type(item.second);
			return std::pair<iterator, bool>(iterator(this, _size++), true);
		}

// Assembly:
movq %rdi, %rax
movl (%rsi), %ecx
movl %ecx, %edi
shrl $0x10, %edi
movzwl %cx, %r8d
cmpl %r8d, %edi
jae 0x2974e
movq 0x8(%rsi), %rcx
movl (%rdx), %r8d
movl %r8d, (%rcx,%rdi,4)
movq 0x10(%rsi), %rcx
movzwl 0x2(%rsi), %edi
movl 0x4(%rdx), %edx
movl %edx, (%rcx,%rdi,4)
movl (%rsi), %edx
movl %edx, %ecx
shrl $0x10, %ecx
andl $0xffff0000, %edx       # imm = 0xFFFF0000
addl $0x10000, %edx          # imm = 0x10000
shrl $0x10, %edx
movw %dx, 0x2(%rsi)
movb $0x1, %dl
jmp 0x29750
xorl %edx, %edx
movq %rsi, (%rax)
movw %cx, 0x8(%rax)
movb %dl, 0x10(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::at(int const&)
mapped_type& at(const key_type& key)
		{
			const_iterator it(_find(key));
			
			if (it == end())
			{
				throw std::out_of_range("item not found");
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a65a
movzwl 0x8(%r14), %eax
cmpq %rbx, (%r14)
jne 0x297ba
cmpw (%rbx), %ax
je 0x297cc
movzwl %ax, %eax
shll $0x2, %eax
addq 0x10(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0xa1e0
movq %rax, %rbx
leaq 0xbcc0(%rip), %rsi      # 0x3549e
movq %rax, %rdi
callq 0xa070
movq 0x267d3(%rip), %rsi     # 0x4ffc0
movq 0x267c4(%rip), %rdx     # 0x4ffb8
movq %rbx, %rdi
callq 0xa650
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2f0
movq %r14, %rdi
callq 0xa690
nop