LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9090
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x90c0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9130
testb $0x1, %al
jne 0x1b440
jmp 0x1b4c6
leaq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x9160
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x9160
movq -0x60(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x1d860
movl %edx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1d820
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba40
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xaa50
testb $0x1, %al
jne 0x1b4b0
jmp 0x1b4b6
movb $0x0, -0x1(%rbp)
jmp 0x1b4ca
jmp 0x1b4b8
leaq -0x20(%rbp), %rdi
callq 0x9210
jmp 0x1b41d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1daf0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rdi
callq 0x1db10
movq -0x10(%rbp), %rdi
callq 0x1b920
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x1dd60
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rdi
callq 0x1dd80
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/generator.h
// Function: pictcore::Model::GetResultParameterCount()
size_t GetResultParameterCount()
    {
        size_t count = 0;
        for( auto & param : m_parameters )
            if( param->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)
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8c90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8cc0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8cf0
testb $0x1, %al
jne 0x1bf9d
jmp 0x1bfd5
leaq -0x20(%rbp), %rdi
callq 0x8d30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x150e0
testb $0x1, %al
jne 0x1bfbc
jmp 0x1bfc8
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1bfca
leaq -0x20(%rbp), %rdi
callq 0x8d70
jmp 0x1bf8a
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x0, 0x3e(%rdi)
movb $0x0, 0x3d(%rdi)
addq $0x40, %rdi
callq 0x2da70
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x2da90
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0xc930
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movb 0x3d(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d306
jmp 0x2d308
jmp 0x2d327
leaq 0x375f4(%rip), %rdi     # 0x64903
leaq 0x375f6(%rip), %rsi     # 0x6490c
movl $0x1d, %edx
leaq 0x37607(%rip), %rcx     # 0x64929
callq 0x7450
movq -0x50(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x38(%rcx), %eax
jge 0x2d335
jmp 0x2d354
leaq 0x3761d(%rip), %rdi     # 0x64959
leaq 0x375c9(%rip), %rsi     # 0x6490c
movl $0x1e, %edx
leaq 0x375da(%rip), %rcx     # 0x64929
callq 0x7450
movq -0x50(%rbp), %rdi
addq $0x90, %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x2dac0
movq -0x50(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rcx, 0x30(%rax)
movb $0x1, 0x3d(%rax)
addq $0x40, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1b860
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1b8d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1b890
testb $0x1, %al
jne 0x2d3b8
jmp 0x2d46b
leaq -0x30(%rbp), %rdi
callq 0x1b900
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x8510
movl %eax, -0x54(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x92c0
movl %eax, %ecx
movl -0x54(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2d45b
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x92c0
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
jge 0x2d459
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movl -0x44(%rbp), %esi
callq 0x1b710
movq %rax, %rdi
callq 0x8e90
testb $0x1, %al
jne 0x2d44c
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movl -0x44(%rbp), %esi
callq 0x1b710
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x326a0
jmp 0x2d44e
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2d3f3
jmp 0x2d45b
jmp 0x2d45d
leaq -0x30(%rbp), %rdi
callq 0x1b940
jmp 0x2d3a2
movq -0x18(%rbp), %rdi
callq 0x32790
movb $0x1, %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ccf0
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x72f0
movq -0x80(%rbp), %rdi
movl -0x74(%rbp), %esi
movl -0x70(%rbp), %edx
movl -0x6c(%rbp), %ecx
movq -0x68(%rbp), %r8
xorl %r9d, %r9d
callq 0x2dd50
jmp 0x2d911
leaq -0x38(%rbp), %rdi
callq 0x7910
movq -0x80(%rbp), %rdi
leaq 0x640eb(%rip), %rax     # 0x91a10
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0xd0(%rdi)
addq $0x8, %rdi
leaq 0x370be(%rip), %rsi     # 0x649fc
callq 0x7a10
jmp 0x2d945
movq -0x18(%rbp), %rdi
callq 0x1c780
movq %rax, -0x88(%rbp)
jmp 0x2d957
movq -0x88(%rbp), %rdi
callq 0x8c90
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c780
movq %rax, -0x90(%rbp)
jmp 0x2d979
movq -0x90(%rbp), %rdi
callq 0x8cc0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8cf0
testb $0x1, %al
jne 0x2d99f
jmp 0x2da5a
movq -0x18(%rbp), %rdi
callq 0x1c780
movq %rax, -0x98(%rbp)
jmp 0x2d9b1
movq -0x98(%rbp), %rdi
callq 0x8c90
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8cf0
testb $0x1, %al
jne 0x2d9d4
jmp 0x2da1a
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
leaq 0x37015(%rip), %rsi     # 0x649f8
callq 0x71b0
jmp 0x2d9ea
jmp 0x2da1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7910
jmp 0x2da63
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2e030
jmp 0x2da63
leaq -0x50(%rbp), %rdi
callq 0x8d30
movq (%rax), %rdi
callq 0x1cc20
movq %rax, -0xa0(%rbp)
jmp 0x2da34
movq -0xa0(%rbp), %rsi
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
callq 0x78a0
jmp 0x2da4a
jmp 0x2da4c
leaq -0x50(%rbp), %rdi
callq 0x8d70
jmp 0x2d967
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x79d0
nopl (%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictAddExclusion
PICT_RET_CODE
API_SPEC
PictAddExclusion
    (
    IN const PICT_HANDLE         task,
    IN const PICT_EXCLUSION_ITEM exclusionItems[],
    IN       size_t              exclusionItemCount
    )
{
    Task* taskObj = static_cast<Task*>( NO_CONST_HANDLE( task ));
    
    try
    {
        Exclusion exclusion;
        for( size_t index = 0; index < exclusionItemCount; ++index )
        {
            exclusion.insert( make_pair( 
                static_cast<Parameter*> ( NO_CONST_HANDLE( exclusionItems[ index ].Parameter  )),
                static_cast<int>        (                  exclusionItems[ index ].ValueIndex ))
                );
        }
        bool ret = taskObj->AddExclusion( exclusion );
        return( ret ? PICT_SUCCESS : PICT_OUT_OF_MEMORY );
    }
    catch( ... )
    {
        return( PICT_OUT_OF_MEMORY );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xb6c0
jmp 0x2f23a
movq $0x0, -0x90(%rbp)
movq -0x90(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2f36f
movq -0x18(%rbp), %rax
movq -0x90(%rbp), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq -0x90(%rbp), %rcx
shlq $0x4, %rcx
movl 0x8(%rax,%rcx), %eax
movl %eax, -0xac(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xac(%rbp), %rsi
callq 0x2fdc0
movl %edx, -0xe4(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x2f2ab
movl -0xe4(%rbp), %eax
movq -0xe0(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
movl %eax, -0xb8(%rbp)
movl -0xb8(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xd9b0
movb %dl, -0xf1(%rbp)
movq %rax, -0xf0(%rbp)
jmp 0x2f2fe
movb -0xf1(%rbp), %al
movq -0xf0(%rbp), %rcx
movq %rcx, -0xd0(%rbp)
movb %al, -0xc8(%rbp)
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0x2f245
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2f358
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xbc70
movq -0x80(%rbp), %rdi
callq 0x7220
movl $0xc0000001, -0x4(%rbp) # imm = 0xC0000001
callq 0x7900
jmp 0x2f3b1
movq -0x28(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2fdf0
movb %al, -0xf2(%rbp)
jmp 0x2f384
movb -0xf2(%rbp), %al
andb $0x1, %al
movb %al, -0xd1(%rbp)
movb -0xd1(%rbp), %dl
movl $0xc0000001, %eax       # imm = 0xC0000001
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xbc70
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictAddSeed
PICT_RET_CODE
API_SPEC
PictAddSeed
    (
    IN const PICT_HANDLE     task,
    IN const PICT_SEED_ITEM  seedItems[],
    IN       size_t          seedItemCount
    )
{
    Task* taskObj = static_cast<Task*>( NO_CONST_HANDLE( task ));
    
    try
    {
        RowSeed seed;
        for( size_t index = 0; index < seedItemCount; ++index )
        {
            seed.insert( make_pair( 
                static_cast<Parameter*> ( NO_CONST_HANDLE( seedItems[ index ].Parameter  )),
                static_cast<int>        (                  seedItems[ index ].ValueIndex ))
                );
        }
        taskObj->AddRowSeed( seed );
        return( PICT_SUCCESS );
    }
    catch( ... )
    {
        return( PICT_OUT_OF_MEMORY );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1cf70
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2f4eb
movq -0x18(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq -0x60(%rbp), %rcx
shlq $0x4, %rcx
movl 0x8(%rax,%rcx), %eax
movl %eax, -0x7c(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x7c(%rbp), %rsi
callq 0x2fdc0
movl %edx, -0xbc(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x2f441
movl -0xbc(%rbp), %eax
movq -0xb8(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movl %eax, -0x98(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1cf90
movb %dl, -0xc9(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0x2f48b
movb -0xc9(%rbp), %al
movq -0xc8(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movb %al, -0xa8(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x2f3f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1d020
movq -0x88(%rbp), %rdi
callq 0x7220
movl $0xc0000001, -0x4(%rbp) # imm = 0xC0000001
callq 0x7900
jmp 0x2f50a
movq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2fe40
jmp 0x2f4fa
movl $0x0, -0x4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1d020
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictGenerate
PICT_RET_CODE
API_SPEC
PictGenerate
    (
    IN const PICT_HANDLE task
    )
{
    Task* taskObj = static_cast<Task*>( NO_CONST_HANDLE( task ));
    try
    {
        taskObj->PrepareForGeneration();
    }
    catch( ... )
    {
        return( PICT_GENERATION_ERROR );
    }
    
    Model* root = taskObj->GetRootModel();
    try
    {
        generate( root );
    }
    catch( GenerationError e )
    {
        switch( e.GetErrorType() )
        {
        case OutOfMemory:
            return( PICT_OUT_OF_MEMORY );
        case GenerationCancelled:
        case TooManyRows:        
        case Unknown:
        case GenerationFailure:
        default:
            return( PICT_GENERATION_ERROR );
        }
    }
    return( PICT_SUCCESS );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31ea0
jmp 0x2f542
jmp 0x2f56a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7220
movl $0xc0000002, -0x4(%rbp) # imm = 0xC0000002
callq 0x7900
jmp 0x2f648
movq -0x18(%rbp), %rdi
callq 0x1bf30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2f670
jmp 0x2f582
jmp 0x2f641
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x2f654
movq -0x20(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7740
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x2fe70
jmp 0x2f5be
movq -0x70(%rbp), %rdi
callq 0x7220
leaq -0x60(%rbp), %rdi
callq 0x2fec0
movl %eax, -0x74(%rbp)
jmp 0x2f5d5
movl -0x74(%rbp), %eax
subl $0x3, %eax
jb 0x2f61f
jmp 0x2f5df
movl -0x74(%rbp), %eax
subl $0x3, %eax
je 0x2f60f
jmp 0x2f5e9
movl -0x74(%rbp), %eax
subl $0x4, %eax
je 0x2f61f
jmp 0x2f621
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xd7f0
callq 0x7900
jmp 0x2f63f
movl $0xc0000001, -0x4(%rbp) # imm = 0xC0000001
movl $0x1, -0x64(%rbp)
jmp 0x2f62f
jmp 0x2f621
movl $0xc0000002, -0x4(%rbp) # imm = 0xC0000002
movl $0x1, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xd7f0
callq 0x7900
jmp 0x2f648
jmp 0x2f654
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x79d0
movq %rax, %rdi
callq 0x9570
nopw %cs:(%rax,%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictAllocateResultBuffer
PICT_RESULT_ROW
API_SPEC
PictAllocateResultBuffer
    (
    IN const PICT_HANDLE task
    )
{
    Task* taskObj = static_cast<Task*>( NO_CONST_HANDLE( task ));
    size_t totalParamCount = taskObj->GetTotalParameterCount();
    
    PICT_RESULT_ROW row = static_cast<PICT_RESULT_ROW>( malloc( totalParamCount * sizeof( PICT_VALUE ) ) );

    return( row );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fed0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x77b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictGetNextResultRow
size_t
API_SPEC
PictGetNextResultRow
    (
    IN  const PICT_HANDLE     task,
    OUT       PICT_RESULT_ROW resultRow
    )
{
    Task* taskObj = static_cast<Task*>( NO_CONST_HANDLE( task ));
    
    ResultCollection::iterator i_row = taskObj->GetNextResultRow();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x323a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2fef0
movq %rax, %rdi
callq 0x1c1f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c1b0
testb $0x1, %al
jne 0x2f7cd
jmp 0x2f82e
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1c220
movq %rax, %rdi
callq 0x26830
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f82c
leaq -0x20(%rbp), %rdi
callq 0x2ff10
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x1c6e0
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2f7d5
jmp 0x2f82e
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2fef0
movq %rax, %rdi
callq 0x1c1f0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2ff30
addq $0x50, %rsp
popq %rbp
retq
nop
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictCreateModel
PICT_HANDLE
API_SPEC
PictCreateModel
    (
    IN OPT unsigned int randomSeed
    )
{
    Model* modelObj = new Model( L"",
                                 MixedOrder, 
                                 0,
                                 randomSeed );
    
    return( static_cast<PICT_HANDLE>( modelObj ));   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl $0x150, %edi            # imm = 0x150
callq 0x75e0
movq %rax, -0x58(%rbp)
movb $0x1, -0x45(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x72c0
movq -0x50(%rbp), %rdx
leaq 0x35127(%rip), %rsi     # 0x649fc
leaq -0x30(%rbp), %rdi
callq 0x2ff70
jmp 0x2f8e0
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, %r8d
leaq -0x30(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x30020
jmp 0x2f8f9
movb $0x0, -0x45(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7910
leaq -0x31(%rbp), %rdi
callq 0x79f0
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2f944
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7910
leaq -0x31(%rbp), %rdi
callq 0x79f0
testb $0x1, -0x45(%rbp)
jne 0x2f955
jmp 0x2f963
movq -0x58(%rbp), %rdi
movl $0x150, %esi            # imm = 0x150
callq 0x7600
jmp 0x2f965
movq -0x40(%rbp), %rdi
callq 0x79d0
nop
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictAttachChildModel
PICT_RET_CODE
API_SPEC
PictAttachChildModel
    (
    IN const PICT_HANDLE modelParent,
    IN const PICT_HANDLE modelChild,
    IN OPT unsigned int  order
    )
{
    Model* parent = static_cast<Model*>( NO_CONST_HANDLE( modelParent ));
    Model* child  = static_cast<Model*>( NO_CONST_HANDLE( modelChild  ));
    try
    {
        child->SetOrder( order );
        if ( parent->GetOrder() < static_cast<int>( order ))
        {
            parent->SetOrder( order );
        }
        
        parent->AddSubmodel( child );
        return( PICT_SUCCESS );
    }
    catch( ... )
    {
        return( PICT_OUT_OF_MEMORY );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x30380
jmp 0x2fc71
movq -0x28(%rbp), %rdi
callq 0x303a0
movl %eax, -0x40(%rbp)
jmp 0x2fc7f
movl -0x40(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2fcba
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x30380
jmp 0x2fc95
jmp 0x2fcba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x7220
movl $0xc0000001, -0x4(%rbp) # imm = 0xC0000001
callq 0x7900
jmp 0x2fcd0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x303c0
jmp 0x2fcc9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/pictapi.cpp
// Function: PictDeleteModel
void
API_SPEC
PictDeleteModel
    (
    IN const PICT_HANDLE model
    )
{
    Model* modelObj = static_cast<Model*>( NO_CONST_HANDLE( model ));

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8c90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8cc0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8cf0
testb $0x1, %al
jne 0x2fd2e
jmp 0x2fd63
leaq -0x20(%rbp), %rdi
callq 0x8d30
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2fd56
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x2fd58
leaq -0x20(%rbp), %rdi
callq 0x8d70
jmp 0x2fd1b
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x2fd88
movq -0x40(%rbp), %rdi
callq 0x1b540
movq -0x40(%rbp), %rdi
movl $0x150, %esi            # imm = 0x150
callq 0x7600
addq $0x40, %rsp
popq %rbp
retq
nop
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::Task()
Task::Task() :
      m_rootModel     (NULL),
      m_abortCallback (NULL),
      m_generationMode(Regular),
      m_maxRandomTries(DefaultMaxRandomTries),
      m_workbuf       (NULL)
{
    Combination::ResetId();

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq $0x0, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x1d040
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x28(%rbp)
callq 0x1d570
movq -0x20(%rbp), %rdi
movq $0x0, 0x50(%rdi)
movl $0x0, 0x58(%rdi)
movq $0x3e8, 0x60(%rdi)      # imm = 0x3E8
movq $0x0, 0x68(%rdi)
addq $0x70, %rdi
callq 0x32520
callq 0x32540
jmp 0x31d6c
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x1d800
movq -0x30(%rbp), %rdi
callq 0x1d120
movq -0x10(%rbp), %rdi
callq 0x79d0
nopl (%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::PrepareForGeneration()
void Task::PrepareForGeneration()
{
    // new models could have been added to the root
    // repropagate the task pointer to all models
    m_rootModel->WireTask(this);

    // run the deriver on exclusions
    deriveExclusions();

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movq (%rsi), %rdi
callq 0x30410
movq -0x48(%rbp), %rdi
callq 0x31fa0
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaf20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xab70
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xaf50
testb $0x1, %al
jne 0x31efe
jmp 0x31f60
leaq -0x18(%rbp), %rdi
callq 0xafa0
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq (%rdi), %rdx
callq 0x32220
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
je 0x31f29
jmp 0x31f48
leaq 0x32b2b(%rip), %rdi     # 0x64a5b
leaq 0x32b32(%rip), %rsi     # 0x64a69
movl $0x53, %edx
leaq 0x32b3e(%rip), %rcx     # 0x64a81
callq 0x7450
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x32560
leaq -0x18(%rbp), %rdi
callq 0xb000
jmp 0x31eeb
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x50(%rbp)
addq $0x38, %rdi
callq 0x1d590
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x38, %rdi
callq 0x1d5f0
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x325b0
addq $0x50, %rsp
popq %rbp
retq
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::deriveExclusions()
void Task::deriveExclusions()
{
    ExclusionDeriver deriver(this);
    ParamCollection params;
    m_rootModel->GetAllParameters(params);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x160(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x1d140
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x9240
movq -0x160(%rbp), %rax
movq -0x158(%rbp), %rsi
movq (%rax), %rdi
callq 0x1d200
jmp 0x31ff1
leaq -0xe0(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rdi
callq 0x8c90
movq %rax, -0x100(%rbp)
movq -0xf8(%rbp), %rdi
callq 0x8cc0
movq %rax, -0x108(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x8cf0
testb $0x1, %al
jne 0x3203e
jmp 0x320a8
leaq -0x100(%rbp), %rdi
callq 0x8d30
movq (%rax), %rax
movq %rax, -0x110(%rbp)
movq -0x110(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x1d2c0
jmp 0x32069
jmp 0x3206b
leaq -0x100(%rbp), %rdi
callq 0x8d70
jmp 0x32025
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x9260
leaq -0xc8(%rbp), %rdi
callq 0x1d340
jmp 0x3220d
movq -0x160(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
callq 0xaf20
movq %rax, -0x120(%rbp)
movq -0x118(%rbp), %rdi
callq 0xab70
movq %rax, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0xaf50
testb $0x1, %al
jne 0x320f9
jmp 0x3215b
leaq -0x120(%rbp), %rdi
callq 0xafa0
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
movl $0x1, %edx
callq 0x9ef0
movb %dl, -0x169(%rbp)
movq %rax, -0x168(%rbp)
jmp 0x32133
movb -0x169(%rbp), %al
movq -0x168(%rbp), %rcx
movq %rcx, -0x140(%rbp)
movb %al, -0x138(%rbp)
leaq -0x120(%rbp), %rdi
callq 0xb000
jmp 0x320e0
leaq -0xc8(%rbp), %rdi
callq 0xa300
jmp 0x32169
movq -0x160(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x180(%rbp)
callq 0x1d300
leaq -0xc8(%rbp), %rdi
callq 0x1d320
movq %rax, -0x178(%rbp)
jmp 0x32195
movq -0x178(%rbp), %rdi
callq 0xaf20
movq %rax, -0x148(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x1d320
movq %rax, -0x188(%rbp)
jmp 0x321bd
movq -0x188(%rbp), %rdi
callq 0xab70
movq -0x180(%rbp), %rdi
movq %rax, -0x150(%rbp)
movq -0x148(%rbp), %rsi
movq -0x150(%rbp), %rdx
callq 0x1d0c0
jmp 0x321ec
leaq -0xe0(%rbp), %rdi
callq 0x9260
leaq -0xc8(%rbp), %rdi
callq 0x1d340
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq -0xe8(%rbp), %rdi
callq 0x79d0
nopl (%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::findMatchingNode(pictcore::Exclusion&, pictcore::Model*)
Model* Task::findMatchingNode( Exclusion& exclusion, Model* root )
{
    // can any of the subnodes accommodate the exclusion?
    for( auto & submodel : root->GetSubmodels() )
    {
        Model* foundNode = findMatchingNode( exclusion, submodel );
        if ( NULL != foundNode ) return( foundNode );
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
callq 0x303f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1ca90
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1caf0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1cac0
testb $0x1, %al
jne 0x32279
jmp 0x322c0
leaq -0x30(%rbp), %rdi
callq 0x1cb20
movq -0x78(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rax
movq (%rax), %rdx
callq 0x32220
movq %rax, -0x48(%rbp)
xorl %eax, %eax
cmpq -0x48(%rbp), %rax
je 0x322b3
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3234c
jmp 0x322b5
leaq -0x30(%rbp), %rdi
callq 0x1cc90
jmp 0x32266
movb $0x1, -0x49(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x9090
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x90c0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9130
testb $0x1, %al
jne 0x322f9
jmp 0x32334
leaq -0x60(%rbp), %rdi
callq 0x9910
movq -0x78(%rbp), %rdi
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x32410
andb $0x1, %al
movb %al, -0x49(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x32327
jmp 0x32334
jmp 0x32329
leaq -0x60(%rbp), %rdi
callq 0x9210
jmp 0x322e6
testb $0x1, -0x49(%rbp)
je 0x32344
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3234c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::GetNextResultRow()
ResultCollection::iterator Task::GetNextResultRow()
{
    ResultCollection::iterator ret = m_currentResultRow;
    if( m_currentResultRow != GetResults().end() )
    {
        ++m_currentResultRow;
    }
    return( ret );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq 0x70(%rdi), %rax
movq %rax, -0x8(%rbp)
movq %rdi, %rax
addq $0x70, %rax
movq %rax, -0x20(%rbp)
callq 0x2fef0
movq %rax, %rdi
callq 0x1c1f0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x1c1b0
testb $0x1, %al
jne 0x323eb
jmp 0x323f8
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
callq 0x1c3d0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/task.cpp
// Function: pictcore::Task::findParamInSubtree(pictcore::Parameter*, pictcore::Model*)
bool Task::findParamInSubtree( Parameter* parameter, Model* root )
{
    // check if exists in current node collection
    for( auto p : root->GetParameters() )
    {
        if ( p == parameter ) return( true );
    }

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

    return( false );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c780
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 0x32466
jmp 0x32496
leaq -0x30(%rbp), %rdi
callq 0x8d30
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x32489
movb $0x1, -0x1(%rbp)
jmp 0x32513
jmp 0x3248b
leaq -0x30(%rbp), %rdi
callq 0x8d70
jmp 0x32453
movq -0x20(%rbp), %rdi
callq 0x303f0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1ca90
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1caf0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1cac0
testb $0x1, %al
jne 0x324d0
jmp 0x3250f
leaq -0x50(%rbp), %rdi
callq 0x1cb20
movq -0x70(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rsi
movq -0x60(%rbp), %rax
movq (%rax), %rdx
callq 0x32410
andb $0x1, %al
movb %al, -0x61(%rbp)
testb $0x1, -0x61(%rbp)
je 0x32502
movb $0x1, -0x1(%rbp)
jmp 0x32513
jmp 0x32504
leaq -0x50(%rbp), %rdi
callq 0x1cc90
jmp 0x324bd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/worklist.cpp
// Function: pictcore::WorkList::AddItem(pictcore::Parameter*)
void WorkList::AddItem( Parameter* param )
{
    if( !param->IsPending() )
    {
        assert( !param->GetBoundCount() );
        m_rep.push_back( param );
        param->MarkPending();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32800
testb $0x1, %al
jne 0x3270d
movq -0x10(%rbp), %rdi
callq 0x8e90
xorb $-0x1, %al
testb $0x1, %al
jne 0x326d6
jmp 0x326d8
jmp 0x326f7
leaq 0x32072(%rip), %rdi     # 0x64751
leaq 0x323c7(%rip), %rsi     # 0x64aad
movl $0xe, %edx
leaq 0x323d7(%rip), %rcx     # 0x64ac9
callq 0x7450
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xdbc0
movq -0x10(%rbp), %rdi
callq 0x8d50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/api/worklist.cpp
// Function: pictcore::WorkList::GetItem()
Parameter *WorkList::GetItem()
{
    Parameter *param = m_rep.front();
    assert( !param->GetBoundCount() );
    m_rep.pop_front();
    return param;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x32820
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8e90
xorb $-0x1, %al
testb $0x1, %al
jne 0x32751
jmp 0x32753
jmp 0x32772
leaq 0x31ff7(%rip), %rdi     # 0x64751
leaq 0x3234c(%rip), %rsi     # 0x64aad
movl $0x1a, %edx
leaq 0x3238a(%rip), %rcx     # 0x64af7
callq 0x7450
movq -0x18(%rbp), %rdi
callq 0xb3e0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/utils/utils.cpp
// Function: position_in_vector(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int position_in_vector(vector<string> vect, string target)
{
    for(int i=0; i<vect.size(); i++)
    {
        if(vect[i].compare(target) == 0)
        {
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x32c20
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x32aaf
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x32c40
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x7060
cmpl $0x0, %eax
jne 0x32aa2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32ab6
jmp 0x32aa4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x32a5f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: WShabti-Team[P]WShabtiPict/wshabtilib/input-parser/input-parser.cpp
// Function: input_parser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>&, std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>&)
void input_parser(string input_file_path, vector<vector<string>> &parameter_matrix, vector<vector<string>> &constraint_matrix)
{
	
	std::ifstream input_file;
  	input_file.open(input_file_path, std::ios_base::in);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x238(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0x76d0
movq -0x240(%rbp), %rdi
movq -0x238(%rbp), %rsi
movl $0x8, %edx
callq 0x7520
jmp 0x33a5b
movq -0x10(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x33ad0
jmp 0x33a6d
movq -0x18(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x34230
jmp 0x33a7f
leaq -0x220(%rbp), %rdi
callq 0x7110
jmp 0x33a8d
leaq -0x220(%rbp), %rdi
callq 0x7140
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x7140
movq -0x228(%rbp), %rdi
callq 0x79d0
nopl (%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/java-source-code-parser/java-source-code-parser.cpp
// Function: get_method_and_values_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> get_method_and_values_name(string method_prototype)
{
    smatch sm;
    vector<string> method_values_name;
    regex method_and_value_name_regex (R"rgx(\b\w+(?=\s*[,()]))rgx");

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x364e0
movq -0xb0(%rbp), %rdi
movb $0x0, -0x31(%rbp)
callq 0x32b00
leaq 0x2eb1a(%rip), %rsi     # 0x64e05
leaq -0x58(%rbp), %rdi
movl $0x10, %edx
callq 0x36520
jmp 0x362fb
jmp 0x362fd
movq -0xc0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x58(%rbp), %rdx
xorl %ecx, %ecx
callq 0x365c0
movb %al, -0xc1(%rbp)
jmp 0x3631b
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x3632a
jmp 0x363f7
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x36620
movq %rax, -0xd0(%rbp)
jmp 0x36340
movq -0xd0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x36690
jmp 0x36355
movq -0xb0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x32b90
jmp 0x3636a
leaq -0x88(%rbp), %rdi
callq 0x73e0
leaq -0x30(%rbp), %rdi
callq 0x36710
movq %rax, -0xd8(%rbp)
jmp 0x36388
movq -0xd8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x36690
jmp 0x3639d
movq -0xc0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x7720
leaq -0xa8(%rbp), %rdi
callq 0x73e0
jmp 0x362fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x3643c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x3640c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x73e0
jmp 0x3640c
movb $0x1, -0x31(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x366c0
testb $0x1, -0x31(%rbp)
jne 0x36423
jmp 0x36417
leaq -0x58(%rbp), %rdi
callq 0x366c0
jmp 0x3643c
movq -0xb0(%rbp), %rdi
callq 0x32bc0
leaq -0x30(%rbp), %rdi
callq 0x366f0
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x32bc0
leaq -0x30(%rbp), %rdi
callq 0x366f0
movq -0x60(%rbp), %rdi
callq 0x79d0
nopw (%rax,%rax)
// File: WShabti-Team[P]WShabtiPict/wshabtilib/junit-test-case-generator/junit-test-case-generator.cpp
// Function: add_oracle_to_arguments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
string add_oracle_to_arguments(string prototype, bool interval_found)
{
    string arguments_with_oracle = "";
    if(interval_found)
    {
        arguments_with_oracle = (prototype.replace(prototype.find(")"),prototype.find(")"), ", double oracle, double delta)")); 

    }
    else
    {
        arguments_with_oracle = (prototype.replace(prototype.find(")"),prototype.find(")"), ", Object oracle)")); 
    }
    return arguments_with_oracle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x38(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
leaq -0x13(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x79e0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x86f9(%rip), %rsi      # 0x65c32
callq 0xd700
jmp 0x5d540
leaq -0x13(%rbp), %rdi
callq 0x7660
testb $0x1, -0x11(%rbp)
je 0x5d5e9
movq -0x48(%rbp), %rdi
leaq 0x7047(%rip), %rsi      # 0x645a5
movq %rsi, -0x68(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x60(%rbp)
callq 0x7aa0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x7aa0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq 0x860a(%rip), %rcx      # 0x65ba0
callq 0x73a0
movq %rax, -0x50(%rbp)
jmp 0x5d5a1
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x7070
jmp 0x5d5b0
jmp 0x5d64e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x13(%rbp), %rdi
callq 0x7660
jmp 0x5d66e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x73e0
jmp 0x5d66e
movq -0x48(%rbp), %rdi
leaq 0x6fb1(%rip), %rsi      # 0x645a5
movq %rsi, -0x88(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x80(%rbp)
callq 0x7aa0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x7aa0
movq -0x48(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, %rdx
leaq 0x858d(%rip), %rcx      # 0x65bbf
callq 0x73a0
movq %rax, -0x70(%rbp)
jmp 0x5d63d
movq -0x70(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x7070
jmp 0x5d64c
jmp 0x5d64e
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x5d661
movq -0x38(%rbp), %rdi
callq 0x73e0
movq -0x40(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x79d0
nopw (%rax,%rax)