LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Bind(int, pictcore::WorkList&)
int Combination::Bind( int value, WorkList &worklist )
{
    int bound = 0;
    // Mark all as pending so we don't add any to the worklist
    for( auto param : m_params )
    {
        param->MarkPending();
    }

    for( ParamCollection::reverse_iterator iter =  m_params.rbegin();
                                           iter != m_params.rend();
                                         ++iter )
    {
        if( !( *iter )->GetBoundCount() )
        {
            ( *iter )->Bind( value % ( *iter )->GetValueCount(), worklist );
            ++bound;
        }
        value /= ( *iter )->GetValueCount();
    }

    return bound;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r12
movq %rcx, %rax
cmpq %r12, %rax
je 0x6b4f
movq (%rax), %rdx
movb $0x1, 0x3e(%rdx)
addq $0x8, %rax
jmp 0x6b3d
xorl %r15d, %r15d
cmpq %rcx, %r12
je 0x6b8b
movq -0x8(%r12), %rdi
addq $-0x8, %r12
cmpb $0x0, 0x3d(%rdi)
jne 0x6b81
movl %ebp, %eax
cltd
idivl 0x38(%rdi)
movl %edx, %esi
movq %rbx, %rdx
callq 0xf8e0
incl %r15d
movq (%r12), %rdi
movq 0x8(%r14), %rcx
movl %ebp, %eax
cltd
idivl 0x38(%rdi)
movl %eax, %ebp
jmp 0x6b52
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Feasible()
int Combination::Feasible()
{
    int* workbuf = m_model->GetTask()->GetWorkbuf();

    int nWorkVals = 1;
    workbuf[ 0 ] = 0;
    for( Parameter* param : m_params )
    {
        for( int i = 0; i < nWorkVals; i++ )
        {
            workbuf[ i ] *= param->GetValueCount();
        }
        int nCurrentVal = (int) param->GetLast();
        if( param->GetBoundCount() )
        {
            for( int i = 0; i < nWorkVals; ++i )
            {
                workbuf[ i ] += nCurrentVal;
            }
        }
        else
        {
            for( int i = 0; i < nWorkVals; ++i )
            {
                for( int addend = 1; addend < param->GetValueCount(); ++addend )
                {
                    workbuf[ i + nWorkVals*addend ] = workbuf[ i ] + addend;
                }
            }
            nWorkVals *= param->GetValueCount();
        }
    }

    // Now count the zeros corresponding to the open combinations
    int zeros = 0;
    for( int i = 0; i < nWorkVals; ++i )
    {
        if( Open == m_bitvec[ workbuf[ i ] ] )
        {
            ++zeros;
        }
    }

    return zeros;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x38(%rdi), %rax
movq 0x148(%rax), %rax
movq 0x68(%rax), %rcx
andl $0x0, (%rcx)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rsi
movl $0x1, %edx
movabsq $0x1, %r8
testl %edx, %edx
movl $0x0, %r9d
cmovgl %edx, %r9d
cmpq %rsi, %rax
je 0x6c64
movq (%rax), %r10
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x6bfd
movl (%rcx,%r11,4), %ebx
imull 0x38(%r10), %ebx
movl %ebx, (%rcx,%r11,4)
incq %r11
jmp 0x6be6
cmpb $0x1, 0x3d(%r10)
jne 0x6c19
movl 0x30(%r10), %r10d
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x6c5b
addl %r10d, (%rcx,%r11,4)
incq %r11
jmp 0x6c0b
movslq %edx, %r11
leaq (%rcx,%r11,4), %rbx
shlq $0x2, %r11
xorl %r14d, %r14d
cmpq %r9, %r14
je 0x6c56
movq %rbx, %r15
movq %r8, %r12
movslq 0x38(%r10), %r13
cmpq %r13, %r12
jge 0x6c4d
movl (%rcx,%r14,4), %ebp
addl %r12d, %ebp
movl %ebp, (%r15)
incq %r12
addq %r11, %r15
jmp 0x6c32
incq %r14
addq $0x4, %rbx
jmp 0x6c27
imull 0x38(%r10), %edx
addq $0x8, %rax
jmp 0x6bcb
movq 0x20(%rdi), %rsi
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
xorl %eax, %eax
cmpq %rdi, %rdx
je 0x6c87
movslq (%rcx,%rdi,4), %r8
cmpb $0x1, (%rsi,%r8)
adcl $0x0, %eax
incq %rdi
jmp 0x6c71
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Feasible(int)
ComboStatus Combination::Feasible( int value )
{
    if( EXCLUDED == m_bitvec[ value ] )
    {
        return Excluded;
    }
    ComboStatus retval = ( COVERED == m_bitvec[ value ] ) ? CoveredMatch : Open;
    for( ParamCollection::reverse_iterator iter = m_params.rbegin(); iter != m_params.rend(); ++iter )
    {
        if( ( *iter )->GetBoundCount() && ( *iter )->GetLast() != value % ( *iter )->GetValueCount() )
        {
            return Excluded;
        }
        value /= ( *iter )->GetValueCount();
    }

    return retval;
}

// Assembly:
movq 0x20(%rdi), %rax
movslq %esi, %rcx
movb (%rax,%rcx), %al
pushq $0x2
popq %rcx
cmpb $-0x1, %al
je 0x6cf0
xorl %r8d, %r8d
cmpb $0x1, %al
sete %r8b
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %rdi
cmpq %r9, %rdi
je 0x6ced
movq -0x8(%rdi), %rax
cmpb $0x0, 0x3d(%rax)
je 0x6cdb
movq 0x30(%rax), %r11
movl 0x38(%rax), %r10d
movl %esi, %eax
cltd
idivl %r10d
movslq %edx, %rax
cmpq %rax, %r11
je 0x6cdf
jmp 0x6cf0
movl 0x38(%rax), %r10d
addq $-0x8, %rdi
movl %esi, %eax
cltd
idivl %r10d
movl %eax, %esi
jmp 0x6cb4
movl %r8d, %ecx
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Weight(int)
int Combination::Weight( int value )
{
    int weight = 0;
    for( ParamCollection::reverse_iterator iter = m_params.rbegin(); iter != m_params.rend(); ++iter )
    {
        Parameter* param = *iter;
        weight += param->GetWeight( value % param->GetValueCount() );
        value /= param->GetValueCount();
    }

    return weight;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x10(%rdi), %r12
xorl %ebp, %ebp
cmpq 0x8(%rbx), %r12
je 0x6d38
movq -0x8(%r12), %r15
addq $-0x8, %r12
movl %r14d, %eax
cltd
idivl 0x38(%r15)
movq %r15, %rdi
movl %edx, %esi
callq 0x6fec
addl %eax, %ebp
movl %r14d, %eax
cltd
idivl 0x38(%r15)
movl %eax, %r14d
jmp 0x6d08
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::AddBinding()
int Combination::AddBinding()
{
    if( ++m_boundCount == m_params.size() )
    {
        // compute which zero we're setting
        size_t value = 0;
        for( ParamCollection::iterator iter = m_params.begin(); iter != m_params.end(); ++iter )
        {
            assert( ( *iter )->GetBoundCount() );
            value = ( value * ( *iter )->GetValueCount() ) + ( *iter )->GetLast();
        }

        // check to see if it's zero
        if( OPEN == m_bitvec[ value ] )
        {
            // if so, set it and count it locally and globally
            assert( value <= (size_t) m_range );
            m_bitvec[ value ] = COVERED;
            --m_openCount;
            --m_model->GlobalZerosCount;
        }
    }

    return m_boundCount;
}

// Assembly:
pushq %rax
movslq 0x30(%rdi), %rax
incq %rax
movl %eax, 0x30(%rdi)
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rsi, %rcx
subq %rdx, %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x6dac
xorl %ecx, %ecx
cmpq %rsi, %rdx
je 0x6d89
movq (%rdx), %r8
cmpb $0x0, 0x3d(%r8)
je 0x6dae
movslq 0x38(%r8), %r9
imulq %r9, %rcx
addq 0x30(%r8), %rcx
addq $0x8, %rdx
jmp 0x6d68
movq 0x20(%rdi), %rdx
cmpb $0x0, (%rdx,%rcx)
jne 0x6dac
movslq 0x28(%rdi), %rax
cmpq %rax, %rcx
ja 0x6dcd
movb $0x1, (%rdx,%rcx)
decl 0x2c(%rdi)
movq 0x38(%rdi), %rax
decl (%rax)
movl 0x30(%rdi), %eax
popq %rcx
retq
leaq 0x1b24f(%rip), %rdi     # 0x22004
leaq 0x1b263(%rip), %rsi     # 0x2201f
leaq 0x1b27b(%rip), %rcx     # 0x2203e
movl $0x98, %edx
callq 0x6310
leaq 0x1b292(%rip), %rdi     # 0x22066
leaq 0x1b244(%rip), %rsi     # 0x2201f
leaq 0x1b25c(%rip), %rcx     # 0x2203e
movl $0xa0, %edx
callq 0x6310
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::applyExclusion(pictcore::Exclusion&, int, __gnu_cxx::__normal_iterator<pictcore::Parameter**, std::vector<pictcore::Parameter*, std::allocator<pictcore::Parameter*>>>)
void Combination::applyExclusion( Exclusion& excl, int index, ParamCollection::iterator pos )
{
    if( m_params.end() == pos )
    {
        assert( index <= m_range );
        if( OPEN == m_bitvec[ index ] )
        {
            --m_openCount;
            --m_model->GlobalZerosCount;
        }
        m_bitvec[ index ] = EXCLUDED;
    }
    else
    {
        // Is *pos a parameter in the exclusion?
        Exclusion::iterator ie = find_if( excl.begin(),
                                          excl.end(),
                                          bind2nd( MatchParameterPointer(), *pos ) );
        // parameter is bound to a value in the exclusion
        if( excl.end() != ie )
        {
            applyExclusion( excl, index * ( *pos )->GetValueCount() + ie->second, pos + 1 );
        }
        // parameter ranges over all values in the exclusion
        else
        {
            for( int n = 0; n < ( *pos )->GetValueCount(); ++n )
            {
                applyExclusion( excl, index * ( *pos )->GetValueCount() + n, pos + 1 );
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r12
cmpq 0x10(%rbx), %r14
je 0x6e30
movq 0x18(%r15), %rdi
movq (%r14), %rdx
movq %r12, %rsi
callq 0x7051
cmpq %rax, %r12
je 0x6e5e
movq (%r14), %rcx
imull 0x38(%rcx), %ebp
addl 0x28(%rax), %ebp
addq $0x8, %r14
jmp 0x6e06
cmpl %ebp, 0x28(%rbx)
jl 0x6e89
movq 0x20(%rbx), %rax
movslq %ebp, %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x6e4b
decl 0x2c(%rbx)
movq 0x38(%rbx), %rdx
decl (%rdx)
movb $-0x1, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%r14), %r12
xorl %r13d, %r13d
movq (%r14), %rax
movl 0x38(%rax), %edx
cmpl %edx, %r13d
jge 0x6e4f
imull %ebp, %edx
addl %r13d, %edx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x6dec
incl %r13d
jmp 0x6e65
leaq 0x1b1f0(%rip), %rdi     # 0x22080
leaq 0x1b188(%rip), %rsi     # 0x2201f
leaq 0x1b1f3(%rip), %rcx     # 0x22091
movl $0xb4, %edx
callq 0x6310
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::ApplyExclusion(pictcore::Exclusion&)
void Combination::ApplyExclusion( Exclusion& excl )
{
    // only if this exclusion's parameters exist in the combo
    for( Exclusion::iterator it = excl.begin(); it != excl.end(); ++it )
    {
        ParamCollection::iterator ip = find( m_params.begin(), m_params.end(), it->first );
        if( ip == m_params.end() ) return;
    }

    applyExclusion( excl, 0, m_params.begin() );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
leaq 0x8(%rsi), %r12
movq 0x8(%r14), %rcx
cmpq %r12, %r15
je 0x6eea
movq 0x10(%r14), %rsi
leaq 0x20(%r15), %rdx
movq %rcx, %rdi
callq 0x707b
cmpq 0x10(%r14), %rax
je 0x6f02
movq %r15, %rdi
callq 0x6500
movq %rax, %r15
jmp 0x6ebe
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6dec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::ViolatesExclusion()
bool Combination::ViolatesExclusion()
{
    size_t nKey = 0;
    for( ParamCollection::iterator iter = m_params.begin(); iter != m_params.end(); ++iter )
    {
        nKey *= ( *iter )->GetValueCount();
        size_t nCurrentVal = ( *iter )->GetLast();
        assert( ( *iter )->GetBoundCount() );
        nKey += nCurrentVal;
    }

    return ( EXCLUDED == m_bitvec[ nKey ] );
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x6f39
movq (%rcx), %rsi
cmpb $0x0, 0x3d(%rsi)
je 0x6f46
movslq 0x38(%rsi), %r8
imulq %r8, %rax
addq 0x30(%rsi), %rax
addq $0x8, %rcx
jmp 0x6f19
movq 0x20(%rdi), %rcx
cmpb $-0x1, (%rcx,%rax)
sete %al
popq %rcx
retq
leaq 0x1b0b7(%rip), %rdi     # 0x22004
leaq 0x1b0cb(%rip), %rsi     # 0x2201f
leaq 0x1b18e(%rip), %rcx     # 0x220e9
movl $0xeb, %edx
callq 0x6310
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::SetOpen(int)
void Combination::SetOpen( int index )
{
    assert( index < m_range );
    if( OPEN != m_bitvec[ index ] )
    {
        m_bitvec[ index ] = OPEN;
        ++m_openCount;
        ++m_model->GlobalZerosCount;
    }
}

// Assembly:
cmpl %esi, 0x28(%rdi)
jle 0x6f86
movq 0x20(%rdi), %rax
movslq %esi, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x6f85
movb $0x0, (%rax,%rcx)
incl 0x2c(%rdi)
movq 0x38(%rdi), %rax
incl (%rax)
retq
pushq %rax
leaq 0x1b18b(%rip), %rdi     # 0x22119
leaq 0x1b08a(%rip), %rsi     # 0x2201f
leaq 0x1b18d(%rip), %rcx     # 0x22129
movl $0xf9, %edx
callq 0x6310
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/generator.h
// Function: pictcore::Parameter::GetWeight(int) const
int GetWeight( int n ) const
    {
        if( 0 <= n && n < static_cast<int>( m_valueWeights.size() ) )
            return m_valueWeights[ n ];
        else
            return 1;
    }

// Assembly:
pushq $0x1
popq %rax
testl %esi, %esi
js 0x7011
movq 0xa8(%rdi), %rcx
movq 0xb0(%rdi), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x7011
movl %esi, %eax
movl (%rcx,%rax,4), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/deriver.cpp
// Function: pictcore::ExclusionDeriver::consistent(pictcore::Exclusion&, pictcore::Exclusion&)
bool ExclusionDeriver::consistent( Exclusion &aa, Exclusion &bb )
{
    // make sure the smaller one is in the outer loop
    Exclusion *a;
    Exclusion *b;
    if( aa.size() < bb.size() )
    {
        a = &aa;
        b = &bb;
    }
    else
    {
        a = &bb;
        b = &aa;
    }

    Exclusion::iterator ib = b->begin();
    for( Exclusion::iterator ia = a->begin(); ia != a->end(); ++ia )
    {
        if( m_currentParam == ia->first )
            continue;

        // move ib to see if we can find ia's parameter
        // ia and ib are sorted by (i->first)->GetSequence() asc then i->second
        while( ib != b->end() && ( ia->first )->GetSequence() > ( ib->first )->GetSequence() )
            ++ib;

        // end of b, return true
        if( ib == b->end() )
            return true;

        // see if params match; if not, move on
        if( ( ia->first )->GetSequence() != ( ib->first )->GetSequence() )
            continue;

        // params match, what about values
        if( ia->second != ib->second )
            return false;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x28(%rsi), %rax
cmpq 0x28(%rdx), %rax
movq %rdx, %r12
cmovbq %rsi, %r12
cmovbq %rdx, %r14
movq 0x18(%r14), %r15
movq 0x18(%r12), %rbx
addq $0x8, %r12
movq 0x48(%rdi), %r13
addq $0x8, %r14
cmpq %r12, %rbx
je 0x71a5
movq 0x20(%rbx), %rbp
cmpq %rbp, %r13
je 0x717f
cmpq %r14, %r15
je 0x718c
movl 0x2c(%rbp), %eax
movq 0x20(%r15), %rcx
cmpl 0x2c(%rcx), %eax
jle 0x716a
movq %r15, %rdi
callq 0x6500
movq %rax, %r15
jmp 0x714c
movl 0x2c(%rbp), %eax
movq 0x20(%r15), %rcx
cmpl 0x2c(%rcx), %eax
jne 0x717f
movl 0x28(%rbx), %eax
cmpl 0x28(%r15), %eax
jne 0x71a5
movq %rbx, %rdi
callq 0x6500
movq %rax, %rbx
jmp 0x713e
movb $0x1, %cl
cmpq %r12, %rbx
sete %al
orb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
jmp 0x718e
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/deriver.cpp
// Function: pictcore::ExclusionDeriver::AddExclusion(pictcore::Exclusion&, bool)
pair<ExclusionCollection::iterator, bool> ExclusionDeriver::AddExclusion( Exclusion& excl, bool checkIfInCollection )
{
    // if there's already an exclusion that's broader, do not add
    if( checkIfInCollection )
    {
        if( alreadyInCollection( excl ) )
        {
            return make_pair( m_exclusions.end(), false );
        }
    }

    // now add
    pair<ExclusionCollection::iterator, bool> result = m_exclusions.insert( excl );
    if( result.second )
    {
        // later, we will attempt to find sorted lists so 
        // the lookup structure should keep them sorted, too
        sort( excl.lbegin(), excl.lend() );
        m_lookup.insert( excl.GetList() );
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
testl %edx, %edx
je 0x71d6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x75e4
testb %al, %al
je 0x71d6
addq $0x20, %rbx
xorl %ebp, %ebp
movq %rbx, %r14
jmp 0x720f
leaq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x8af8
movq %rax, %r14
movl %edx, %ebp
testb $0x1, %dl
je 0x720f
leaq 0x30(%r15), %r12
movq 0x30(%r15), %rdi
movq 0x38(%r15), %rsi
callq 0x8ceb
addq $0xb0, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7644
movq %r14, %rax
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/deriver.cpp
// Function: pictcore::ExclusionDeriver::peformDelete()
void ExclusionDeriver::peformDelete()
{
    if( !m_deletedAtLeastOne ) return;

    //
    // todo:
    // This approach must be changed, we should be removing unnecessary links instead of recreating them
    // For now however, the recreation seems safer and works fast enough
    //

    // actually delete all marked as deleted
    ExclusionCollection::iterator ie = m_exclusions.begin();
    while( ie != m_exclusions.end() )
    {
        if( ie->isDeleted() )
        {
            Exclusion* pExcl = const_cast<Exclusion*>( &*ie );
            m_lookup.erase( pExcl->GetList() );
            ie = __map_erase( m_exclusions, ie );
        }
        else
            ++ie;
    }

    // recreate links to params
    for( Parameter* param : m_parameters )
    {
        param->ClearExclusions();
    }

    for( ie = m_exclusions.begin(); ie != m_exclusions.end(); ++ie )
    {
        AddExclusionParamBackPtrs( ie );
    }

    // prepare for the next round
    m_deletedAtLeastOne = false;
    DOUT( L"obsolete exclusions removed, now have: " << static_cast<int>( m_exclusions.size() ) << L"\n" );
}

// Assembly:
cmpb $0x1, 0xb8(%rdi)
jne 0x7385
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x30(%rdi), %r12
leaq 0x20(%rdi), %r13
leaq 0xb0(%rdi), %r15
cmpq %r13, %r12
je 0x732f
cmpb $0x1, 0x68(%r12)
jne 0x7322
leaq 0x50(%r12), %rsi
movq %r15, %rdi
callq 0x77ee
movq %r14, %rdi
movq %r12, %rsi
callq 0x77ff
movq %rax, %r12
jmp 0x72f8
movq %r12, %rdi
callq 0x6500
movq %rax, %r12
jmp 0x72f8
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x7349
movq (%r14), %rdi
callq 0x7832
addq $0x8, %r14
jmp 0x7336
movq 0x30(%rbx), %r15
leaq 0x8(%rsp), %r14
movq %r15, 0x8(%rsp)
cmpq %r13, %r15
je 0x7371
movq %r14, %rdi
callq 0x7290
movq %r15, %rdi
callq 0x6500
movq %rax, %r15
jmp 0x7352
movb $0x0, 0xb8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/deriver.cpp
// Function: pictcore::ExclusionDeriver::alreadyInCollection(pictcore::Exclusion&)
inline bool ExclusionDeriver::alreadyInCollection( Exclusion &excl )
{
    // for all permutations
    sort( excl.lbegin(), excl.lend() );
    bool more = true;
    while( more )
    {
        if( m_lookup.find_prefix( excl.GetList() ) ) return true;
        more = next_permutation( excl.lbegin(), excl.lend() );
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsi), %r15
movq 0x30(%rsi), %rdi
movq 0x38(%rsi), %rsi
callq 0x8ceb
addq $0xb0, %r14
movb $0x1, %bpl
testb $0x1, %bpl
je 0x7632
movq %r14, %rdi
movq %r15, %rsi
callq 0x7d94
testb %al, %al
jne 0x7632
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
callq 0x7e84
movl %eax, %ebp
jmp 0x760c
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/trie.h
// Function: trie<std::vector<std::pair<pictcore::Parameter*, int>, std::allocator<std::pair<pictcore::Parameter*, int>>>>::insert(std::vector<std::pair<pictcore::Parameter*, int>, std::allocator<std::pair<pictcore::Parameter*, int>>>&)
bool insert( Col &t )
    {
        trienode<typename Col::value_type>* current = m_root;
        for( typename Col::iterator ic = t.begin(); ic != t.end(); ++ic )
        {
            typename TNodeCol::iterator found;
            found = current->children.find( *ic );
            if( found == current->children.end() )
            {
                trienode< typename Col::value_type > *node = NULL;

                try
                {
                    node = new trienode < typename Col::value_type >;
                }
                catch( std::bad_alloc e )
                {
                    return( false );
                }

                std::pair<typename TNodeCol::iterator, bool> ret = current->children.insert( make_pair( *ic, node ) );
                if( !ret.second ) return( false );

                found = ret.first;
            }
            current = found->second;
        }
        current->valid = true;

        return( true );
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rax
movq (%rsi), %rbx
pushq $0x38
popq %r15
movq %rsp, %r12
movq (%rax), %r13
movq 0x8(%r14), %rbp
cmpq %rbp, %rbx
je 0x76d1
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7df2
leaq 0x8(%r13), %rcx
cmpq %rcx, %rax
jne 0x76c7
movq %r15, %rdi
callq 0x6440
movq %rax, %rcx
addq $0x8, %rcx
andl $0x0, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movb $0x0, 0x30(%rax)
movups (%rbx), %xmm0
movaps %xmm0, (%rsp)
movq %rax, 0x10(%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x92ee
testb $0x1, %dl
je 0x76d6
addq $0x30, %rax
addq $0x10, %rbx
jmp 0x7662
movb $0x1, 0x30(%r13)
cmpq %rbp, %rbx
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x7723
movq %r14, %rdi
callq 0x6540
movq 0x2d886(%rip), %rax     # 0x34f88
addq $0x10, %rax
movq %rsp, %r15
movq %rax, (%r15)
movq %r14, %rdi
callq 0x6190
movq %r15, %rdi
callq 0x62d0
callq 0x6690
jmp 0x76d6
movq %r14, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/trie.h
// Function: trie<std::vector<std::pair<pictcore::Parameter*, int>, std::allocator<std::pair<pictcore::Parameter*, int>>>>::pfind_prefix(std::vector<std::pair<pictcore::Parameter*, int>, std::allocator<std::pair<pictcore::Parameter*, int>>>&)
trienode<typename Col::value_type>* pfind_prefix( Col &t )
    {
        trienode<typename Col::value_type> *current = m_root;
        for( typename Col::iterator ic = t.begin(); ic != t.end(); ++ic )
        {
            typename TNodeCol::iterator found = current->children.find( *ic );
            if( found == current->children.end() ) return( NULL );

            current = found->second;

            if( current->valid ) return( current );
        }

        return( current->valid ? current : NULL );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rdi), %rbx
movq (%rsi), %r15
cmpq 0x8(%r14), %r15
je 0x7dda
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7df2
addq $0x8, %rbx
cmpq %rbx, %rax
je 0x7de6
movq 0x30(%rax), %rbx
addq $0x10, %r15
cmpb $0x0, 0x30(%rbx)
je 0x7db0
jmp 0x7de8
xorl %eax, %eax
cmpb $0x0, 0x30(%rbx)
cmoveq %rax, %rbx
jmp 0x7de8
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/generator.h
// Function: pictcore::Exclusion::insert(std::pair<pictcore::Parameter*, int> const&)
std::pair<iterator, bool> insert( const ExclusionTerm& Term )
    {
        std::pair<iterator, bool> ret = col.insert( Term );
        if( ret.second ) vec.push_back( Term );
        assert( col.size() == vec.size() );
        return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x8490
movq %rax, %r14
movl %edx, %ebp
testb $0x1, %dl
je 0x8002
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x8472
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
sarq $0x4, %rax
cmpq %rax, 0x28(%rbx)
jne 0x8024
movq %r14, %rax
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a225(%rip), %rdi     # 0x22250
leaq 0x1a192(%rip), %rsi     # 0x221c4
leaq 0x1a230(%rip), %rcx     # 0x22269
movl $0x10a, %edx            # imm = 0x10A
callq 0x6310
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/trie.h
// Function: trie<std::vector<std::pair<pictcore::Parameter*, int>, std::allocator<std::pair<pictcore::Parameter*, int>>>>::pfind(std::vector<std::pair<pictcore::Parameter*, int>, std::allocator<std::pair<pictcore::Parameter*, int>>>&)
trienode<typename Col::value_type>* pfind( Col &t )
    {
        trienode<typename Col::value_type> *current = m_root;
        for( typename Col::iterator ic = t.begin(); ic != t.end(); ++ic )
        {
            typename TNodeCol::iterator found = current->children.find( *ic );
            if( found == current->children.end() ) return( NULL );

            current = found->second;
        }
        return( current->valid ? current : NULL );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rax
movq (%rsi), %r15
xorl %ebx, %ebx
movq (%rax), %r12
cmpq 0x8(%r14), %r15
je 0x94ea
movq %r12, %rdi
movq %r15, %rsi
callq 0x7df2
addq $0x8, %r12
cmpq %r12, %rax
je 0x94f6
addq $0x30, %rax
addq $0x10, %r15
jmp 0x94c3
xorl %ebx, %ebx
cmpb $0x0, 0x30(%r12)
cmovneq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/exclusion.cpp
// Function: contained
bool contained( Exclusion &a, Exclusion &b )
{
    if( b.size() < a.size() ) return( false );

    Exclusion::iterator ib = b.begin();
    for( Exclusion::iterator ia = a.begin(); ia != a.end(); ++ia )
    {
        // move ib until pointers of ia and ib match
        while( ib != b.end() && ( ia->first )->GetSequence() != ( ib->first )->GetSequence() )
        {
            ++ib;
        }

        // end of b, return true only if also end of a
        if( ib == b.end() ) return ia == a.end();

        // pointers match, what about values
        if( ia->second != ib->second ) return false;
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x28(%rsi), %rax
cmpq 0x28(%rdi), %rax
jae 0x995b
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
movq 0x18(%rdi), %r12
addq $0x8, %r14
addq $0x8, %rbx
cmpq %r14, %r12
sete %bpl
je 0x99b5
cmpq %rbx, %r15
je 0x994e
movq 0x20(%r12), %rax
movl 0x2c(%rax), %eax
movq 0x20(%r15), %rcx
cmpl 0x2c(%rcx), %eax
je 0x999d
movq %r15, %rdi
callq 0x6500
movq %rax, %r15
jmp 0x997a
movl 0x28(%r12), %eax
cmpl 0x28(%r15), %eax
jne 0x9950
movq %r12, %rdi
callq 0x6500
movq %rax, %r12
jmp 0x9971
movb $0x1, %bpl
jmp 0x9950
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/exclusion.cpp
// Function: compareExclusionTerms
int compareExclusionTerms( const ExclusionTerm& op1, const ExclusionTerm& op2 )
{
    assert( (( op1.first == op2.first ) && ( ( op1.first )->GetSequence() == ( op2.first )->GetSequence() ))
         || (( op1.first != op2.first ) && ( ( op1.first )->GetSequence() != ( op2.first )->GetSequence() )) );

    if( op1.first != op2.first )
        // return op1.first < op2.first ? -1 : 1;
        return ( op1.first )->GetSequence() < ( op2.first )->GetSequence() ? -1 : 1;
    else
        if( op1.second != op2.second )
            return op1.second < op2.second ? -1 : 1;
        else
            return 0;
}

// Assembly:
movq (%rdi), %rdx
movq (%rsi), %r8
movl 0x2c(%rdx), %eax
movl 0x2c(%r8), %ecx
cmpq %r8, %rdx
je 0x99d2
cmpl %ecx, %eax
jne 0x99e0
jmp 0x99ee
cmpl %ecx, %eax
jne 0x99ee
movl 0x8(%rsi), %ecx
xorl %eax, %eax
cmpl %ecx, 0x8(%rdi)
je 0x99ed
setge %al
movzbl %al, %eax
leal -0x1(,%rax,2), %eax
retq
pushq %rax
leaq 0x189a2(%rip), %rdi     # 0x22398
leaq 0x18a60(%rip), %rsi     # 0x2245d
leaq 0x18a76(%rip), %rcx     # 0x2247a
pushq $0x29
popq %rdx
callq 0x6310
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/exclusion.cpp
// Function: compareExclusions
int compareExclusions(const Exclusion& op1, const Exclusion& op2)
{
    Exclusion::const_iterator i_op1 = op1.begin();
    Exclusion::const_iterator i_op2 = op2.begin();

    int comp = 0;
    while( i_op1 != op1.end() &&
           i_op2 != op2.end() )
    {
        comp = compareExclusionTerms( *i_op1, *i_op2 );
        if( comp != 0 ) break;
        ++i_op1;
        ++i_op2;
    }
    if( comp != 0 )
        return( comp );
    else
        if( op1.size() != op2.size() )
            return op1.size() < op2.size() ? -1 : 1;
        else
            return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movq 0x18(%rsi), %r12
leaq 0x8(%rdi), %r13
leaq 0x8(%rsi), %rbp
cmpq %r13, %r15
je 0x9a61
cmpq %rbp, %r12
je 0x9a61
leaq 0x20(%r15), %rdi
leaq 0x20(%r12), %rsi
callq 0x99ba
testl %eax, %eax
jne 0x9a7a
movq %r15, %rdi
callq 0x6500
movq %rax, %r15
movq %r12, %rdi
callq 0x6500
movq %rax, %r12
jmp 0x9a2d
movq 0x28(%r14), %rcx
movq 0x28(%rbx), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x9a7a
xorl %eax, %eax
cmpq %rdx, %rcx
sbbl %eax, %eax
orl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/exclusion.cpp
// Function: pictcore::Exclusion::ResultParamCount() const
size_t Exclusion::ResultParamCount() const
{
    size_t count = 0;
    for( auto & term : col )
    {
        if( term.first->IsExpectedResultParam() )
        {
            ++count;
        }
    }
    return( count );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rbx
xorl %r14d, %r14d
cmpq %rbx, %rax
je 0x9ab6
movq 0x20(%rax), %rcx
movzbl 0x3c(%rcx), %ecx
addq %rcx, %r14
movq %rax, %rdi
callq 0x6500
jmp 0x9a9c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/model.cpp
// Function: pictcore::Model::generateRandomRow()
Exclusion Model::generateRandomRow()
{
    Exclusion row;
    for( ParamCollection::iterator ip = m_parameters.begin(); ip != m_parameters.end(); ++ip )
    {
        int sum = 0;
        for( int i = 0; i < ( *ip )->GetValueCount(); ++i )
        {
            sum += ( *ip )->GetWeight( i );
        }
        int idx = rand() % sum;

        int n;
        int val = 0;
        for( n = 0; n < ( *ip )->GetValueCount(); ++n )
        {
            if( val < idx )
            {
                val += ( *ip )->GetWeight( n );
            }
            else
            {
                break;
            }
        }

        row.insert( make_pair( *ip, n ) );
    }
    return( row );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
leaq 0x8(%rdi), %rax
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movb $0x0, 0x48(%rdi)
movq 0x8(%rsi), %r13
cmpq 0x10(%r14), %r13
je 0xa983
xorl %ebp, %ebp
xorl %r12d, %r12d
movq (%r13), %rdi
cmpl 0x38(%rdi), %ebp
jge 0xa93a
movl %ebp, %esi
callq 0x6fec
addl %eax, %r12d
incl %ebp
jmp 0xa923
callq 0x6120
cltd
idivl %r12d
movl %edx, %r12d
xorl %ebp, %ebp
xorl %r15d, %r15d
movq (%r13), %rdi
cmpl 0x38(%rdi), %ebp
jge 0xa967
cmpl %r12d, %r15d
jge 0xa967
movl %ebp, %esi
callq 0x6fec
addl %eax, %r15d
incl %ebp
jmp 0xa94b
movq %rdi, 0x8(%rsp)
movl %ebp, 0x10(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7fda
addq $0x8, %r13
jmp 0xa918
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7b50
movq %r14, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/model.cpp
// Function: pictcore::Model::rowViolatesExclusion(pictcore::Exclusion&)
bool Model::rowViolatesExclusion( Exclusion& row )
{
    for( ExclusionCollection::iterator ie = m_exclusions.begin(); ie != m_exclusions.end(); ++ie )
    {
        if( contained( const_cast<Exclusion&> ( *ie ), row ) )
        {
            return( true );
        }
    }
    return( false );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %r15
addq $0x28, %rbx
cmpq %rbx, %r15
je 0xa9dd
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x993c
testb %al, %al
jne 0xa9dd
movq %r15, %rdi
callq 0x6500
movq %rax, %r15
jmp 0xa9bb
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/model.cpp
// Function: pictcore::Model::rowViolatesExclusion(std::vector<unsigned long, std::allocator<unsigned long>>&)
bool Model::rowViolatesExclusion( ResultRow& row )
{
    for( ExclusionCollection::iterator ie = m_exclusions.begin(); ie != m_exclusions.end(); ++ie )
    {
        bool matches = true;
        for( Exclusion::iterator it = ie->begin(); it != ie->end(); ++it )
        {
            if( row[ it->first->GetSequence() ] != it->second )
            {
                matches = false;
                break;
            }
        }
        if( matches ) return( true );
    }
    return( false );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %r14
addq $0x28, %rbx
movq (%rsi), %r15
cmpq %rbx, %r14
je 0xab73
movq 0x38(%r14), %rax
leaq 0x28(%r14), %r12
cmpq %r12, %rax
je 0xab73
movq 0x20(%rax), %rcx
movslq 0x2c(%rcx), %rcx
movslq 0x28(%rax), %rdx
cmpq %rdx, (%r15,%rcx,8)
jne 0xab66
movq %rax, %rdi
callq 0x6500
jmp 0xab45
movq %r14, %rdi
callq 0x6500
movq %rax, %r14
jmp 0xab38
cmpq %rbx, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/model.cpp
// Function: pictcore::Model::generateFixedOrder()
void Model::generateFixedOrder()
{
    GlobalZerosCount = 0;
    
    // turn each submodel's output into a PseudoParameter and add to model
    for( SubmodelCollection::iterator im = m_submodels.begin(); im != m_submodels.end(); ++im )
    {
        // make a pseudo-parameter from the submodel, add to this model
        Parameter *pseudo = new PseudoParameter( m_order, ++m_lastParamId, *im );
        AddParameter( pseudo );
    }

    // initialize combinations based on contents of m_parameters
    vector<Combination*> vecCombo;

    for( ParamCollection::iterator ip = m_parameters.begin(); ip != m_parameters.end(); ++ip )
    {
        ( *ip )->SetOrder( m_order );
    }
    bool r1 = mapExclusionsToPseudoParameters();
    bool r2 = excludeConflictingParamValues();
    if( r1 || r2 ) deriveSubmodelExclusions();

    mapRowSeedsToPseudoParameters();

    Combination baseCombo( this );
    choose( m_parameters.begin(), m_parameters.end(), m_order, m_order, baseCombo, vecCombo );
    gcd( vecCombo );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
andl $0x0, (%rdi)
leaq 0x50(%rdi), %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0xb32d
movl $0xd8, %edi
callq 0x6440
movq %rax, %r14
movl 0x108(%rbx), %esi
movl 0x130(%rbx), %edx
incl %edx
movl %edx, 0x130(%rbx)
movq 0x10(%r12), %rcx
movq %rax, %rdi
callq 0xfc02
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc5c2
jmp 0xb2e9
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movl 0x108(%rbx), %edx
cmpq %rcx, %rax
je 0xb35a
movq (%rax), %rsi
movl %edx, 0x28(%rsi)
addq $0x8, %rax
jmp 0xb349
movq %rbx, %rdi
callq 0xbbce
movl %eax, %ebp
movq %rbx, %rdi
callq 0xadee
orb %al, %bpl
cmpb $0x1, %bpl
jne 0xb37d
movq %rbx, %rdi
callq 0xbee2
movq %rbx, %rdi
callq 0xbfe4
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x6fa6
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movl 0x108(%rbx), %ecx
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %r9
movq %rbx, %rdi
movl %ecx, %r8d
callq 0x9b4c
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x9ce0
leaq 0x30(%rsp), %rdi
callq 0x6fca
leaq 0x10(%rsp), %rdi
callq 0xd978
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb3fa
jmp 0xb3fa
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6fca
jmp 0xb3fd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd978
jmp 0xb419
movq %rax, %rbx
movl $0xd8, %esi
movq %r14, %rdi
callq 0x6460
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/model.cpp
// Function: pictcore::Model::deriveSubmodelExclusions()
void Model::deriveSubmodelExclusions()
{
    ExclusionDeriver deriver( GetTask() );

    // the deriver must know about pseudo parameters
    ParamCollection params;
    GetAllParameters( params );
    for( ParamCollection::iterator ip = params.begin(); ip != params.end(); ++ip )
    {
        deriver.AddParameter( *ip );
    }

    // run the deriver on the newly created set of exclusions
    if( !deriver.GetParameters().empty() )
    {
        for( ExclusionCollection::iterator i_e = m_exclusions.begin(); i_e != m_exclusions.end(); ++i_e )
        {
            deriver.AddExclusion( const_cast<Exclusion&> ( *i_e ), true );
        }
        deriver.DeriveExclusions();

        // must clear because some initial exclusions may have been removed during derivation as obsolete
        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
movq 0x148(%rdi), %rsi
leaq 0x20(%rsp), %rdi
callq 0xc664
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0xc6e2
movq (%rsp), %r15
leaq 0x20(%rsp), %r14
cmpq 0x8(%rsp), %r15
je 0xbf3c
movq (%r15), %rsi
movq %r14, %rdi
callq 0xc720
addq $0x8, %r15
jmp 0xbf24
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0xbfa0
leaq 0x20(%rbx), %r14
movq 0x38(%rbx), %r12
addq $0x28, %rbx
leaq 0x20(%rsp), %r15
pushq $0x1
popq %rbp
cmpq %rbx, %r12
je 0xbf7d
leaq 0x20(%r12), %rsi
movq %r15, %rdi
movl %ebp, %edx
callq 0x71aa
movq %r12, %rdi
callq 0x6500
movq %rax, %r12
jmp 0xbf5c
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 0xbfc6
jmp 0xbfc6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x701e
leaq 0x20(%rsp), %rdi
callq 0xc732
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/model.cpp
// Function: pictcore::seedContained(std::set<std::pair<pictcore::Parameter*, int>, std::less<std::pair<pictcore::Parameter*, int>>, std::allocator<std::pair<pictcore::Parameter*, int>>>&, std::set<std::pair<pictcore::Parameter*, int>, std::less<std::pair<pictcore::Parameter*, int>>, std::allocator<std::pair<pictcore::Parameter*, int>>>&)
bool seedContained( RowSeed &container, RowSeed &containee )
{
    // containee has to have all its elements matching exacly some element in the container
    for( RowSeed::iterator ic = containee.begin(); ic != containee.end(); ++ic )
    {
        if( container.find( *ic ) == container.end() ) return( false );
    }
    return( true );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
addq $0x8, %rbx
leaq 0x8(%rdi), %r12
cmpq %rbx, %r15
je 0xc2c7
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0xf7ec
cmpq %r12, %rax
je 0xc2c7
movq %r15, %rdi
callq 0x6500
movq %rax, %r15
jmp 0xc2a4
cmpq %rbx, %r15
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/model.cpp
// Function: pictcore::seedViolatesExclusion(std::set<std::pair<pictcore::Parameter*, int>, std::less<std::pair<pictcore::Parameter*, int>>, std::allocator<std::pair<pictcore::Parameter*, int>>>&, pictcore::Exclusion&)
bool seedViolatesExclusion( RowSeed &seed, Exclusion &exclusion )
{
    // exclusion has to have all its elements matching exacly some element in the seed
    for( Exclusion::iterator ie = exclusion.begin(); ie != exclusion.end(); ++ie )
    {
        // translate exclusion item into seed item
        // currently they are the same thing
        RowSeedTerm term = make_pair( ie->first, ie->second );
        if( seed.find( term ) == seed.end() ) return( false );
    }
    return( true );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
addq $0x8, %rbx
leaq 0x8(%rdi), %r13
movq %rsp, %r12
cmpq %rbx, %r15
je 0xc32d
movq 0x20(%r15), %rax
movl 0x28(%r15), %ecx
movq %rax, (%rsp)
movl %ecx, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xf7ec
cmpq %r13, %rax
je 0xc32d
movq %r15, %rdi
callq 0x6500
movq %rax, %r15
jmp 0xc2fb
cmpq %rbx, %r15
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/generator.h
// Function: pictcore::Combination::Assign(pictcore::Combination&)
void Assign( Combination &Combo )
    {
        m_params     = Combo.GetParameters();
        m_range      = Combo.GetRange();
        m_openCount  = Combo.GetOpenCount();
        m_boundCount = Combo.GetBoundCount();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rsi
addq $0x8, %rdi
callq 0xc7fc
movq 0x28(%rbx), %rax
movq %rax, 0x28(%r14)
movl 0x30(%rbx), %eax
movl %eax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/parameter.cpp
// Function: pictcore::Parameter::CleanUp()
void Parameter::CleanUp()
{
    m_pending = false;
    m_bound   = false;

    m_combinations.clear();
    m_result.clear();
    m_exclusions.clear();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andw $0x0, 0x3d(%rdi)
movq 0x40(%rdi), %rax
cmpq %rax, 0x48(%rdi)
je 0xf8c7
movq %rax, 0x48(%rbx)
leaq 0x90(%rbx), %rdi
callq 0xfce4
addq $0x58, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x7d22
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/parameter.cpp
// Function: pictcore::Parameter::Bind(int, pictcore::WorkList&)
bool Parameter::Bind(int value, WorkList& worklist)
{
    DOUT(L"Binding " << m_name << L" to value " << value << L".\n");
    assert(!m_bound);
    assert(value < m_valueCount);

    m_result.push_back(value);
    m_currentValue = value;
    m_bound = true;

    for( auto & combination : m_combinations )
    {
        if( combination->AddBinding() == combination->GetParameterCount() - 1 )
        {
            // Add any parameter that completes a combination to work list
            for( int n = 0; n < combination->GetParameterCount(); ++n )
            {
                if( !( (*combination)[ n ] ).GetBoundCount() )
                {
                    worklist.AddItem( &( *combination )[ n ] );
                }
            }
        }
    }

    worklist.Print();
    
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, 0x3d(%rdi)
je 0xf9a1
movq %rdi, %r14
cmpl %esi, 0x38(%rdi)
jle 0xf9ba
movq %rdx, %rbx
leaq 0x90(%r14), %rdi
movslq %esi, %r15
movq %rsp, %rsi
movq %r15, (%rsi)
callq 0xfcfc
movq %r15, 0x30(%r14)
movb $0x1, 0x3d(%r14)
movq 0x40(%r14), %r15
movq 0x48(%r14), %r14
cmpq %r14, %r15
je 0xf98b
movq (%r15), %rdi
callq 0x6d44
movq (%r15), %rdx
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
shrq $0x3, %rsi
decl %esi
cmpl %esi, %eax
jne 0xf985
xorl %r12d, %r12d
movq %rdx, %rax
subq %rcx, %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r12
jge 0xf985
movq (%rcx,%r12,8), %rsi
cmpb $0x0, 0x3d(%rsi)
jne 0xf980
movq %rbx, %rdi
callq 0x11028
movq (%r15), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
incq %r12
jmp 0xf952
addq $0x8, %r15
jmp 0xf927
movq %rbx, %rdi
callq 0x110ac
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x12f4f(%rip), %rdi     # 0x228f7
leaq 0x12f51(%rip), %rsi     # 0x22900
leaq 0x12f67(%rip), %rcx     # 0x2291d
pushq $0x1d
jmp 0xf9d1
leaq 0x12f8c(%rip), %rdi     # 0x2294d
leaq 0x12f38(%rip), %rsi     # 0x22900
leaq 0x12f4e(%rip), %rcx     # 0x2291d
pushq $0x1e
popq %rdx
callq 0x6310
nop
// File: /workspace/github_cpp_makefile_star2_O2/WShabti-Team[P]WShabtiPict/wshabtilib/api/parameter.cpp
// Function: pictcore::PseudoParameter::PseudoParameter(int, unsigned int, pictcore::Model*)
PseudoParameter::PseudoParameter( int order, unsigned int sequence, Model *model ) :
        Parameter( order, sequence, static_cast<int>( model->GetResultCount() ), wstring(), false ),
        m_model( model )
{
    m_name = L"";
    for( vector<Parameter*>::iterator ip =  model->GetParameters().begin();
                                      ip != model->GetParameters().end();
                                    ++ip )
    {
        if( ip != model->GetParameters().begin() )
        {
            m_name += L" ";
        }
        m_name += ( *ip )->GetName();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movl %edx, %ecx
movq %rdi, %rbx
movq 0xd8(%r14), %rax
subq 0xd0(%r14), %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
leaq 0x10(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
andl $0x0, (%rdx)
movq %rsp, %r8
movq %rbx, %rdi
movl %ecx, %edx
movl %eax, %ecx
xorl %r9d, %r9d
callq 0xfdd2
movq %rsp, %rdi
callq 0x6090
leaq 0x24e01(%rip), %rax     # 0x34a60
movq %rax, (%rbx)
movq %r14, 0xd0(%rbx)
leaq 0x8(%rbx), %r15
leaq 0x12d7c(%rip), %rsi     # 0x229f0
movq %r15, %rdi
callq 0x6420
movq 0x8(%r14), %r13
leaq 0x12d65(%rip), %r12     # 0x229ec
cmpq 0x10(%r14), %r13
je 0xfcb4
cmpq 0x8(%r14), %r13
je 0xfc9e
movq %r15, %rdi
movq %r12, %rsi
callq 0x6720
movq (%r13), %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x66f0
addq $0x8, %r13
jmp 0xfc87
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xfcd1
movq %rax, %r14
movq %rsp, %rdi
callq 0x6090
jmp 0xfcdc
movq %rax, %r14
movq %rbx, %rdi
callq 0xfebc
movq %r14, %rdi
callq 0x66e0