LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c189
cmpw $0x1, 0x1fc(%rsi)
jne 0x1c189
movq %rsp, %r14
movq %r14, %rdi
callq 0x1b384
movq (%r14), %rax
testq %rax, %rax
je 0x1c189
cmpw $0x0, 0x1fc(%rax)
sete %cl
movq 0x8(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1c189
cmpw $0x0, 0x1fc(%rax)
sete %cl
movq 0x10(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1c189
cmpw $0x0, 0x1fc(%rax)
sete %cl
movq 0x18(%rsp), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1c189
cmpw $0x0, 0x1fc(%rax)
jne 0x1c189
movl $0x1, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0xc, %r8d
xorl %r9d, %r9d
movsd -0x30(%rax,%r8,8), %xmm0
movhps (%rax,%r8,8), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, -0x20(%rsp,%r9,8)
movsd -0x30(%rcx,%r8,8), %xmm0
movhps (%rcx,%r8,8), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movaps %xmm0, -0x40(%rsp,%r9,8)
addq $0x2, %r9
addq $0xc, %r8
cmpq $0x4, %r9
jne 0x1c2e3
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 0xdeb(%rip), %xmm2      # 0x1d140
mulsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
addsd -0x8(%rsp), %xmm0
movsd 0xe3d(%rip), %xmm1      # 0x1d1a8
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 0xd79(%rip), %xmm0      # 0x1d148
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
cmpq $0x4, %rax
jne 0x1c3cf
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ad0a
callq 0x1af3e
callq 0x1b335
callq 0x1bbcf
callq 0x1bf28
callq 0x1b98a
leaq 0x7f15(%rip), %rax      # 0x24350
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x1c448
movq %rcx, 0x8(%rax)
leaq 0x7f19(%rip), %rax      # 0x24368
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x1c45c
movq %rcx, 0x8(%rax)
movq 0x7b65(%rip), %rbx      # 0x23fc8
leaq 0x1933(%rip), %rsi      # 0x1dd9d
movl $0x31, %edx
movq %rbx, %rdi
callq 0x3250
callq 0x1c193
leaq 0x194c(%rip), %rsi      # 0x1ddcf
movl $0x25, %edx
movq %rbx, %rdi
callq 0x3250
callq 0xbfa2
callq 0xbae8
callq 0x4e90
callq 0xbff7
callq 0xbf33
leaq 0xbdd0(%rip), %rsi      # 0x28280
movl $0x138, %edi            # imm = 0x138
callq 0x5014
callq 0xbc9f
callq 0x8e6a
callq 0x56ac
xorl %ebx, %ebx
leaq 0xd27e(%rip), %r14      # 0x29750
leaq (%rbx,%r14), %rdi
callq 0x1c54d
addq $0x10, %rbx
cmpq $0x30, %rbx
jne 0x1c4d2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c52c
xorl %r15d, %r15d
movq 0x258(%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1c4f0
incq %r15
cmpq $0x4, %r15
jne 0x1c511
jmp 0x1c543
testb $0x1, 0x1b0(%r14)
jne 0x1c543
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6c64
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x40(%rsp)
leaq 0xd1a3(%rip), %rdi      # 0x29720
callq 0x6c36
leaq 0x7d57(%rip), %rax      # 0x242e0
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movl $0x360, %ebx            # imm = 0x360
addq (%rax), %rbx
movl $0x1f3b, %eax           # imm = 0x1F3B
movsd 0xba1(%rip), %xmm2      # 0x1d148
movsd 0xba1(%rip), %xmm3      # 0x1d150
movsd 0xb89(%rip), %xmm4      # 0x1d140
movsd 0x12b1(%rip), %xmm5     # 0x1d870
movsd 0x278(%rbx), %xmm7
movsd 0x288(%rbx), %xmm6
movapd %xmm6, %xmm8
mulsd %xmm2, %xmm8
addsd %xmm7, %xmm8
addsd %xmm3, %xmm8
ucomisd %xmm0, %xmm8
jbe 0x1c639
mulsd %xmm4, %xmm6
addsd %xmm7, %xmm6
addsd %xmm5, %xmm6
ucomisd %xmm6, %xmm0
jbe 0x1c639
movsd 0x290(%rbx), %xmm6
movsd 0x280(%rbx), %xmm7
movapd %xmm6, %xmm8
mulsd %xmm2, %xmm8
addsd %xmm7, %xmm8
addsd %xmm3, %xmm8
ucomisd %xmm1, %xmm8
jbe 0x1c639
mulsd %xmm4, %xmm6
addsd %xmm7, %xmm6
addsd %xmm5, %xmm6
ucomisd %xmm6, %xmm1
ja 0x1c64b
addq $0x360, %rbx            # imm = 0x360
decq %rax
jne 0x1c5bf
xorl %ebx, %ebx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b384
movq %rbx, 0x40(%r14)
xorl %r14d, %r14d
leaq 0xd0b9(%rip), %rbx      # 0x29720
movq (%rsp,%r14,8), %rdi
movq %rbx, %rsi
callq 0x1c4f0
incq %r14
cmpq $0x9, %r14
jne 0x1c667
movq 0x18(%rbx), %rax
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x1c69e
movq 0x20(%rax), %rcx
movb $0x1, 0x1b4(%rcx)
movq %rax, %rdi
callq 0x3260
jmp 0x1c684
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
leaq 0xcf5c(%rip), %rax      # 0x29610
movq (%rax), %rax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x1c6fe
movq 0x8(%rax), %rcx
cmpw $0x0, 0x1b0(%rcx)
jne 0x1c6f8
cmpw $0x2, (%rax)
jg 0x1c6f8
movsd 0x2a0(%rcx), %xmm2
mulsd %xmm2, %xmm2
mulsd 0x288(%rcx), %xmm2
mulsd 0x290(%rcx), %xmm2
addsd %xmm2, %xmm0
movq 0x10(%rax), %rax
jmp 0x1c6bf
ucomisd %xmm1, %xmm0
jb 0x1c70a
sqrtsd %xmm0, %xmm0
jmp 0x1c70f
callq 0x31b0
movsd %xmm0, 0x8(%rsp)
movq 0x78ac(%rip), %rbx      # 0x23fc8
leaq 0x16d2(%rip), %rsi      # 0x1ddf5
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3250
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl 0x18(%rbx,%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3300
leaq 0xb3b(%rip), %rsi       # 0x1d29a
movl $0x1, %edx
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x3250
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa1b(%rip), %xmm0      # 0x1d1b0
movapd %xmm2, 0x10(%rsp)
mulsd %xmm2, %xmm0
divsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movsd %xmm1, 0x8(%rsp)
jb 0x1c7b9
sqrtsd %xmm0, %xmm0
jmp 0x1c7cc
movsd %xmm4, (%rsp)
callq 0x31b0
xorpd %xmm2, %xmm2
movsd (%rsp), %xmm4
ucomisd %xmm4, %xmm2
jbe 0x1c826
mulsd 0x12de(%rip), %xmm4     # 0x1dab8
divsd %xmm0, %xmm4
addsd 0x9ba(%rip), %xmm4      # 0x1d1a0
movsd 0x1622(%rip), %xmm1     # 0x1de10
movapd %xmm4, %xmm0
callq 0x3360
movapd 0x10(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, (%r14)
divsd %xmm1, %xmm0
movsd 0x1036(%rip), %xmm1     # 0x1d848
callq 0x3360
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
jmp 0x1c8ea
movsd 0x15d2(%rip), %xmm1     # 0x1de00
movapd 0x10(%rsp), %xmm3
mulsd %xmm3, %xmm1
movsd 0x15c8(%rip), %xmm0     # 0x1de08
movsd 0x8(%rsp), %xmm2
divsd %xmm2, %xmm0
movsd 0x8f6(%rip), %xmm5      # 0x1d148
mulsd %xmm4, %xmm5
divsd %xmm0, %xmm5
mulsd 0xf06(%rip), %xmm0      # 0x1d768
addsd %xmm3, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm4, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1c886
sqrtsd %xmm0, %xmm0
jmp 0x1c8a7
movsd %xmm4, (%rsp)
movapd %xmm5, 0x20(%rsp)
callq 0x31b0
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 0x153a(%rip), %xmm0     # 0x1de00
mulsd %xmm5, %xmm0
unpcklpd %xmm0, %xmm5            # xmm5 = xmm5[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm5
addpd 0x1542(%rip), %xmm5     # 0x1de20
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_O3/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
movl $0x0, 0x4(%rsp)
xorl %ebx, %ebx
movl $0x10, %edi
callq 0x2100
movq %rax, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1c14(%rip), %rsi      # 0x4076
leaq 0x1c20(%rip), %rdx      # 0x4089
leaq 0x8(%rsp), %rdi
callq 0x330e
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x64, %ecx
callq 0x20b0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x249e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
leaq 0x1cb9(%rip), %rsi      # 0x415e
movq %rbx, %rdi
callq 0x2b95
testb %al, %al
je 0x24ff
movq 0x8(%rbx), %rdi
leaq -0x190(%rip), %rsi      # 0x232c
leaq 0x4(%rsp), %rdx
callq 0x2040
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x48(%rax)
movq 0x3af3(%rip), %rdi      # 0x5fd0
leaq 0x1ba6(%rip), %rsi      # 0x408a
movl $0x2f, %edx
callq 0x2120
movq 0x3aeb(%rip), %rdi      # 0x5fe0
leaq 0x3(%rsp), %rsi
callq 0x2150
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x254e
movq %rdx, %r15
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x253d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
jmp 0x253d
movq %rdx, %r15
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x2110
xorl %ebx, %ebx
jmp 0x2554
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x2577
callq 0x2050
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
callq 0x21a0
testq %rbx, %rbx
jne 0x24ff
jmp 0x2508
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b58
leaq 0x16b3(%rip), %rsi      # 0x4129
movl $0xc, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x21c0
cmpq $-0x1, %rax
je 0x2a92
callq 0x242f
jmp 0x2b0f
leaq 0x169d(%rip), %rsi      # 0x4136
leaq 0x10(%rsp), %rdi
movl $0xd, %ecx
xorl %edx, %edx
callq 0x21c0
cmpq $-0x1, %rax
je 0x2ab7
callq 0x2588
jmp 0x2b0f
movq 0x3512(%rip), %rdi      # 0x5fd0
leaq 0x167f(%rip), %rsi      # 0x4144
movl $0x19, %edx
callq 0x2120
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x34f0(%rip), %rdi      # 0x5fd0
callq 0x2120
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b2a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2110
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b50
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdx, %r14
movq %rdi, %rbx
movq $0x0, (%rdi)
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xb200
movq %rsi, %r12
movq (%rdi), %rax
callq *0x88(%rax)
movq %rax, %r15
testq %rax, %rax
je 0xb20d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x223fe
jmp 0xb26f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x223fe
jmp 0xb27e
movl $0x28, %edi
callq 0xa380
movq %rax, %r15
leaq 0x524ef(%rip), %rax     # 0x5d710
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
movq %rsp, %rsi
movq %r15, (%rsi)
movl $0x1, 0x8(%r15)
movq %rbx, %rdi
callq 0x223fe
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xb259
movq (%rdi), %rax
callq *0x18(%rax)
cmpq $0x0, (%r12)
je 0xb26f
movq %r15, %rdi
addq $0x10, %rdi
movq %r12, %rsi
callq 0x2e77c
addq $0x10, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2e77c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb2c0
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xb2aa
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xb2aa
jmp 0xb2c0
jmp 0xb2a7
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb2b8
movq (%rdi), %rax
callq *0x18(%rax)
movq %r14, %rdi
callq 0xa660
movq %rax, %rdi
callq 0x233c5
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::CompactReporter::AssertionPrinter::printRemainingMessages(Catch::Colour::Code)
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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x20(%rdi), %rbp
movq 0x30(%rdi), %r12
cmpq %rbp, %r12
je 0x4112a
movq %rdi, %rbx
movb $0x0, 0xf(%rsp)
movl %esi, %edi
callq 0xcd4e
movq (%rbx), %r14
leaq 0x5bf0(%rip), %rsi      # 0x46bb0
movl $0x6, %edx
movq %r14, %rdi
callq 0xa400
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x59d2(%rip), %rsi      # 0x469af
leaq 0x59d2(%rip), %rdx      # 0x469b6
leaq 0x10(%rsp), %rdi
callq 0x33cdc
movq %rbp, %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rcx # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %rcx
leaq 0x38(%rsp), %rdi
movq %rcx, -0x8(%rdi)
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
callq 0x41d1e
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0xeb55
leaq 0x3c93(%rip), %rsi      # 0x44cd2
movl $0x1, %edx
movq %r14, %rdi
callq 0xa400
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x41063
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa3a0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4107a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa3a0
xorl %edi, %edi
callq 0xcd4e
movq 0x30(%rbx), %rax
cmpq %rbp, %rax
je 0x4112a
leaq 0x4229(%rip), %r14      # 0x452be
leaq 0x4223(%rip), %r15      # 0x452bf
leaq 0x5b14(%rip), %r12      # 0x46bb7
cmpb $0x0, 0x38(%rbx)
jne 0x410af
cmpl $0x1, 0x48(%rax)
je 0x41121
movq (%rbx), %r13
movl $0x2, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0xa400
movq 0x30(%rbx), %rax
movq 0x50(%rax), %rsi
movq 0x58(%rax), %rdx
movq %r13, %rdi
callq 0xa400
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0xa400
movq 0x30(%rbx), %rax
addq $0x78, %rax
movq %rax, 0x30(%rbx)
cmpq %rbp, %rax
je 0x41121
movb $0x0, 0x30(%rsp)
movl $0x17, %edi
callq 0xcd4e
movq (%rbx), %rdi
movl $0x4, %edx
movq %r12, %rsi
callq 0xa400
xorl %edi, %edi
callq 0xcd4e
movq 0x30(%rbx), %rax
cmpq %rbp, %rax
jne 0x410a3
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x41194
movq %rax, %rbx
jmp 0x41161
jmp 0x41142
movq %rax, %rbx
jmp 0x41178
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x41161
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa3a0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x41178
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa3a0
leaq 0xf(%rsp), %rdi
jmp 0x41187
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xcdb8
movq %rbx, %rdi
callq 0xa660
movq %rax, %rdi
callq 0x233c5
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x1, %ecx
callq 0x32966
testl %eax, %eax
je 0x24598
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x32c22
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29f2e
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x80(%rax)
testb %al, %al
jne 0x29fa7
leaq 0x1ad6d(%rip), %rdi     # 0x44c83
leaq 0x1aaef(%rip), %rsi     # 0x44a0c
leaq 0x1acf0(%rip), %rcx     # 0x44c14
movl $0x164b, %edx           # imm = 0x164B
callq 0xa240
movl $0x60, %edi
callq 0xa380
movq %rax, %rbx
movl $0x0, 0x8(%rax)
leaq 0x322b7(%rip), %rax     # 0x5c200
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x41d1e
movq %r14, 0x30(%rbx)
movq %r15, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x4c(%rbx)
leaq 0x32675(%rip), %rax     # 0x5c5f8
movq %rax, (%rbx)
movq %rsp, %rsi
movq %rbx, (%rsi)
incl 0x8(%rbx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x68(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x29fa7
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x2, 0x10(%r14)
je 0x29fd9
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x29fd9
movl $0x1, 0x58(%rbx)
movq 0x30(%rbx), %rax
movq %rbx, 0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x29fd9
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x29ffe
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2a016
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x2a016
movq %rax, %rdi
callq 0x233c5
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0xa3a0
movq %r14, %rdi
callq 0xa660
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd5d9
leaq 0x1412c(%rip), %rsi     # 0x45285
movq %r14, %rdi
callq 0xa0f0
testl %eax, %eax
je 0x311c3
leaq 0x142c6(%rip), %rsi     # 0x45432
leaq 0x8(%rsp), %rdi
callq 0xa0f0
testl %eax, %eax
je 0x311ca
leaq 0x14283(%rip), %rsi     # 0x45404
leaq 0x8(%rsp), %rdi
callq 0xa0f0
xorl %ecx, %ecx
testl %eax, %eax
je 0x311cf
movl $0x10, %edi
callq 0xa1a0
movq %rax, %r14
leaq 0x14264(%rip), %rsi     # 0x45409
movq %rax, %rdi
callq 0xa140
movq 0x2ce3c(%rip), %rsi     # 0x5dff0
movq 0x2cddd(%rip), %rdx     # 0x5df98
movq %r14, %rdi
callq 0xa610
movl $0x1, %ecx
jmp 0x311cf
movl $0x2, %ecx
movl %ecx, 0x24(%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x311ed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa3a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x31205
movq %rax, %rbx
movq %r14, %rdi
callq 0xa2c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31220
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa3a0
movq %rbx, %rdi
callq 0xa660
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %r13
movq %r13, %rdi
callq 0x41d1e
leaq 0x12686(%rip), %rsi     # 0x4544a
movl $0x2, %ecx
movq %r13, %rdi
movq $-0x1, %rdx
callq 0xa710
cmpq $-0x1, %rax
je 0x32e23
incq %rax
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0xa3d0
movq %rsp, %rdi
leaq 0x20(%rsp), %r13
movq %r13, %rsi
callq 0xa460
movq (%r13), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x32e23
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xa3a0
movq (%r15), %rdi
movq (%rdi), %rax
movq %rsp, %rdx
movq %r14, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
xorl %eax, %eax
movq %rax, 0x10(%rdx)
leaq 0x40(%rsp), %rdi
movl $0x0, (%rdi)
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %r12, %rsi
callq 0x33620
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x33714
leaq 0x20(%rsp), %rdi
callq 0x3027e
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x32e91
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa3a0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32ea5
movq %rax, %rbx
jmp 0x32eb7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3027e
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x32ecd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xa3a0
movq %rbx, %rdi
callq 0xa660
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq (%r14), %rax
movb (%rax,%r12), %al
cmpb $0x22, %al
jne 0x33834
xorb $0x1, 0x10(%r15)
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
movq %rbx, %r8
callq 0x33860
movl %eax, (%r15)
incq %r12
cmpq 0x8(%r14), %r12
jbe 0x33824
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x338cf
leaq 0x10f39(%rip), %r9      # 0x447ac
movslq (%r9,%rax,4), %rax
addq %r9, %rax
jmpq *%rax
movsbl %dl, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x33914
cmpb $0x2d, %dl
jne 0x3389b
movl $0x1, %eax
cmpb $0x0, 0x10(%rdi)
je 0x338b8
movq %rsi, 0x8(%rdi)
movl $0x5, %eax
jmp 0x338b8
xorl %eax, %eax
cmpb $0x2d, %dl
sete %al
addq %rax, %rsi
addl $0x3, %eax
movq %rsi, 0x8(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsbl %dl, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x33b8c
movl $0x10, %edi
callq 0xa1a0
movq %rax, %rbx
leaq 0x11b6a(%rip), %rsi     # 0x4544d
movq %rax, %rdi
callq 0xa4d0
movq 0x2a6de(%rip), %rsi     # 0x5dfd0
movq 0x2a6af(%rip), %rdx     # 0x5dfa8
movq %rbx, %rdi
callq 0xa610
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2c0
movq %r14, %rdi
callq 0xa660
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %rdi, %r12
cmpb $0x0, 0x10(%rdi)
jne 0x33c87
movq %rcx, %r14
movq %rsi, %r15
movq %r8, 0x8(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movl $0x0, (%rbx)
movq $0x3, -0x8(%rbx)
movsbl %dl, %esi
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
xorl %edx, %edx
callq 0xa490
movq %rax, %r13
movq (%rbp), %rdi
cmpq %rbx, %rdi
je 0x33bf4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xa3a0
cmpq $-0x1, %r13
movq 0x8(%rsp), %rbx
je 0x33c87
movq 0x8(%r12), %rdx
subq %rdx, %r15
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xa3d0
leaq 0x18(%rsp), %rdi
movl $0x0, -0x8(%rdi)
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x41d1e
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x33d72
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x33c68
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xa3a0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33c83
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa3a0
xorl %eax, %eax
jmp 0x33c8b
movl (%r12), %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x33cb9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xa3a0
jmp 0x33cb9
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x33cd4
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xa3a0
movq %rbx, %rdi
callq 0xa660
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movl (%rdi), %ecx
cmpq $0x10000, %rcx          # imm = 0x10000
jb 0x3807c
movq 0x8(%rdi), %rdx
movl (%rsi), %esi
movl %ecx, %r8d
shrl $0xe, %r8d
andl $-0x4, %r8d
xorl %eax, %eax
cmpl %esi, (%rdx,%rax)
je 0x380ae
addq $0x4, %rax
decl %ecx
cmpq %rax, %r8
jne 0x3806c
movl $0x10, %edi
callq 0xa1a0
movq %rax, %rbx
leaq 0xe412(%rip), %rsi      # 0x464a2
movq %rax, %rdi
callq 0xa080
movq 0x25f21(%rip), %rsi     # 0x5dfc0
movq 0x25f12(%rip), %rdx     # 0x5dfb8
movq %rbx, %rdi
callq 0xa610
testw %cx, %cx
je 0x3807c
addq 0x10(%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2c0
movq %r14, %rdi
callq 0xa660
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::operator[](int const&)
mapped_type& operator[](const key_type& key)
		{
			iterator it = find(key);
			
			if (it == end())
			{
				if (_size >= _capacity)
				{
					throw std::overflow_error("nanomap is full");
				}
				
				size_type i = _size++;
				new (&_keys[i]) key_type(key);
				new (&_values[i]) mapped_type();
				return _values[i];
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %ecx
cmpq $0x10000, %rcx          # imm = 0x10000
jb 0x38118
movq 0x8(%rdi), %rdx
movl (%rsi), %r8d
movl %ecx, %r9d
shrl $0xe, %r9d
andl $-0x4, %r9d
xorl %eax, %eax
movl %ecx, %r10d
cmpl %r8d, (%rdx,%rax)
je 0x3810c
addq $0x4, %rax
decl %r10d
cmpq %rax, %r9
jne 0x380f8
jmp 0x38118
testw %r10w, %r10w
je 0x38118
addq 0x10(%rdi), %rax
jmp 0x3814e
movl %ecx, %edx
shrl $0x10, %edx
movzwl %cx, %eax
cmpl %eax, %edx
jae 0x38156
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
addl %ecx, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, (%rdi)
movq 0x8(%rdi), %rax
shll $0x2, %edx
movl (%rsi), %ecx
movl %ecx, (%rax,%rdx)
movq 0x10(%rdi), %rcx
leaq (%rcx,%rdx), %rax
movl $0x0, (%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa1a0
movq %rax, %rbx
leaq 0xe347(%rip), %rsi      # 0x464b1
movq %rax, %rdi
callq 0xa0a0
movq 0x25de7(%rip), %rsi     # 0x5df60
movq 0x25dd0(%rip), %rdx     # 0x5df50
movq %rbx, %rdi
callq 0xa610
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2c0
movq %r14, %rdi
callq 0xa660
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::operator[](int&&)
mapped_type& operator[](key_type&& key)
		{
			iterator it = find(key);
			
			if (it == end())
			{
				if (_size >= _capacity)
				{
					throw std::overflow_error("nanomap is full");
				}
				
				size_type i = _size++;
				new (&_keys[i]) key_type(std::move(key));
				new (&_values[i]) mapped_type();
				return _values[i];
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %ecx
cmpq $0x10000, %rcx          # imm = 0x10000
jb 0x381e2
movq 0x8(%rdi), %rdx
movl (%rsi), %r8d
movl %ecx, %r9d
shrl $0xe, %r9d
andl $-0x4, %r9d
xorl %eax, %eax
movl %ecx, %r10d
cmpl %r8d, (%rdx,%rax)
je 0x381d6
addq $0x4, %rax
decl %r10d
cmpq %rax, %r9
jne 0x381c2
jmp 0x381e2
testw %r10w, %r10w
je 0x381e2
addq 0x10(%rdi), %rax
jmp 0x38218
movl %ecx, %edx
shrl $0x10, %edx
movzwl %cx, %eax
cmpl %eax, %edx
jae 0x38220
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
addl %ecx, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, (%rdi)
movq 0x8(%rdi), %rax
shll $0x2, %edx
movl (%rsi), %ecx
movl %ecx, (%rax,%rdx)
movq 0x10(%rdi), %rcx
leaq (%rcx,%rdx), %rax
movl $0x0, (%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xa1a0
movq %rax, %rbx
leaq 0xe27d(%rip), %rsi      # 0x464b1
movq %rax, %rdi
callq 0xa0a0
movq 0x25d1d(%rip), %rsi     # 0x5df60
movq 0x25d06(%rip), %rdx     # 0x5df50
movq %rbx, %rdi
callq 0xa610
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2c0
movq %r14, %rdi
callq 0xa660
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::erase(gdc::nanomap_iterator<true, int, myvalue, std::equal_to<int>>)
iterator erase(const_iterator it)
		{
			if (it._index == max_size())
			{
				std::abort();
			}
			
			_keys[it._index].~key_type();
			_values[it._index].~mapped_type();

			if (it._index < --_size)
			{
				new (&_keys[it._index]) key_type(std::move(_keys[_size]));
				new (&_values[it._index]) mapped_type(std::move(_values[_size]));
				_keys[_size].~key_type();
				_values[_size].~mapped_type();
			}
			else
			{
				it._index = end()._index;
			}

			return iterator(it._map, it._index);
		}

// Assembly:
movzwl 0x8(%rdx), %r8d
cmpw (%rsi), %r8w
je 0x3831e
movq 0x10(%rsi), %rcx
movl $0x2a, (%rcx,%r8,4)
movl (%rsi), %eax
movl %eax, %r9d
shrl $0x10, %r9d
decl %r9d
movzwl %r9w, %r9d
movw %r9w, 0x2(%rsi)
cmpl %r8d, %r9d
jbe 0x3830c
movq 0x8(%rsi), %r8
movzwl 0x8(%rdx), %eax
movl %eax, %r10d
shll $0x2, %r10d
movl (%r8,%r9,4), %r9d
movl %r9d, (%r8,%r10)
movzwl 0x2(%rsi), %r8d
movl (%rcx,%r8,4), %r8d
movl %r8d, (%rcx,%r10)
movzwl 0x2(%rsi), %esi
movl $0x2a, (%rcx,%rsi,4)
jmp 0x38310
movw %ax, 0x8(%rdx)
movq (%rdx), %rcx
movq %rcx, (%rdi)
movw %ax, 0x8(%rdi)
movq %rdi, %rax
retq
pushq %rax
callq 0xa1f0
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>::nanomap_factory(gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>> const&)
nanomap_factory(const nanomap_factory& f) : _map(_keys, _values, _capacity, f._map.size())
		{
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_keys[i]) key_type(f._keys[i]);
			}
			
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_values[i]) mapped_type(f._values[i]);
			}
		}

// Assembly:
leaq 0x18(%rdi), %rcx
leaq 0x98(%rdi), %rax
movzwl 0x2(%rsi), %edx
shll $0x10, %edx
orl $0x20, %edx
movl %edx, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
xorl %edx, %edx
movl $0x0, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x80, %rdx
jne 0x38345
xorl %edx, %edx
movl 0x18(%rsi,%rdx,4), %edi
movl %edi, (%rcx,%rdx,4)
incq %rdx
cmpq $0x20, %rdx
jne 0x3835b
xorl %ecx, %ecx
movl 0x98(%rsi,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
cmpq $0x20, %rcx
jne 0x3836d
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>::nanomap_factory(gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>&&)
nanomap_factory(nanomap_factory&& f) : _map(_keys, _values, _capacity, f._map.size())
		{
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_keys[i]) key_type(std::move(f._keys[i]));
			}
			
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_values[i]) mapped_type(std::move(f._values[i]));
			}
			
			f._map.clear();
		}

// Assembly:
leaq 0x18(%rdi), %rcx
leaq 0x98(%rdi), %rax
movzwl 0x2(%rsi), %edx
shll $0x10, %edx
orl $0x20, %edx
movl %edx, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
xorl %ecx, %ecx
movl $0x0, (%rax,%rcx)
addq $0x4, %rcx
cmpq $0x80, %rcx
jne 0x383a3
movl $0x6, %eax
movl (%rsi,%rax,4), %ecx
movl %ecx, (%rdi,%rax,4)
incq %rax
cmpq $0x26, %rax
jne 0x383bc
movl $0x26, %eax
movl (%rsi,%rax,4), %ecx
movl %ecx, (%rdi,%rax,4)
incq %rax
cmpq $0x46, %rax
jne 0x383d0
movl (%rsi), %edx
cmpl $0x10000, %edx          # imm = 0x10000
jb 0x38404
movq 0x10(%rsi), %rax
xorl %ecx, %ecx
movl $0x2a, (%rax,%rcx,4)
incq %rcx
movl (%rsi), %edx
movl %edx, %edi
shrl $0x10, %edi
cmpl %ecx, %edi
ja 0x383ef
movzwl %dx, %eax
movl %eax, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/devinsmith[P]qvdreader/LineageInfo.cpp
// Function: QvdLineageInfo::ParseXml(_xmlNode const*)
void QvdLineageInfo::ParseXml(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "Discriminator") == 0) {
        Discriminator = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "Statement") == 0) {
        Statement = (char *)nodeContent;
      } else {
        printf("Unprocessed LineageInfo tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rsi), %r14
testq %r14, %r14
je 0x48fb
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rsp)
movq 0x878a(%rip), %r13      # 0xcfe0
leaq 0x57a3(%rip), %r12      # 0xa000
cmpl $0x1, 0x8(%r14)
jne 0x48ee
movq %r14, %rdi
callq 0x43a0
testq %rax, %rax
je 0x48ee
movq %rax, %rbp
cmpb $0x0, (%rax)
je 0x48e7
movq 0x10(%r14), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x4460
testl %eax, %eax
je 0x48b6
movq %r15, %rdi
leaq 0x5774(%rip), %rsi      # 0xa00e
callq 0x4460
testl %eax, %eax
je 0x48c7
leaq 0x576e(%rip), %rdi      # 0xa018
movq %r15, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x48e7
movq 0x8(%rbx), %r15
movq %rbp, %rdi
callq 0x4120
movq %rbx, %rdi
jmp 0x48d7
movq 0x28(%rbx), %r15
movq %rbp, %rdi
callq 0x4120
movq (%rsp), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbp, %rcx
movq %rax, %r8
callq 0x44e0
movq %rbp, %rdi
callq *(%r13)
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x485d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/devinsmith[P]qvdreader/main.cpp
// Function: main
int
main(int argc, char *argv[])
{
  if (argc < 2) {
    fprintf(stderr, "usage: %s qvdfile.qvd\n", argv[0]);
    exit(1);
  }

  QvdFile qvd;

  if (!qvd.Load(argv[1])) {
    fprintf(stderr, "The file '%s' could not be loaded.\n", argv[1]);
    exit(1);
  }

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2150, %rsp           # imm = 0x2150
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x4a2b
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x50(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movl $0x0, 0x10(%rcx)
leaq 0x78(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0xf8(%rsp), %r14
xorps %xmm0, %xmm0
movups %xmm0, -0x70(%r14)
movups %xmm0, -0x60(%r14)
movups %xmm0, -0x50(%r14)
movups %xmm0, -0x40(%r14)
movups %xmm0, -0x30(%r14)
movups %xmm0, -0x24(%r14)
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x118(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
movq %rax, 0x10(%r15)
movq %rax, 0x202c(%r15)
movb %al, 0x2028(%r15)
movups %xmm0, 0x2018(%r15)
movq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x4190
testb %al, %al
je 0x4a33
movq 0x108(%rsp), %rdi
cmpq %r15, %rdi
je 0x49f7
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x4360
movq 0xe8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4a14
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x4360
movq %rsp, %rdi
callq 0x4380
xorl %eax, %eax
addq $0x2150, %rsp           # imm = 0x2150
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x4697
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4670
movq %rax, %rbx
movq %rsp, %rdi
callq 0x41c0
movq %rbx, %rdi
callq 0x45b0