LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::SetMapSize(int, unsigned char)
void Combination::SetMapSize( int size, TrackType trackType )
{
    m_range = size;
    m_bitvec = new TrackType[ size ];

    memset( m_bitvec, trackType, size * sizeof( TrackType ) );
    if( OPEN == trackType )
    {
        m_openCount = size;
        m_model->GlobalZerosCount += size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x28(%rax)
movslq -0xc(%rbp), %rdi
callq 0x7040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rdi
movzbl -0xd(%rbp), %eax
movslq -0xc(%rbp), %rdx
shlq $0x0, %rdx
movzbl %al, %esi
callq 0x7330
movzbl -0xd(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x7fcd
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x2c(%rax)
movl -0xc(%rbp), %ecx
movq 0x38(%rax), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x1c(%rbp)
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8c90
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8cc0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8cf0
testb $0x1, %al
jne 0x8037
jmp 0x805b
leaq -0x30(%rbp), %rdi
callq 0x8d30
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x8d50
leaq -0x30(%rbp), %rdi
callq 0x8d70
jmp 0x8024
movq -0x58(%rbp), %rsi
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
callq 0x8d90
movq -0x58(%rbp), %rsi
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
callq 0x8e10
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8de0
testb $0x1, %al
jne 0x8093
jmp 0x8119
leaq -0x48(%rbp), %rdi
callq 0x8e60
movq (%rax), %rdi
callq 0x8e90
testb $0x1, %al
jne 0x80ef
leaq -0x48(%rbp), %rdi
callq 0x8e60
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8e60
movq (%rax), %rdi
callq 0x8eb0
movq -0x68(%rbp), %rdi
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cltd
idivl %ecx
movl %edx, %esi
movq -0x18(%rbp), %rdx
callq 0x2d2e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8e60
movq (%rax), %rdi
callq 0x8eb0
movl %eax, %ecx
movl -0xc(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8ed0
jmp 0x806c
movl -0x1c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movl $0xff, %eax
cmpl %ecx, %eax
jne 0x8358
movl $0x2, -0x4(%rbp)
jmp 0x843b
movq -0x30(%rbp), %rsi
movq 0x20(%rsi), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %edx
movl $0x1, %ecx
xorl %eax, %eax
cmpl %edx, %ecx
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x8d90
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x8e10
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8de0
testb $0x1, %al
jne 0x83ab
jmp 0x8435
leaq -0x20(%rbp), %rdi
callq 0x8e60
movq (%rax), %rdi
callq 0x8e90
testb $0x1, %al
jne 0x83c2
jmp 0x840b
leaq -0x20(%rbp), %rdi
callq 0x8e60
movq (%rax), %rdi
callq 0x8f40
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8e60
movq (%rax), %rdi
callq 0x8eb0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cltd
idivl %ecx
movq -0x38(%rbp), %rax
movslq %edx, %rcx
cmpq %rcx, %rax
je 0x840b
movl $0x2, -0x4(%rbp)
jmp 0x843b
leaq -0x20(%rbp), %rdi
callq 0x8e60
movq (%rax), %rdi
callq 0x8eb0
movl %eax, %ecx
movl -0x14(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8ed0
jmp 0x8384
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
movl $0x0, -0x10(%rbp)
addq $0x8, %rsi
leaq -0x18(%rbp), %rdi
callq 0x8d90
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x8e10
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8de0
testb $0x1, %al
jne 0x849f
jmp 0x8501
leaq -0x18(%rbp), %rdi
callq 0x8e60
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8eb0
movq -0x40(%rbp), %rdi
movl %eax, %ecx
movl -0x34(%rbp), %eax
cltd
idivl %ecx
movl %edx, %esi
callq 0x8f60
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8eb0
movl %eax, %ecx
movl -0xc(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8ed0
jmp 0x847b
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl 0x30(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x30(%rdi)
cltq
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x8fd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x8689
movq -0x30(%rbp), %rdi
movq $0x0, -0x10(%rbp)
addq $0x8, %rdi
callq 0x8c90
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x8cc0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8cf0
testb $0x1, %al
jne 0x858c
jmp 0x861b
leaq -0x18(%rbp), %rdi
callq 0x8d30
movq (%rax), %rdi
callq 0x8e90
testb $0x1, %al
jne 0x85a3
jmp 0x85a5
jmp 0x85c4
leaq 0x5ba68(%rip), %rdi     # 0x64014
leaq 0x5ba7c(%rip), %rsi     # 0x6402f
movl $0x98, %edx
leaq 0x5ba8f(%rip), %rcx     # 0x6404e
callq 0x7450
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8d30
movq (%rax), %rdi
callq 0x8eb0
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
imulq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8d30
movq (%rax), %rdi
callq 0x8f40
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8d70
jmp 0x8565
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x8687
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq 0x28(%rcx), %rcx
cmpq %rcx, %rax
ja 0x8644
jmp 0x8663
leaq 0x5ba2b(%rip), %rdi     # 0x64076
leaq 0x5b9dd(%rip), %rsi     # 0x6402f
movl $0xa0, %edx
leaq 0x5b9f0(%rip), %rcx     # 0x6404e
callq 0x7450
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rdx
movb $0x1, (%rcx,%rdx)
movl 0x2c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rax)
movq 0x38(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x8689
movq -0x30(%rbp), %rax
movl 0x30(%rax), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9090
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x90c0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9130
testb $0x1, %al
jne 0x8935
jmp 0x89aa
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x8c90
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x8cc0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9160
movq %rax, %rdx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x91c0
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x8cc0
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8ff0
testb $0x1, %al
jne 0x8998
jmp 0x899a
jmp 0x89d6
jmp 0x899c
leaq -0x18(%rbp), %rdi
callq 0x9210
jmp 0x8915
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x8, %rdi
callq 0x8c90
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
xorl %edx, %edx
callq 0x86a0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq $0x0, -0x10(%rbp)
addq $0x8, %rdi
callq 0x8c90
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x8cc0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8cf0
testb $0x1, %al
jne 0x8a30
jmp 0x8ab3
leaq -0x18(%rbp), %rdi
callq 0x8d30
movq (%rax), %rdi
callq 0x8eb0
cltq
imulq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8d30
movq (%rax), %rdi
callq 0x8f40
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8d30
movq (%rax), %rdi
callq 0x8e90
testb $0x1, %al
jne 0x8a78
jmp 0x8a7a
jmp 0x8a99
leaq 0x5b593(%rip), %rdi     # 0x64014
leaq 0x5b5a7(%rip), %rsi     # 0x6402f
movl $0xeb, %edx
leaq 0x5b665(%rip), %rcx     # 0x640f9
callq 0x7450
movq -0x28(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8d70
jmp 0x8a09
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movl $0xff, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x8b01
jmp 0x8b20
leaq 0x5b621(%rip), %rdi     # 0x64129
leaq 0x5b520(%rip), %rsi     # 0x6402f
movl $0xf9, %edx
leaq 0x5b61e(%rip), %rcx     # 0x64139
callq 0x7450
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x8b5a
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rdx
movb $0x0, (%rcx,%rdx)
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movq 0x38(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/combination.cpp
// Function: pictcore::Combination::Print()
void Combination::Print()
{
    DOUT( L"Combo dump: name " << GetId() << L" range " << m_range << L", " << m_openCount << L" zeros, "
          << ( m_boundCount ? L"" : L"not " ) << L"bound. " );
    DOUT( L" " << GetParameterCount() << L" parameters: " );
    for( int n = 0; n < GetParameterCount(); ++n )
        DOUT( ( *this )[ n ].GetName() << L" [" << ( *this )[ n ].GetSequence() << L"] " );
    DOUT( L" " );
    for( int n = 0; n < m_range; ++n )
        DOUT( m_bitvec[ n ] << L" " );
    DOUT( L"\n" );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x92c0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x8c60
jmp 0x8c55
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8c3b
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x8c80
jmp 0x8c75
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8c67
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jg 0x8fb9
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0xa8, %rdi
callq 0x9360
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x8fb9
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x9380
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x8fc0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, -0x21(%rbp)
je 0x9f66
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xaa80
testb $0x1, %al
jne 0x9f2b
jmp 0x9f64
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0xab70
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0xab40
movb %dl, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movb -0x40(%rbp), %al
movb %al, -0x8(%rbp)
jmp 0x9fde
jmp 0x9f66
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
callq 0xaba0
movb %dl, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movb -0x50(%rbp), %al
movb %al, -0x8(%rbp)
testb $0x1, -0x8(%rbp)
je 0x9fdc
movq -0x20(%rbp), %rdi
callq 0xac30
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0xac60
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xabf0
movq -0x70(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaeb0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0xac90
jmp 0x9fde
movq -0x10(%rbp), %rax
movb -0x8(%rbp), %dl
addq $0x80, %rsp
popq %rbp
retq
nop
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/deriver.cpp
// Function: pictcore::ExclusionDeriver::markObsolete(std::_Rb_tree_const_iterator<pictcore::Exclusion>)
void ExclusionDeriver::markObsolete( ExclusionCollection::iterator ie )
{
    // empty exclusions would obsolete all others; we don't want to remove those
    if( ie->empty() ) return;

    for( ExclusionCollection::iterator im =  m_exclusions.begin();
                                       im != m_exclusions.end(); 
                                     ++im )
    {
        if( ( ie != im )
         && ( !im->isDeleted() )
         && contained( const_cast<Exclusion&> ( *ie ), const_cast<Exclusion&>( *im ) ) )
        {
            markDeleted( const_cast<Exclusion*>( &*im ) );
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xaed0
movq %rax, %rdi
callq 0xaf00
testb $0x1, %al
jne 0xa01f
jmp 0xa024
jmp 0xa0ce
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0xaf20
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0xab70
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xaf50
testb $0x1, %al
jne 0xa059
jmp 0xa0ce
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xaf50
testb $0x1, %al
jne 0xa06c
jmp 0xa0be
leaq -0x18(%rbp), %rdi
callq 0xaed0
movq %rax, %rdi
callq 0xaf80
testb $0x1, %al
jne 0xa0be
leaq -0x8(%rbp), %rdi
callq 0xafa0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xafa0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x14a30
testb $0x1, %al
jne 0xa0a9
jmp 0xa0be
leaq -0x18(%rbp), %rdi
callq 0xafa0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xafc0
jmp 0xa0c0
leaq -0x18(%rbp), %rdi
callq 0xb000
jmp 0xa035
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
testb $0x1, 0xb8(%rax)
jne 0xa182
jmp 0xa2eb
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
callq 0xaf20
movq %rax, -0x10(%rbp)
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
callq 0xab70
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xaf50
testb $0x1, %al
jne 0xa1b7
jmp 0xa236
leaq -0x10(%rbp), %rdi
callq 0xaed0
movq %rax, %rdi
callq 0xaf80
testb $0x1, %al
jne 0xa1ce
jmp 0xa228
leaq -0x10(%rbp), %rdi
callq 0xafa0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x20(%rbp)
addq $0xb0, %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rdi
callq 0xaeb0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0xb220
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0xb260
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xa231
leaq -0x10(%rbp), %rdi
callq 0xb000
jmp 0xa193
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8c90
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8cc0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8cf0
testb $0x1, %al
jne 0xa26b
jmp 0xa28f
leaq -0x40(%rbp), %rdi
callq 0x8d30
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0xb2e0
leaq -0x40(%rbp), %rdi
callq 0x8d70
jmp 0xa258
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
callq 0xaf20
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
callq 0xab70
movq %rax, -0x60(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xaf50
testb $0x1, %al
jne 0xa2cc
jmp 0xa2e0
leaq -0x10(%rbp), %rdi
callq 0xa0e0
leaq -0x10(%rbp), %rdi
callq 0xb000
jmp 0xa2a8
movq -0x68(%rbp), %rax
movb $0x0, 0xb8(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/deriver.cpp
// Function: pictcore::ExclusionDeriver::printLookupNode(trienode<std::pair<pictcore::Parameter*, int>>*, int)
void ExclusionDeriver::printLookupNode( trienode<Exclusion::_ExclusionVec::value_type> *node, int indent )
{
    for( auto ii = node->children.begin(); ii != node->children.end(); ++ii )
   {
        for( int i = 0; i < indent; ++i )
            DOUT( L"  " );
        DOUT( ii->first.first->GetName() << L": " << ii->first.second << L" [" << ii->second->value << L"]\n" );
        printLookupNode( ii->second, indent + 1 );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd00
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xbd30
testb $0x1, %al
jne 0xa9b8
jmp 0xa9fb
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xa9d4
jmp 0xa9c9
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa9bf
leaq -0x20(%rbp), %rdi
callq 0xbd90
movq -0x38(%rbp), %rdi
movq 0x10(%rax), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0xa970
leaq -0x20(%rbp), %rdi
callq 0xbdb0
jmp 0xa998
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0xac30
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xac60
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xabf0
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0xab26
movq -0x48(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaeb0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xcaf0
testb $0x1, %al
jne 0xaaf2
jmp 0xaaf8
movb $0x1, -0x1(%rbp)
jmp 0xab2a
movq -0x18(%rbp), %rdi
callq 0xac30
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xac60
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xcb20
andb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0xaac3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/generator.h
// Function: std::set<pictcore::Exclusion, pictcore::ExclusionSizeLess, std::allocator<pictcore::Exclusion>>::iterator __map_erase<std::set<pictcore::Exclusion, pictcore::ExclusionSizeLess, std::allocator<pictcore::Exclusion>>>(std::set<pictcore::Exclusion, pictcore::ExclusionSizeLess, std::allocator<pictcore::Exclusion>>&, std::set<pictcore::Exclusion, pictcore::ExclusionSizeLess, std::allocator<pictcore::Exclusion>>::iterator)
typename _Col::iterator __map_erase
    (
    _Col&    collection,
    typename _Col::iterator where
    )
{
    if ( where == collection.end() ) return( collection.end() );
    typename _Col::iterator next = where;
    ++next;
    collection.erase( where );
    return( next );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xab70
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13600
testb $0x1, %al
jne 0xb290
jmp 0xb29f
movq -0x18(%rbp), %rdi
callq 0xab70
movq %rax, -0x8(%rbp)
jmp 0xb2c9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xb000
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x13630
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbe50
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbea0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xcc60
testb $0x1, %al
jne 0xcbab
jmp 0xcc2b
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xccd0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xcca0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbd60
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xccf0
testb $0x1, %al
jne 0xcbec
jmp 0xcbf6
movq $0x0, -0x8(%rbp)
jmp 0xcc4f
leaq -0x38(%rbp), %rdi
callq 0xbd90
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0xcc1b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc4f
jmp 0xcc1d
leaq -0x28(%rbp), %rdi
callq 0xcd20
jmp 0xcb88
movq -0x20(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0xcc3f
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xcc47
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xcc47
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0xf2b0
movb %dl, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movb -0x28(%rbp), %al
movb %al, -0x8(%rbp)
testb $0x1, -0x8(%rbp)
je 0xd9fd
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0xf300
movq -0x38(%rbp), %rdi
callq 0xbde0
movq -0x38(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
callq 0xeb90
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0xda25
jmp 0xda44
leaq 0x56846(%rip), %rdi     # 0x64272
leaq 0x567b3(%rip), %rsi     # 0x641e6
movl $0x10a, %edx            # imm = 0x10A
leaq 0x5684c(%rip), %rcx     # 0x6428b
callq 0x7450
movq -0x10(%rbp), %rax
movb -0x8(%rbp), %dl
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbe50
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbea0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xcc60
testb $0x1, %al
jne 0x13568
jmp 0x135d2
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xccd0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xcca0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbd60
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xccf0
testb $0x1, %al
jne 0x135a9
jmp 0x135b3
movq $0x0, -0x8(%rbp)
jmp 0x135f6
leaq -0x38(%rbp), %rdi
callq 0xbd90
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcd20
jmp 0x13548
movq -0x20(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x135e6
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x135ee
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x135ee
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaa10
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaa10
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x14a6b
movb $0x0, -0x1(%rbp)
jmp 0x14b96
movq -0x18(%rbp), %rdi
callq 0x9090
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9090
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x90c0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9130
testb $0x1, %al
jne 0x14aa8
jmp 0x14b92
jmp 0x14aaa
movq -0x18(%rbp), %rdi
callq 0x90c0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9130
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x51(%rbp)
jne 0x14ad2
jmp 0x14b04
leaq -0x28(%rbp), %rdi
callq 0x9160
movq (%rax), %rdi
callq 0xaa30
movl %eax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9160
movq (%rax), %rdi
callq 0xaa30
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x14b0d
jmp 0x14b18
leaq -0x20(%rbp), %rdi
callq 0x9210
jmp 0x14aaa
movq -0x18(%rbp), %rdi
callq 0x90c0
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xaa50
testb $0x1, %al
jne 0x14b38
jmp 0x14b59
movq -0x10(%rbp), %rdi
callq 0x90c0
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xaa50
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x14b96
leaq -0x28(%rbp), %rdi
callq 0x9160
movl 0x8(%rax), %eax
movl %eax, -0x5c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9160
movq %rax, %rcx
movl -0x5c(%rbp), %eax
cmpl 0x8(%rcx), %eax
je 0x14b82
movb $0x0, -0x1(%rbp)
jmp 0x14b96
jmp 0x14b84
leaq -0x28(%rbp), %rdi
callq 0x9210
jmp 0x14a85
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x14bf9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xaa30
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xaa30
movl -0x20(%rbp), %ecx
movl %eax, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
je 0x14c3c
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x21(%rbp)
je 0x14c36
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xaa30
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xaa30
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x14c45
jmp 0x14c47
jmp 0x14c66
leaq 0x4f76c(%rip), %rdi     # 0x643ba
leaq 0x4f82a(%rip), %rsi     # 0x6447f
movl $0x29, %edx
leaq 0x4f83b(%rip), %rcx     # 0x6449c
callq 0x7450
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x14caa
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xaa30
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xaa30
movl -0x2c(%rbp), %edx
movl %eax, %esi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x14ce3
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x14cdc
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x14ce3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb030
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb030
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb060
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9130
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x14d49
jmp 0x14d66
movq -0x18(%rbp), %rdi
callq 0xb060
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9130
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x14d6f
jmp 0x14db3
leaq -0x20(%rbp), %rdi
callq 0x9910
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9910
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x14bb0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x14d9c
jmp 0x14db3
leaq -0x20(%rbp), %rdi
callq 0x9210
leaq -0x28(%rbp), %rdi
callq 0x9210
jmp 0x14d21
cmpl $0x0, -0x2c(%rbp)
je 0x14dc1
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14e1c
movq -0x10(%rbp), %rdi
callq 0xaa10
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaa10
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0x14e15
movq -0x10(%rbp), %rdi
callq 0xaa10
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaa10
movq -0x60(%rbp), %rdx
movq %rax, %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x14e1c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x93a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9420
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9130
testb $0x1, %al
jne 0x14e79
jmp 0x14eb1
leaq -0x20(%rbp), %rdi
callq 0x9910
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x150e0
testb $0x1, %al
jne 0x14e98
jmp 0x14ea4
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x14ea6
leaq -0x20(%rbp), %rdi
callq 0x9210
jmp 0x14e66
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
callq 0xaf20
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0xab70
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf50
testb $0x1, %al
jne 0x17719
jmp 0x17747
leaq -0x20(%rbp), %rdi
callq 0xafa0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x14a30
testb $0x1, %al
jne 0x17734
jmp 0x1773a
movb $0x1, -0x1(%rbp)
jmp 0x1774b
jmp 0x1773c
leaq -0x20(%rbp), %rdi
callq 0xb000
jmp 0x176f5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x20, %rdi
callq 0xaf20
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0xab70
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaf50
testb $0x1, %al
jne 0x17a7c
jmp 0x17b31
movb $0x1, -0x29(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xaed0
movq %rax, %rdi
callq 0xb030
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xaed0
movq %rax, %rdi
callq 0xb060
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9130
testb $0x1, %al
jne 0x17abd
jmp 0x17b15
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9160
movq (%rax), %rdi
callq 0xaa30
movq -0x58(%rbp), %rdi
movslq %eax, %rsi
callq 0x1c6e0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9160
movq %rax, %rcx
movq -0x50(%rbp), %rax
movslq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0x17b08
movb $0x0, -0x29(%rbp)
jmp 0x17b15
jmp 0x17b0a
leaq -0x38(%rbp), %rdi
callq 0x9210
jmp 0x17a95
testb $0x1, -0x29(%rbp)
je 0x17b21
movb $0x1, -0x1(%rbp)
jmp 0x17b35
jmp 0x17b23
leaq -0x20(%rbp), %rdi
callq 0xb000
jmp 0x17a55
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/model.cpp
// Function: pictcore::Model::Generate()
void Model::Generate()
{
    DOUT( L"Num of params " << (int) m_parameters.size() <<
          L", order: "      << m_order <<
          L", seed: "       << m_randomSeed << endl );
    for( ParamCollection::iterator ip = m_parameters.begin(); ip != m_parameters.end(); ++ip )
        DOUT( ( *ip )->GetName() << L", order: " << ( *ip )->GetOrder() << endl );

    switch( m_generationType )
    {
    case MixedOrder:
        generateMixedOrder();
        break;
    case FixedOrder:
        generateFixedOrder();
        break;
    case Full:
        generateFull();
        break;
    case Flat:
        generateFlat();
        break;
    case Random:
        generateRandom();
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0x8c90
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x8cc0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8cf0
testb $0x1, %al
jne 0x18995
jmp 0x189a2
jmp 0x18997
leaq -0x10(%rbp), %rdi
callq 0x8d70
jmp 0x18971
movq -0x20(%rbp), %rax
movl 0x120(%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x4, %rax
ja 0x189ff
movq -0x28(%rbp), %rax
leaq 0x4bc4b(%rip), %rcx     # 0x6460c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
callq 0x18a10
jmp 0x189ff
movq -0x20(%rbp), %rdi
callq 0x18d80
jmp 0x189ff
movq -0x20(%rbp), %rdi
callq 0x19050
jmp 0x189ff
movq -0x20(%rbp), %rdi
callq 0x194a0
jmp 0x189ff
movq -0x20(%rbp), %rdi
callq 0x19830
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ba10
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ba40
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9130
testb $0x1, %al
jne 0x1b39d
jmp 0x1b3f1
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9910
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1d820
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba40
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xaa50
testb $0x1, %al
jne 0x1b3de
jmp 0x1b3e4
movb $0x0, -0x1(%rbp)
jmp 0x1b3f5
jmp 0x1b3e6
leaq -0x20(%rbp), %rdi
callq 0x9210
jmp 0x1b37d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq