LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictAddExclusion
PICT_RET_CODE
API_SPEC
PictAddExclusion
    (
    IN const PICT_HANDLE         task,
    IN const PICT_EXCLUSION_ITEM exclusionItems[],
    IN       size_t              exclusionItemCount
    )
{
    Task* taskObj = static_cast<Task*>( NO_CONST_HANDLE( task ));
    
    try
    {
        Exclusion exclusion;
        for( size_t index = 0; index < exclusionItemCount; ++index )
        {
            exclusion.insert( make_pair( 
                static_cast<Parameter*> ( NO_CONST_HANDLE( exclusionItems[ index ].Parameter  )),
                static_cast<int>        (                  exclusionItems[ index ].ValueIndex ))
                );
        }
        bool ret = taskObj->AddExclusion( exclusion );
        return( ret ? PICT_SUCCESS : PICT_OUT_OF_MEMORY );
    }
    catch( ... )
    {
        return( PICT_OUT_OF_MEMORY );
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movb $0x0, 0x40(%rax)
addq $0x8, %r15
leaq 0x10(%rsp), %r12
movq %rsp, %r13
subq $0x1, %r14
jb 0x101a9
movq -0x8(%r15), %rax
movl (%r15), %ecx
movq %rax, (%rsp)
movl %ecx, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x7fda
addq $0x10, %r15
jmp 0x10183
addq $0x8, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x8af8
xorl %eax, %eax
testb $0x1, %dl
movl $0xc0000001, %ebx       # imm = 0xC0000001
cmovnel %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x7b50
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x101e3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7b50
movq %rbx, %rdi
callq 0x6190
callq 0x6690
movl $0xc0000001, %ebx       # imm = 0xC0000001
jmp 0x101d1
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictAddSeed
PICT_RET_CODE
API_SPEC
PictAddSeed
    (
    IN const PICT_HANDLE     task,
    IN const PICT_SEED_ITEM  seedItems[],
    IN       size_t          seedItemCount
    )
{
    Task* taskObj = static_cast<Task*>( NO_CONST_HANDLE( task ));
    
    try
    {
        RowSeed seed;
        for( size_t index = 0; index < seedItemCount; ++index )
        {
            seed.insert( make_pair( 
                static_cast<Parameter*> ( NO_CONST_HANDLE( seedItems[ index ].Parameter  )),
                static_cast<int>        (                  seedItems[ index ].ValueIndex ))
                );
        }
        taskObj->AddRowSeed( seed );
        return( PICT_SUCCESS );
    }
    catch( ... )
    {
        return( PICT_OUT_OF_MEMORY );
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x18(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %rdi, %r15
addq $0x8, %r14
leaq 0x10(%rsp), %r12
movq %rsp, %r13
subq $0x1, %rbx
jb 0x10266
movq -0x8(%r14), %rax
movl (%r14), %ecx
movq %rax, (%rsp)
movl %ecx, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xf598
addq $0x10, %r14
jmp 0x10240
addq $0x38, %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xc626
leaq 0x10(%rsp), %rdi
callq 0xd164
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x10293
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd164
movq %rbx, %rdi
callq 0x6190
callq 0x6690
movl $0xc0000001, %eax       # imm = 0xC0000001
jmp 0x10283
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictGenerate
PICT_RET_CODE
API_SPEC
PictGenerate
    (
    IN const PICT_HANDLE task
    )
{
    Task* taskObj = static_cast<Task*>( NO_CONST_HANDLE( task ));
    try
    {
        taskObj->PrepareForGeneration();
    }
    catch( ... )
    {
        return( PICT_GENERATION_ERROR );
    }
    
    Model* root = taskObj->GetRootModel();
    try
    {
        generate( root );
    }
    catch( GenerationError e )
    {
        switch( e.GetErrorType() )
        {
        case OutOfMemory:
            return( PICT_OUT_OF_MEMORY );
        case GenerationCancelled:
        case TooManyRows:        
        case Unknown:
        case GenerationFailure:
        default:
            return( PICT_GENERATION_ERROR );
        }
    }
    return( PICT_SUCCESS );
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x10d38
movq (%rbx), %rdi
xorl %ebx, %ebx
callq 0x1033a
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x2, %edx
jne 0x10316
movq %rbx, %rdi
callq 0x6540
movq %rsp, %rdi
movq %rax, %rsi
callq 0x10662
movq %rbx, %rdi
callq 0x6190
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
cmpl $0x3, -0x8(%rdi)
setne %bl
addl $0xc0000001, %ebx       # imm = 0xC0000001
callq 0x61e0
callq 0x6690
jmp 0x102cb
movq %rbx, %rdi
callq 0x66e0
movq %rax, %rdi
callq 0x7012
movq %rax, %rdi
callq 0x6190
callq 0x6690
movl $0xc0000002, %ebx       # imm = 0xC0000002
jmp 0x102cb
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictGetNextResultRow
size_t
API_SPEC
PictGetNextResultRow
    (
    IN  const PICT_HANDLE     task,
    OUT       PICT_RESULT_ROW resultRow
    )
{
    Task* taskObj = static_cast<Task*>( NO_CONST_HANDLE( task ));
    
    ResultCollection::iterator i_row = taskObj->GetNextResultRow();

    if( i_row != taskObj->GetResults().end() )
    {
        for( size_t index = 0; index < i_row->size(); ++index )
        {
            resultRow[ index ] = (*i_row)[ index ];
        }
    }
    
    return( distance( i_row, taskObj->GetResults().end() ));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10f4a
movq (%r14), %rcx
movq 0xd8(%rcx), %rcx
cmpq %rcx, %rax
je 0x103c3
movq (%rax), %rdx
movq 0x8(%rax), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x103c3
movq (%rdx,%rdi,8), %r8
movq %r8, (%rbx,%rdi,8)
incq %rdi
jmp 0x103b1
subq %rax, %rcx
pushq $0x18
popq %rsi
movq %rcx, %rax
cqto
idivq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictCreateModel
PICT_HANDLE
API_SPEC
PictCreateModel
    (
    IN OPT unsigned int randomSeed
    )
{
    Model* modelObj = new Model( L"",
                                 MixedOrder, 
                                 0,
                                 randomSeed );
    
    return( static_cast<PICT_HANDLE>( modelObj ));   
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebp
movl $0x150, %edi            # imm = 0x150
callq 0x6440
movq %rax, %rbx
leaq 0x125dc(%rip), %rsi     # 0x229f0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1068c
movl %ebp, %r8d
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x106c6
leaq 0x10(%rsp), %rdi
callq 0x6090
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6090
jmp 0x1045f
movq %rax, %r14
movl $0x150, %esi            # imm = 0x150
movq %rbx, %rdi
callq 0x6460
movq %r14, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictAddParameter
PICT_HANDLE
API_SPEC
PictAddParameter
    (
    IN     const PICT_HANDLE model,
    IN           size_t      valueCount,
    IN OPT unsigned int      order,
    IN OPT unsigned int      valueWeights[]
    )
{
    Model* modelObj = static_cast<Model*>( NO_CONST_HANDLE( model ));

    Parameter* param = new Parameter( order,
                                      static_cast<int>( modelObj->GetParameters().size() + 1 ),
                                      static_cast<int>( valueCount ),
                                      L"",
                                      false );
    try
    {
        if( NULL != param )
        {
            if( NULL != valueWeights )
            {
                std::vector<int> weights;
                weights.reserve( valueCount );
                weights.insert( weights.begin(), valueWeights, valueWeights + valueCount );
                param->SetWeights( move( weights ));
            }

            modelObj->AddParameter( param );
        }
    }
    catch( ... )
    {
        param = NULL;
    }

    return( param );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r13
movl $0xd0, %edi
callq 0x6440
movq %rax, %rbx
movq 0x8(%r13), %r14
movq %r13, 0x18(%rsp)
movq 0x10(%r13), %r13
leaq 0x12542(%rip), %rsi     # 0x229f0
leaq 0x38(%rsp), %rdi
movq %rsp, %rdx
callq 0x1068c
subq %r14, %r13
shrq $0x3, %r13
incl %r13d
leaq 0x38(%rsp), %r8
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %r12d, %ecx
xorl %r9d, %r9d
callq 0xfdd2
leaq 0x38(%rsp), %rdi
callq 0x6090
testq %r15, %r15
je 0x10550
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %r12, %rsi
callq 0x107fc
movq %rsp, %rdi
movq (%rdi), %rsi
leaq (%r15,%r12,4), %rcx
movq %r15, %rdx
callq 0x10892
movaps (%rsp), %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0xfbb6
leaq 0x20(%rsp), %rdi
callq 0xd9ac
movq %rsp, %rdi
callq 0xd9ac
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0xc5c2
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd9ac
jmp 0x10583
jmp 0x10580
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd9ac
jmp 0x10590
movq %rax, %rbx
movq %rbx, %rdi
callq 0x6190
callq 0x6690
xorl %ebx, %ebx
jmp 0x1055d
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x6090
jmp 0x105b3
movq %rax, %r14
movl $0xd0, %esi
movq %rbx, %rdi
callq 0x6460
movq %r14, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictDeleteModel
void
API_SPEC
PictDeleteModel
    (
    IN const PICT_HANDLE model
    )
{
    Model* modelObj = static_cast<Model*>( NO_CONST_HANDLE( model ));

    // delete all params first
    // since GetParameters() will return all params for this and all submodels, do it here
    for( Parameter* param : modelObj->GetParameters() )
    {
        delete( param );
    }

    // and this model, Model::~Model will clean up all submodels too
    delete( modelObj );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x10635
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1062f
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1061c
movq %rbx, %rdi
callq 0xc342
movl $0x150, %esi            # imm = 0x150
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::Task()
Task::Task() :
      m_rootModel     (NULL),
      m_abortCallback (NULL),
      m_generationMode(Regular),
      m_maxRandomTries(DefaultMaxRandomTries),
      m_workbuf       (NULL)
{
    Combination::ResetId();

#if ( defined(_DOUT) || defined(_FILE) )
    wcerr << L"WARNING: _DOUT or _FILE are defined\n";
#endif

#if ( defined(_DOUT) && defined(_FILE) )
    logfile.open( "\\generator.log", ofstream::out );
#endif
}

// Assembly:
andq $0x0, (%rdi)
leaq 0x10(%rdi), %rax
andl $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, 0x40(%rdi)
movq %rax, 0x38(%rdi)
andl $0x0, 0x58(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdi)
movq $0x3e8, 0x60(%rdi)      # imm = 0x3E8
movups %xmm0, 0x68(%rdi)
leaq 0x24b4c(%rip), %rax     # 0x35818
andl $0x0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::PrepareForGeneration()
void Task::PrepareForGeneration()
{
    // new models could have been added to the root
    // repropagate the task pointer to all models
    m_rootModel->WireTask(this);

    // run the deriver on exclusions
    deriveExclusions();

    // propagate exclusions wiring to appropriate submodel
    // add each exclusion to that model in the hierarchy which is the most suitable:
    //  1. a subtree of that model must have all the parameters of the exclusion
    //  2. no lower subtree satisfies the condition 1)
    //
    for ( auto & excl : m_exclusions )
    {
        Model* found = findMatchingNode(const_cast<Exclusion&>( excl ), m_rootModel);
        assert( NULL != found );
        found->AddExclusion( const_cast<Exclusion&>( excl ));
    }

    // propagate all row seeds
    m_rootModel->AddRowSeeds( m_rowSeeds.begin(), m_rowSeeds.end() );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x108c8
movq %rbx, %rdi
callq 0x10dce
movq 0x20(%rbx), %r14
leaq 0x10(%rbx), %r12
cmpq %r12, %r14
je 0x10d96
leaq 0x20(%r14), %r15
movq (%rbx), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10ec2
testq %rax, %rax
je 0x10db1
addq $0x20, %rax
movq %rax, %rdi
movq %r15, %rsi
callq 0x8af8
movq %r14, %rdi
callq 0x6500
movq %rax, %r14
jmp 0x10d5e
leaq 0x38(%rbx), %rdx
movq (%rbx), %rdi
movq 0x38(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10fc6
leaq 0x11c97(%rip), %rdi     # 0x22a4f
leaq 0x11c9e(%rip), %rsi     # 0x22a5d
leaq 0x11caf(%rip), %rcx     # 0x22a75
pushq $0x53
popq %rdx
callq 0x6310
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::deriveExclusions()
void Task::deriveExclusions()
{
    ExclusionDeriver deriver(this);
    ParamCollection params;
    m_rootModel->GetAllParameters(params);

    for( auto p : params )
    {
        deriver.AddParameter( p );
    }

    for( auto & excl : m_exclusions )
    {
        deriver.AddExclusion( const_cast<Exclusion&>( excl ), true );
    }

    deriver.DeriveExclusions();
    
    // must clear and repopulate the collection with the result of the derivation
    m_exclusions.clear();
    __insert( m_exclusions, deriver.GetExclusions().begin(), deriver.GetExclusions().end() );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0xc664
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq (%rbx), %rdi
callq 0xc6e2
movq (%rsp), %r15
movq 0x8(%rsp), %r12
leaq 0x20(%rsp), %r14
cmpq %r12, %r15
je 0x10e27
movq (%r15), %rsi
movq %r14, %rdi
callq 0xc720
addq $0x8, %r15
jmp 0x10e11
leaq 0x8(%rbx), %r14
movq 0x20(%rbx), %r12
addq $0x10, %rbx
leaq 0x20(%rsp), %r15
pushq $0x1
popq %rbp
cmpq %rbx, %r12
je 0x10e5c
leaq 0x20(%r12), %rsi
movq %r15, %rdi
movl %ebp, %edx
callq 0x71aa
movq %r12, %rdi
callq 0x6500
movq %rax, %r12
jmp 0x10e3b
leaq 0x20(%rsp), %rdi
callq 0x7386
movq %r14, %rdi
callq 0xf6e0
leaq 0x40(%rsp), %rdx
movq 0x10(%rdx), %rsi
movq %r14, %rdi
callq 0xc631
movq %rsp, %rdi
callq 0x701e
leaq 0x20(%rsp), %rdi
callq 0xc732
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10ea5
jmp 0x10ea5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x701e
leaq 0x20(%rsp), %rdi
callq 0xc732
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::findMatchingNode(pictcore::Exclusion&, pictcore::Model*)
Model* Task::findMatchingNode( Exclusion& exclusion, Model* root )
{
    // can any of the subnodes accommodate the exclusion?
    for( auto & submodel : root->GetSubmodels() )
    {
        Model* foundNode = findMatchingNode( exclusion, submodel );
        if ( NULL != foundNode ) return( foundNode );
    }

    // none of the subnodes matches the exclusion so let's try the current one
    bool foundParams = true;
    for( auto & term : exclusion )
    {
        foundParams = findParamInSubtree( term.first, root );
        if ( ! foundParams ) break;
    }
    if ( foundParams )
    {
        return( root );
    }
    else
    {
        return( NULL );
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdx), %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x10efd
movq 0x10(%r13), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x10ec2
testq %rax, %rax
je 0x10edb
movq %rax, %rbx
jmp 0x10f2d
movq 0x18(%r14), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0x10f2d
movq 0x20(%r12), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x10f64
testb %al, %al
je 0x10f2b
movq %r12, %rdi
callq 0x6500
movq %rax, %r12
jmp 0x10f05
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::findParamInSubtree(pictcore::Parameter*, pictcore::Model*)
bool Task::findParamInSubtree( Parameter* parameter, Model* root )
{
    // check if exists in current node collection
    for( auto p : root->GetParameters() )
    {
        if ( p == parameter ) return( true );
    }

    // check if exists in any of the children
    for( auto & submodel : root->GetSubmodels() )
    {
        bool found = findParamInSubtree( parameter, submodel );
        if ( found ) return( true );
    }

    return( false );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %rax
cmpq %rax, %rcx
je 0x10f93
leaq 0x8(%rcx), %rdx
cmpq %r14, (%rcx)
movq %rdx, %rcx
jne 0x10f7d
movb $0x1, %bpl
jmp 0x10fbb
addq $0x50, %rbx
movq %rbx, %r12
movq (%r12), %r12
cmpq %rbx, %r12
setne %bpl
je 0x10fbb
movq 0x10(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x10f64
testb %al, %al
je 0x10f9a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/worklist.cpp
// Function: pictcore::WorkList::AddItem(pictcore::Parameter*)
void WorkList::AddItem( Parameter* param )
{
    if( !param->IsPending() )
    {
        assert( !param->GetBoundCount() );
        m_rep.push_back( param );
        param->MarkPending();
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
cmpb $0x0, 0x3e(%rsi)
jne 0x11052
cmpb $0x1, 0x3d(%rsi)
je 0x11058
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x8086
movq (%rbx), %rax
movb $0x1, 0x3e(%rax)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x116e6(%rip), %rdi     # 0x22745
leaq 0x11a3b(%rip), %rsi     # 0x22aa1
leaq 0x11a50(%rip), %rcx     # 0x22abd
pushq $0xe
popq %rdx
callq 0x6310
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/utils/utils.cpp
// Function: position_in_vector(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>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int position_in_vector(vector<string> vect, string target)
{
    for(int i=0; i<vect.size(); i++)
    {
        if(vect[i].compare(target) == 0)
        {
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
pushq $-0x1
popq %rbx
xorl %r13d, %r13d
movq (%r15), %rdi
movq 0x8(%r15), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x11212
addq %r12, %rdi
movq %r14, %rsi
callq 0x6040
testl %eax, %eax
je 0x1120f
incq %r13
addq $0x20, %r12
jmp 0x111e4
movl %r13d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/input-parser/input-parser.cpp
// Function: input_parser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<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>>>>, std::allocator<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>>>>>>&, std::vector<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>>>>, std::allocator<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>>>>>>&)
void input_parser(string input_file_path, vector<vector<string>> &parameter_matrix, vector<vector<string>> &constraint_matrix)
{
	
	std::ifstream input_file;
  	input_file.open(input_file_path, std::ios_base::in);

	parameter_parser(input_file, parameter_matrix);
	constraint_parser(input_file, constraint_matrix);
	
	input_file.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x64e0
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x63a0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x11618
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x11ab6
movq %rsp, %rdi
callq 0x60d0
movq %rsp, %rdi
callq 0x60f0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x60f0
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/input-parser/input-parser.cpp
// Function: constraint_parser(std::basic_ifstream<char, std::char_traits<char>>&, std::vector<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>>>>, std::allocator<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>>>>>>&)
void constraint_parser(ifstream &input_file_stream, vector<vector<string>> &constraint_matrix)
{
	string file_row;
	int num_of_params = 0;

	while(!input_file_stream.eof())
	{	
		getline(input_file_stream, file_row);
		if(start_string_delim_find(file_row,'#'))
		{
			break;
		}

		vector<string> values_vector = split(file_row, ",");
	    constraint_matrix.push_back(vector<string>());

		for (auto value : values_vector)
		{
			constraint_matrix[num_of_params].push_back(value);
		}

		num_of_params++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, 0x10(%rsp)
movb $0x0, (%rax)
movq $0x0, 0x8(%rsp)
leaq 0x58(%rsp), %r15
leaq 0x30(%rsp), %r13
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rcx,%rax)
jne 0x11c0c
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x60b0
leaq 0xb8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x65b0
movq %r15, %r14
movq %r12, %rdi
pushq $0x23
popq %rsi
callq 0x1121e
movl %eax, %r15d
movq %r12, %rdi
callq 0x61e0
testb %r15b, %r15b
jne 0x11c0c
movq %r14, %rsi
leaq 0x78(%rsp), %rdi
callq 0x65b0
leaq 0x98(%rsp), %r12
movq %r12, %rdi
leaq 0x1206f(%rip), %rsi     # 0x23bda
movq %r13, %rdx
callq 0x7f56
leaq 0x18(%rsp), %rdi
leaq 0x78(%rsp), %r15
movq %r15, %rsi
movq %r12, %rdx
callq 0x110b0
movq %r12, %rdi
callq 0x61e0
movq %r15, %rdi
callq 0x61e0
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x120a6
movq %r13, %rdi
callq 0x11254
movq 0x18(%rsp), %r15
movq 0x20(%rsp), %r12
imulq $0x18, 0x8(%rsp), %rbp
cmpq %r12, %r15
je 0x11bf5
movq %r13, %rdi
movq %r15, %rsi
callq 0x65b0
movq (%rbx), %rdi
addq %rbp, %rdi
movq %r13, %rsi
callq 0x11228
movq %r13, %rdi
callq 0x61e0
addq $0x20, %r15
jmp 0x11bc9
incq 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x11254
movq %r14, %r15
jmp 0x11af3
leaq 0x58(%rsp), %rdi
callq 0x61e0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11c67
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x61e0
jmp 0x11c3f
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
jmp 0x11c60
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x11254
jmp 0x11c7e
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x61e0
jmp 0x11c88
movq %rax, %rbx
jmp 0x11c88
movq %rax, %rbx
jmp 0x11c7e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x61e0
leaq 0x18(%rsp), %rdi
callq 0x11254
leaq 0x58(%rsp), %rdi
callq 0x61e0
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/java-source-code-parser/java-source-code-parser.cpp
// Function: get_class_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string get_class_name(string source_code_path)
{
    std::ifstream source_input_file;
    source_input_file.open(source_code_path, std::ios_base::in);

    string search_string = "";
    string source_code = "";

    while(!source_input_file.eof())
	{
        getline(source_input_file, search_string);
        source_code.append(search_string);        
    }

    smatch sm ;

    //CLASS NAME REGEX (WITH CLASS|INTERFACE|ENUM)
    regex class_regex (R"rgx((class|interface|enum)\s([^\n\s]*))rgx");
    regex_search(source_code, sm, class_regex);
    string class_name_with_decl = ((string) sm[0]);
    string class_name = (class_name_with_decl.replace(0,class_name_with_decl.find(" ")+1, ""));
    return class_name;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
callq 0x64e0
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x63a0
leaq 0x11891(%rip), %rsi     # 0x23b9a
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x7f56
leaq 0x11878(%rip), %rsi     # 0x23b9a
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x7f56
leaq 0xa0(%rsp), %r14
leaq 0x80(%rsp), %r15
leaq 0x20(%rsp), %r12
movq 0xa0(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0xc0(%rsp,%rax)
jne 0x12372
movq %r14, %rdi
movq %r15, %rsi
callq 0x60b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x6770
jmp 0x12344
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0x10953(%rip), %rsi     # 0x22cd8
leaq 0x60(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x12880
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
leaq 0x60(%rsp), %rdx
xorl %ecx, %ecx
callq 0x128e6
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
leaq -0x48(%rcx), %rdi
cmpq $0x48, %rdx
movq %rax, %rsi
cmoveq %rdi, %rsi
cmpq %rax, %rcx
cmoveq %rdi, %rsi
leaq 0x40(%rsp), %rdi
callq 0x1de50
leaq 0x1183f(%rip), %rsi     # 0x23c1b
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x6780
leaq 0x1(%rax), %rdx
leaq 0x117a4(%rip), %rcx     # 0x23b9a
movq %r14, %rdi
xorl %esi, %esi
callq 0x6280
movq %rbx, %rdi
movq %rax, %rsi
callq 0x65b0
leaq 0x40(%rsp), %rdi
callq 0x61e0
leaq 0x60(%rsp), %rdi
callq 0x12902
movq %rsp, %rdi
callq 0x1291c
leaq 0x20(%rsp), %rdi
callq 0x61e0
leaq 0x80(%rsp), %rdi
callq 0x61e0
leaq 0xa0(%rsp), %rdi
callq 0x60f0
movq %rbx, %rax
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1245f
movq %rax, %rbx
jmp 0x12482
movq %rax, %rbx
jmp 0x1248c
movq %rax, %rbx
jmp 0x124a3
jmp 0x12470
movq %rax, %rbx
jmp 0x124b0
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x61e0
leaq 0x60(%rsp), %rdi
callq 0x12902
movq %rsp, %rdi
callq 0x1291c
jmp 0x12499
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x61e0
leaq 0x80(%rsp), %rdi
callq 0x61e0
leaq 0xa0(%rsp), %rdi
callq 0x60f0
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/java-source-code-parser/java-source-code-parser.cpp
// Function: get_method_and_values_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> get_method_and_values_name(string method_prototype)
{
    smatch sm;
    vector<string> method_values_name;
    regex method_and_value_name_regex (R"rgx(\b\w+(?=\s*[,()]))rgx");

    while(regex_search(method_prototype, sm, method_and_value_name_regex))
    {
        method_values_name.push_back(sm[0]);
        method_prototype = sm.suffix();
    }
    return method_values_name;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x1064e(%rip), %rsi     # 0x22d71
leaq 0x28(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x12880
movq %rsp, %r15
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %r13
pushq $0x18
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x128e6
testb %al, %al
je 0x127d9
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
leaq -0x48(%rcx), %rdi
cmpq $0x48, %rdx
movq %rax, %rsi
cmoveq %rdi, %rsi
cmpq %rax, %rcx
cmoveq %rdi, %rsi
movq %r13, %rdi
callq 0x1de50
movq %rbx, %rdi
movq %r13, %rsi
callq 0x114aa
movq %r13, %rdi
callq 0x61e0
movq 0x8(%rsp), %rsi
movq %rsi, %rax
subq (%rsp), %rax
cqto
idivq %rbp
cmpq $0x4, %rax
jb 0x127b5
addq $-0x18, %rsi
jmp 0x127b9
addq $-0x48, %rsi
movq %r13, %rdi
callq 0x1de50
movq %r14, %rdi
movq %r13, %rsi
callq 0x6530
movq %r13, %rdi
callq 0x61e0
jmp 0x12740
leaq 0x28(%rsp), %rdi
callq 0x12902
movq %rsp, %rdi
callq 0x1291c
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x12822
jmp 0x12815
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x61e0
jmp 0x12818
jmp 0x12815
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x12902
movq %rbx, %rdi
callq 0x11254
movq %rsp, %rdi
callq 0x1291c
movq %r14, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/junit-test-case-generator/junit-test-case-generator.cpp
// Function: delta_check(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool delta_check(string input_file_path, int num_of_parameters)
{
    ifstream test_with_oracle;
  	test_with_oracle.open(input_file_path, ios_base::in);
    string combination = "";

    while(!test_with_oracle.eof())
    {
        getline(test_with_oracle, combination);

        if((int) count(combination.begin(), combination.end(), ',') == (num_of_parameters + 1)) //If there's delta it is TRUE (+1 parameter)
        {
            test_with_oracle.close();
            return true;
        }
    }

    test_with_oracle.close();
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movl %esi, %ebx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x64e0
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x63a0
leaq 0x5bc7(%rip), %rsi      # 0x23b9a
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x7f56
incl %ebx
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x48(%rsp,%rax), %ebp
testb $0x2, %bpl
jne 0x1e02f
movq %r14, %rdi
movq %r15, %rsi
callq 0x60b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq %rdi, %rsi
movb $0x2c, 0x7(%rsp)
movq %r12, %rdx
callq 0x1ee1d
cmpl %eax, %ebx
jne 0x1dff3
leaq 0x28(%rsp), %rdi
callq 0x60d0
testb $0x2, %bpl
sete %bl
leaq 0x8(%rsp), %rdi
callq 0x61e0
leaq 0x28(%rsp), %rdi
callq 0x60f0
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e071
jmp 0x1e06a
movq %rax, %rbx
jmp 0x1e07e
jmp 0x1e071
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61e0
leaq 0x28(%rsp), %rdi
callq 0x60f0
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: connect_and_login_ftp(ftplib*, ftpInfo*, int)
static int connect_and_login_ftp (ftplib* ftpClient, ftpInfo* pFtp, int retryTime) 
{
    int retry = 0;
    static int seeded = 0;
    if (!seeded) {
        struct timeval tv;
        gettimeofday(&tv, NULL);
        srand((unsigned)tv.tv_usec);
        seeded = 1;
    }

    while (true) {
        if (ftpClient->Connect(pFtp->ftpServer)) {
            break;
        }
        
        if (retryTime > 0) {
            retry++;
            if (retry >= retryTime) {
                return -1;
            }
        } else {
            unsigned int sleepTime = rand();
            sleepTime = sleepTime % 31 + 2;
            sleep(sleepTime);
        }
    }
    if (!ftpClient->Login(pFtp->user, pFtp->pass)) {
        return -2;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x1205b(%rip)     # 0x17528
jne 0x54ee
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x4610
movl 0x8(%r15), %edi
callq 0x43a0
movb $0x1, 0x1203a(%rip)     # 0x17528
pushq $0x1f
popq %rbp
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xc7ae
testl %eax, %eax
jne 0x5513
callq 0x40c0
xorl %edx, %edx
divl %ebp
leal 0x2(%rdx), %edi
callq 0x42a0
jmp 0x54f1
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0xcb06
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal -0x2(,%rcx,2), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: get_task_from_queue(task<fileInfo>&)
static int get_task_from_queue (task<fileInfo>& curTask)
{
    std::unique_lock<std::mutex> lock(tasksMutex);
    while ((tasksQueue.empty()) && (!exitFlag)) {
        tasksExecuteCV.wait(lock);
    }
    if (!tasksQueue.empty()) {
        curTask = tasksQueue.front();
        tasksQueue.pop();
        tasksProductCV.notify_one();
    } else {
        return -1;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x11ee9(%rip), %rsi     # 0x17438
movq %rsp, %r14
movq %r14, %rdi
callq 0xa326
leaq 0x11f2f(%rip), %r15     # 0x17490
movq 0x11eb0(%rip), %rax     # 0x17418
movq 0x11e89(%rip), %rsi     # 0x173f8
cmpq %rsi, %rax
jne 0x5599
movl 0x11f5e(%rip), %eax     # 0x174d8
testl %eax, %eax
jne 0x558b
movq %r15, %rdi
movq %r14, %rsi
callq 0x40f0
jmp 0x5561
movq 0x11e86(%rip), %rax     # 0x17418
movq 0x11e5f(%rip), %rsi     # 0x173f8
cmpq %rsi, %rax
je 0x55c2
movq %rbx, %rdi
callq 0xa33c
leaq 0x11e3b(%rip), %rdi     # 0x173e8
callq 0xa3ba
leaq 0x11ea7(%rip), %rdi     # 0x17460
callq 0x41c0
xorl %ebx, %ebx
jmp 0x55c5
pushq $-0x1
popq %rbx
movq %rsp, %rdi
callq 0xa366
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa366
movq %rbx, %rdi
callq 0x46a0
// File: /workspace/github_cpp_makefile_star2_O2/lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: build_ftp_data_connection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ftplib::accesstype, ftplib::transfermode, ftplib*, ftpInfo*, ftphandle**)
static int build_ftp_data_connection (string accessPath, ftplib::accesstype type, 
                                            ftplib::transfermode mode, ftplib* ftpClient,
                                            ftpInfo* pFtp, ftphandle** nData) 
{
    int retry = 0;
    while (retry < 5) {
        retry++;
        if (!ftpClient->FtpAccess(accessPath.c_str(), type, mode, ftpClient->mp_ftphandle, nData)) {
            if (ftpClient->mp_ftphandle->handle > 0) 
                net_close(ftpClient->mp_ftphandle->handle);
            int ret = connect_and_login_ftp (ftpClient, pFtp, 0);
            if (ret == -2) {  // login failed
                return ret;
            }
        } else {
            return 0;   // get ftp data connection succeed
        }
    }
    return -1;  // retry 5 times but failed
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, (%rsp)
movq %rcx, %r12
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %rbx
pushq $0x6
popq %r15
decl %r15d
je 0x5652
movq (%rbx), %rsi
movq (%r12), %r8
movq %r12, %rdi
movl %r13d, %edx
movl %ebp, %ecx
movq %r14, %r9
callq 0xcd82
testl %eax, %eax
jne 0x5657
movq (%r12), %rax
movl 0x10(%rax), %edi
testl %edi, %edi
jle 0x563d
callq 0x4740
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x54b6
cmpl $-0x2, %eax
jne 0x560d
pushq $-0x2
jmp 0x5654
pushq $-0x1
popq %rax
jmp 0x5659
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: usage(char*)
static void usage(char * cmd)
{
    printf("ftp benchmark tool.\n");
    printf("Usage: %s -n <ftp server> -u <user name> -p <password> -s <source path>  -d <destination path> -i\n", cmd);
    printf("options:\n");	
    printf("    -t     # the number of threads\n");
    printf("    -i     # verbose, show ftp messages\n");
    printf("    -v     # verify data correctness\n");
    printf("    -h     # show usage\n");
    printf("Example:\n");
    printf("    %s -n 10.1.1.1:21 -u user -p pass -s local:/home -d ftp:/dir -t 8                 # upload local directory to ftp server\n", cmd);
    printf("    %s -n 10.1.1.1 -u user -p pass -s null -d ftp:/dir -w 3 -l 3 -f 10 -S 64K:1M -t 8 # upload random files to  ftp directory\n", cmd);
    printf("    %s -n 10.1.1.1 -u user -p pass -s ftp:/dir -d local:/home -t 8                    # download files from ftp server to local directory\n", cmd);
    printf("    %s -n ftp.boss.xiaoyun -u user -p pass -s ftp:/dir  -d null -t 16                 # download files from ftp server to /dev/null\n\n", cmd);
    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x7710(%rip), %rdi      # 0x112a0
callq 0x45b0
leaq 0x744f(%rip), %rdi      # 0x10feb
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4050
leaq 0x7707(%rip), %rdi      # 0x112b4
callq 0x45b0
leaq 0x7704(%rip), %rdi      # 0x112bd
callq 0x45b0
leaq 0x771b(%rip), %rdi      # 0x112e0
callq 0x45b0
leaq 0x7737(%rip), %rdi      # 0x11308
callq 0x45b0
leaq 0x7750(%rip), %rdi      # 0x1132d
callq 0x45b0
leaq 0x775c(%rip), %rdi      # 0x11345
callq 0x45b0
leaq 0x7459(%rip), %rdi      # 0x1104e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4050
leaq 0x74c6(%rip), %rdi      # 0x110cc
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4050
leaq 0x7534(%rip), %rdi      # 0x1114b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4050
leaq 0x75ae(%rip), %rdi      # 0x111d6
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x4050
// File: /workspace/github_cpp_makefile_star2_O2/lianxings[P]ftp_benchmark/ftp_benchmark.cc
// Function: put_task_to_queue(task<fileInfo>&)
static int put_task_to_queue (task<fileInfo>& curTask) 
{
    std::unique_lock<std::mutex> lock(tasksMutex);
    while ((tasksQueue.size() >= maxQueueSize) && (liveWorkThread > 0)) {
        tasksProductCV.wait(lock);
    }
    if (liveWorkThread > 0) {
        tasksQueue.push(curTask);
        tasksExecuteCV.notify_one();
    } else {
        return -1;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xd7f0(%rip), %rsi      # 0x17438
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa326
leaq 0xd78c(%rip), %r15      # 0x173e8
leaq 0xd7fd(%rip), %r12      # 0x17460
movq %r15, %rdi
callq 0xa9cc
cmpq $0x4000, %rax           # imm = 0x4000
jb 0x9c8a
movl 0xd867(%rip), %eax      # 0x174e0
testl %eax, %eax
jle 0x9c8a
movq %r12, %rdi
movq %r14, %rsi
callq 0x40f0
jmp 0x9c63
movl 0xd850(%rip), %eax      # 0x174e0
testl %eax, %eax
jle 0x9cb3
leaq 0xd74d(%rip), %rdi      # 0x173e8
movq %rbx, %rsi
callq 0xaa1e
leaq 0xd7e6(%rip), %rdi      # 0x17490
callq 0x41c0
xorl %ebx, %ebx
jmp 0x9cb6
pushq $-0x1
popq %rbx
leaq 0x8(%rsp), %rdi
callq 0xa366
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa366
movq %rbx, %rdi
callq 0x46a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: size_to_string(unsigned long, char*)
void size_to_string(uint64_t size, char * buf)
{   
    uint64_t  multiplier = exbibytes;
    int i;

    for (i = 0; i < DIM(sizes); i++, multiplier /= 1024) {   
        if (size < multiplier)
            continue;
        if (size % multiplier == 0)
            sprintf(buf, "%llu %s", (unsigned long long)size / multiplier, sizes[i]);
        else
            sprintf(buf, "%.1f %s", (float) size / multiplier, sizes[i]);
        return ;
    }
    strcpy(buf, "0");
    return ;
}

// Assembly:
movabsq $0x1000000000000000, %r8 # imm = 0x1000000000000000
xorl %ecx, %ecx
cmpl $0x38, %ecx
je 0xbcd2
cmpq %rdi, %r8
jbe 0xbcd8
shrq $0xa, %r8
addq $0x8, %rcx
jmp 0xbcbe
movw $0x30, (%rsi)
retq
leaq -0x1(%r8), %rax
testq %rdi, %rax
je 0xbced
testq %rdi, %rdi
js 0xbd17
cvtsi2ss %rdi, %xmm0
jmp 0xbd2c
movq %rdi, %rax
xorl %edx, %edx
divq %r8
leaq 0xb054(%rip), %rdx      # 0x16d50
movq (%rcx,%rdx), %rcx
leaq 0x58d1(%rip), %rdx      # 0x115d8
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
xorl %eax, %eax
jmp 0x4090
movq %rdi, %rax
shrq %rax
andl $0x1, %edi
orq %rax, %rdi
cvtsi2ss %rdi, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %r8, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xb010(%rip), %rax      # 0x16d50
movq (%rcx,%rax), %rdx
leaq 0x5895(%rip), %rax      # 0x115e0
movq %rsi, %rdi
movq %rax, %rsi
movb $0x1, %al
jmp 0x4090
// File: /workspace/github_cpp_makefile_star2_O2/lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: string_to_size(char const*)
int64_t string_to_size(const char * str)
{
    char c;
    int64_t num;
    int64_t ret;
    int64_t mult;
    char buf[32];

    strcpy(buf, str);
    
    c = buf[strlen(buf) - 1];
    if (c > '9') {
        buf[strlen(buf) - 1] = '\0';
    }
    double f = atof(buf);
    num = atoll(buf);

    if(isdigit(c))
        return num;
    
    switch(c) {
    case 't':
    case 'T':
        mult = 0x1ULL << 40; //1024 * 1024 * 1024*1024;
	break;
    case 'g':
    case 'G':
        mult = 0x1ULL << 30; //1024 * 1024 * 1024;
	break;
    case 'm':
    case 'M':
        mult = 0x1ULL << 20;//1024 * 1024;
	break;
    case 'k':
    case 'K':
        mult = 0x1ULL << 10;//1024;
	break;
    case 'b':
    case 'B':
        mult = 1;
	break;
    default:
        return -1;
    }

    ret = mult * f;
    return ret;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4370
movq %rbx, %rdi
callq 0x4160
movsbl -0x1(%rax,%rbx), %ebx
cmpl $0x3a, %ebx
jl 0xbd82
movb $0x0, -0x1(%rsp,%rax)
movq %rsp, %rdi
callq 0x44b0
leal -0x30(%rbx), %eax
cmpl $0x9, %eax
ja 0xbd9c
movq %rsp, %rdi
callq 0x42d0
jmp 0xbe08
cmpb $0x42, %bl
je 0xbdf7
movzbl %bl, %eax
cmpl $0x47, %eax
je 0xbdd9
cmpl $0x4b, %eax
je 0xbded
cmpl $0x4d, %eax
je 0xbde3
movsd 0x57f5(%rip), %xmm1     # 0x115b0
cmpl $0x54, %eax
je 0xbdff
cmpl $0x62, %eax
je 0xbdf7
cmpl $0x74, %eax
je 0xbdff
cmpl $0x6b, %eax
je 0xbded
cmpl $0x6d, %eax
je 0xbde3
cmpl $0x67, %eax
jne 0xbe0e
movsd 0x57ef(%rip), %xmm1     # 0x115d0
jmp 0xbdff
movsd 0x57dd(%rip), %xmm1     # 0x115c8
jmp 0xbdff
movsd 0x57cb(%rip), %xmm1     # 0x115c0
jmp 0xbdff
movsd 0x57b9(%rip), %xmm1     # 0x115b8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
addq $0x20, %rsp
popq %rbx
retq
pushq $-0x1
popq %rax
jmp 0xbe08
// File: /workspace/github_cpp_makefile_star2_O2/lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: normalize_dir_format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void normalize_dir_format(string& localPath, string& ftpPath) 
{
    if (localPath.length() > 0 && localPath.at(localPath.size() - 1) != '/') {
        localPath.push_back('/');
    }

    if (ftpPath.length() > 0) {
        if (ftpPath.at(0) != '/') {
            ftpPath = "/" + ftpPath;
        }
        if (ftpPath.at(ftpPath.size() - 1) != '/') {
            ftpPath.push_back('/');
        }
    }
    return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0xbe41
movq %rdi, %r14
decq %rsi
callq 0x4710
cmpb $0x2f, (%rax)
je 0xbe41
pushq $0x2f
popq %rsi
movq %r14, %rdi
callq 0x4310
cmpq $0x0, 0x8(%rbx)
je 0xbea0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4710
cmpb $0x2f, (%rax)
je 0xbe81
leaq 0x4fc5(%rip), %rsi      # 0x10e23
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xc03b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44a0
movq %r14, %rdi
callq 0x4170
movq 0x8(%rbx), %rsi
decq %rsi
movq %rbx, %rdi
callq 0x4710
cmpb $0x2f, (%rax)
je 0xbea0
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x4310
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: resolve_list_entry(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void resolve_list_entry (const char * dataBuf, string& name, string& sizeStr) 
{
    if (dataBuf == NULL) return;
    int i = strlen(dataBuf) - 2;
    while (dataBuf[i] != ' ') {
        name = dataBuf[i] + name;
        --i;
    }
    int spaceNum = 0;
    while (spaceNum < 4) {
        if (dataBuf[i] == ' ')
            spaceNum++;
        --i;
    }
    while (dataBuf[i] != ' ') {
        sizeStr = dataBuf[i] + sizeStr;
        --i;
    }
}

// Assembly:
testq %rdi, %rdi
je 0xbf5c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4160
addl $-0x2, %eax
movslq %eax, %r12
addq %r15, %r12
leaq 0x8(%rsp), %r15
movb (%r12), %al
cmpb $0x20, %al
je 0xbf06
movsbl %al, %esi
movq %r15, %rdi
movq %r14, %rdx
callq 0xc0b1
movq %r14, %rdi
movq %r15, %rsi
callq 0x44a0
movq %r15, %rdi
callq 0x4170
decq %r12
jmp 0xbed8
xorl %eax, %eax
cmpl $0x4, %eax
jae 0xbf1e
xorl %ecx, %ecx
cmpb $0x20, (%r12)
sete %cl
addl %ecx, %eax
decq %r12
jmp 0xbf08
leaq 0x8(%rsp), %r14
movb (%r12), %al
cmpb $0x20, %al
je 0xbf51
movsbl %al, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xc0b1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44a0
movq %r14, %rdi
callq 0x4170
decq %r12
jmp 0xbf23
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/lianxings[P]ftp_benchmark/ftptest_utils.cc
// Function: resolve_base_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string resolve_base_name (const string& srcPath) 
{
    int lastSlashLoc = 0;
    int slashLoc = 0;
    string baseName("");
    while ((slashLoc = srcPath.find('/', lastSlashLoc)) != std::string::npos) {
        if (slashLoc == srcPath.size() - 1) {
            baseName = srcPath.substr(lastSlashLoc, srcPath.size() - lastSlashLoc);
            break;
        }
        lastSlashLoc = slashLoc + 1;
    }
    
    if (baseName.empty()) {
        baseName = srcPath.substr(lastSlashLoc, srcPath.size() - lastSlashLoc);
    }
    return baseName;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x497c(%rip), %rsi      # 0x108f2
movq %rsp, %rdx
callq 0x9dca
xorl %eax, %eax
pushq $0x2f
popq %rbp
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
movslq %eax, %r15
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x44e0
movq %rax, %rdx
shlq $0x20, %rdx
cmpq %r12, %rdx
je 0xbfe4
sarq $0x20, %rdx
movq 0x8(%r14), %rcx
leaq -0x1(%rcx), %rsi
incq %rax
cmpq %rsi, %rdx
jne 0xbf8d
subq %r15, %rcx
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4400
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x44a0
movq %r12, %rdi
callq 0x4170
cmpq $0x0, 0x8(%rbx)
jne 0xc016
movq 0x8(%r14), %rcx
subq %r15, %rcx
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4400
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44a0
movq %r14, %rdi
callq 0x4170
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc028
movq %rax, %r14
movq %rbx, %rdi
callq 0x4170
movq %r14, %rdi
callq 0x46a0