LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::_DebugRouteFromLeftToRight(NumObj*)
Action Node::_DebugRouteFromLeftToRight(NumObj *numo)
{
    std::cout << num << "<-_DebugRouteFromLeftToRight() debugid?" << numo->num << " real?" << isReal << "\n";
    if (right != NULL) {
        right->out->call(Node::_DebugRouteFromLeftToRight, numo);
    } else {
        std::cout << "END DEBUG\n";
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movsd 0xb0(%rdi), %xmm0
movq 0x72ba(%rip), %rdi      # 0xffd0
callq 0x2240
leaq 0x1810(%rip), %rsi      # 0xa532
movq %rax, %rdi
callq 0x2160
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x2280
leaq 0x1846(%rip), %rsi      # 0xa583
movq %rax, %rdi
callq 0x2160
movzbl 0xb8(%rbx), %esi
movq %rax, %rdi
callq 0x2270
leaq 0x1714(%rip), %rsi      # 0xa46f
movq %rax, %rdi
callq 0x2160
movq 0xd0(%rbx), %rax
testq %rax, %rax
je 0x8dc5
movq 0x28(%rax), %r15
pushq $0x38
popq %rdi
callq 0x2170
leaq 0x7436(%rip), %rcx      # 0x101b8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
leaq -0xa0(%rip), %rcx       # 0x8cfc
movq %rcx, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %r14, 0x28(%rax)
andq $0x0, 0x30(%rax)
movq (%r15), %rcx
movq 0x8(%rcx), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
movq 0x7204(%rip), %rdi      # 0xffd0
leaq 0x1787(%rip), %rsi      # 0xa55a
popq %rbx
popq %r14
popq %r15
jmp 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::_DebugRouteFromRightToLeft()
Action Node::_DebugRouteFromRightToLeft()
{
    std::cout << num << "<-_DebugRouteFromRightToLeft() real?" << isReal << "\n";
    if (left != NULL) {
        left->out->call(Node::_DebugRouteFromRightToLeft, NONE);
    } else {
        std::cout << "END DEBUG\n";
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movsd 0xb0(%rdi), %xmm0
movq 0x71db(%rip), %rdi      # 0xffd0
callq 0x2240
leaq 0x1764(%rip), %rsi      # 0xa565
movq %rax, %rdi
callq 0x2160
movzbl 0xb8(%rbx), %esi
movq %rax, %rdi
callq 0x2270
leaq 0x1650(%rip), %rsi      # 0xa46f
movq %rax, %rdi
callq 0x2160
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x8e71
movq 0x28(%rax), %r15
pushq $0x38
popq %rdi
callq 0x2170
movq %rax, %r14
leaq -0x6b(%rip), %rsi       # 0x8dde
leaq 0x7370(%rip), %rcx      # 0x101c0
movq %rax, %rdi
xorl %edx, %edx
callq 0x3890
movq (%r15), %rax
movq 0x8(%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq 0x7158(%rip), %rdi      # 0xffd0
leaq 0x16db(%rip), %rsi      # 0xa55a
popq %rbx
popq %r14
popq %r15
jmp 0x2160
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Relay::Relay()
Relay::Relay()
{
    _home = _activeSubject;
    _setup();
    if (_home != NULL) {
        if (DEBUG) {
            std::cout << "-- Creating relay point " << ID << " by subject " << _home->_debugID << ".\n";
        }
        if (_home->_sink != NULL) {
            _oLink = _home->_sink;     // Relay has link to own subject
            _oLink->_iLinks->add(this);
        }
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x69e1(%rip), %rax      # 0xfc68
movq %rax, (%rdi)
leaq 0x6f1f(%rip), %rax      # 0x101b0
movq (%rax), %rax
movq %rax, 0x18(%rdi)
callq 0x409c
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x92c0
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x92c0
movq %rax, 0x28(%rbx)
movq 0x20(%rax), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x403c
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Identity::Identity(Relay*)
Identity::Identity(Relay *r)
{
    _idLinks *idl;

    _source = NULL;
    _sink = NULL;
    _base = NULL;
    if (_activeSubject == NULL) {
        if (WARNING) {
            std::cout << "-- Warning! Identity not created within active subject.\n";
        }
    } else {
        if (r == NULL) {
            if (WARNING) {
                std::cout << "-- Warning! Cannot create identity of NULL.\n";
            }
        } else {
            if (r->_home != _activeSubject) {
                if (WARNING) {
                    std::cout << "Warning! Subject " << _activeSubject->_debugID << " cannot create identity for relay " << r->ID << ".\n";
                }
            } else {
                if (DEBUG) {
                    std::cout << "-- Creating public identity of " << r->ID << ".\n";
                }
                _source = r;               // set source and base
                _base = r->_base;
                idl = new _idLinks(this);  // add identity at beginning of list
                if (r->_identities->next != NULL) {
                    r->_identities->next->prev = idl;
                }
                idl->next = r->_identities->next;
                idl->prev = r->_identities;
                r->_identities->next = idl;
            }
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3a32
xorps %xmm0, %xmm0
andq $0x0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
leaq 0x6ecb(%rip), %rax      # 0x101b0
movq (%rax), %rax
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x9331
cmpq %rax, 0x18(%rbx)
jne 0x9331
movq %rbx, 0x10(%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x20(%r14)
pushq $0x18
popq %rdi
callq 0x2170
movq %r14, 0x10(%rax)
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x9326
movq %rax, (%rdx)
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::_extract(Subject*, Relay*&)
Identity *Subject::_extract(Subject *s, Relay* &r)
{
    Identity *id;
    _idLinks *idl;

    id = NULL;
    if (_activeSubject == NULL || (_parent == NULL && _debugID > 0)) {
        if (WARNING) {
            std::cout << "-- Warning! " << _debugID << "called 'delete' outside of the subjects environment.\n";
        }
    } else {
        if (r == NULL) {
            if (WARNING) {
                std::cout << "-- Warning! " << _debugID << " cannot destruct NULL.\n";
            }
        } else {
            if (s != this) {
                if (WARNING) {
                    std::cout << "-- Warning! " << s->_debugID << " cannot call 'delete' for subject " << _debugID << ".\n";
                }
            } else {
                if (s != r->_home) {
                    if (WARNING) {
                        std::cout << "-- Warning! " << _debugID << " cannot call 'delete' for relay " << r->ID << ".\n";
                    }
                } else {
                    id = new Identity;
                    id->_source = r->_oLink;
                    if (r->_private) {
                        id->_sink = _sink;
                    } else {
                        id->_sink = NULL;
                    }
                    id->_base = r->_base;
                    if (id->_source != NULL) {
                        idl = new _idLinks(id);  // add identity at beginning of list
                        if (id->_source->_identities->next != NULL) {
                            id->_source->_identities->next->prev = idl;
                        }
                        idl->next = id->_source->_identities->next;
                        idl->prev = id->_source->_identities;
                        id->_source->_identities->next = idl;
                    }
                    r->_destruct();  // delete relay r
                    r = NULL;
                }
            }
        }
    }
    return id;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x6e67(%rip), %rax      # 0x101b0
cmpq $0x0, (%rax)
je 0x937c
movq %rdx, %rbx
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
jne 0x9363
cmpq $0x0, 0x8(%r15)
jne 0x937c
movq (%rbx), %rax
testq %rax, %rax
sete %cl
cmpq %r15, %rsi
setne %dl
orb %cl, %dl
jne 0x937c
cmpq %r15, 0x18(%rax)
je 0x938e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x28
popq %rdi
callq 0x2170
movq %rax, %r14
movq %rax, %rdi
callq 0x961e
movq (%rbx), %rdi
movq 0x28(%rdi), %r12
movq %r12, 0x10(%r14)
cmpl $0x0, 0x14(%rdi)
je 0x93b8
movq 0x20(%r15), %rax
jmp 0x93ba
xorl %eax, %eax
movq %rax, 0x18(%r14)
movq 0x30(%rdi), %rax
movq %rax, 0x20(%r14)
testq %r12, %r12
je 0x93f6
pushq $0x18
popq %rdi
callq 0x2170
movq %r14, 0x10(%rax)
movq 0x40(%r12), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x93e8
movq %rax, (%rdx)
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
andq $0x0, (%rbx)
jmp 0x937f
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/main.cpp
// Function: main
int main(int argc, char *argv[])
{
	if( argc!=3 ) {
		cerr<<"Wrong number of arguments. Please execute as follow : \n"
			<<"./hw1.o <input_file name> <output_file name>"<< endl;
		exit(-1);
	}

	ifstream fin( argv[1] );
	ofstream fout( argv[2] );			

	cout<<"\n***** Quine-McCluskey Algorithm *****"<< endl;
	Quine_McCluskey QM;
	Init( fin , QM );
	QM.Solve();
	QM.Print_Prime_Impli();

	cout<<"\n***** Petrick's Method *****"<< endl;
	Petrick_Method PM( QM.Get_Prime_Impli() , QM.Get_On_Set() );
	PM.Solve();
	PM.Print_POS();
//	PM.Print_SOP();

	cout<<"\n***** All possible fewest-terms results *****"<< endl;
	PM.Print_FewestTerm_P();
	
	cout<<"\n***** Final Answer *****"<< endl;
	Output( fout , QM , PM );
	
	fin.close();
	fout.close();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x548, %rsp            # imm = 0x548
cmpl $0x3, %edi
jne 0x262c
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq -0x550(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x22c0
movq 0x10(%rbx), %rsi
leaq -0x348(%rbp), %rdi
pushq $0x10
popq %rdx
callq 0x21c0
movq 0xab1f(%rip), %rdi      # 0xcfd0
leaq 0x5bb1(%rip), %rsi      # 0x8069
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq -0xa0(%rbp), %rdi
callq 0x2a6a
leaq -0x550(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x26ac
leaq -0x20(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2b1c
leaq -0x20(%rbp), %rdi
callq 0x28bc
leaq -0xa0(%rbp), %rdi
callq 0x310a
movq 0xaac0(%rip), %rdi      # 0xcfd0
leaq 0x5b79(%rip), %rsi      # 0x8090
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq -0xa0(%rbp), %rdi
callq 0x2f82
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x2f78
leaq -0x118(%rbp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x513e
leaq -0x148(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x534c
leaq -0x148(%rbp), %rdi
callq 0x28e8
leaq -0x118(%rbp), %rdi
callq 0x56dc
movq 0xaa4d(%rip), %rdi      # 0xcfd0
leaq 0x5b24(%rip), %rsi      # 0x80ae
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq -0x118(%rbp), %rdi
callq 0x58d2
movq 0xaa26(%rip), %rdi      # 0xcfd0
leaq 0x5b2c(%rip), %rsi      # 0x80dd
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq -0x348(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x118(%rbp), %rdx
callq 0x286d
leaq -0x550(%rbp), %rdi
callq 0x2060
leaq -0x348(%rbp), %rdi
callq 0x2240
leaq -0x118(%rbp), %rdi
callq 0x531a
leaq -0xa0(%rbp), %rdi
callq 0x2a94
leaq -0x348(%rbp), %rdi
callq 0x2260
leaq -0x550(%rbp), %rdi
callq 0x2070
xorl %eax, %eax
addq $0x548, %rsp            # imm = 0x548
popq %rbx
popq %rbp
retq
movq 0xa9bd(%rip), %rdi      # 0xcff0
leaq 0x59ca(%rip), %rsi      # 0x8004
callq 0x2180
leaq 0x59f6(%rip), %rsi      # 0x803c
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
pushq $-0x1
popq %rdi
callq 0x21e0
jmp 0x2665
movq %rax, %rbx
jmp 0x2698
movq %rax, %rbx
jmp 0x268c
jmp 0x266c
movq %rax, %rbx
jmp 0x2680
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x531a
leaq -0xa0(%rbp), %rdi
callq 0x2a94
leaq -0x348(%rbp), %rdi
callq 0x2260
leaq -0x550(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/main.cpp
// Function: Init(std::basic_ifstream<char, std::char_traits<char>>&, Quine_McCluskey&)
void Init(ifstream &fin, Quine_McCluskey &QM) {
	// input from a file
	char c;
	while( fin>> c ) {
		if( c=='.' )	
			continue;
		if( c=='i' ) {
			int n;
			fin>> n ;
			QM.Set_Num_Var(n);
		}
		else if( c=='m' ) {
			string s;
			stringstream ss;
			getline( fin , s );
			getline( fin , s );
			ss<< s ;
			int n;
			while( ss>> n ) 
				QM.Add_On_Set(n);
		}
		else if( c=='d' ) {
			string s;
			stringstream ss;
			getline( fin , s );
			getline( fin , s );
			ss<< s ;
			int n;
			while( ss>> n ) 
				QM.Add_DC_Set(n);
		}
		else {
			cerr<<"Wrong input format."<< endl;
			exit(-1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x1d8(%rbp), %r15
leaq -0x50(%rbp), %r12
leaq -0x30(%rbp), %r13
movq %r14, %rdi
leaq -0x29(%rbp), %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x280b
movzbl -0x29(%rbp), %eax
cmpl $0x2e, %eax
je 0x26d5
cmpl $0x64, %eax
je 0x2792
cmpl $0x6d, %eax
je 0x272e
cmpl $0x69, %eax
jne 0x281d
movq %r14, %rdi
movq %r15, %rsi
callq 0x2100
movl -0x1d8(%rbp), %esi
movq %rbx, %rdi
callq 0x2ad4
jmp 0x26d5
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
andq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq %r15, %rdi
callq 0x2110
movq %r14, %rdi
movq %r12, %rsi
callq 0x2050
movq %r14, %rdi
movq %r12, %rsi
callq 0x2050
leaq -0x1c8(%rbp), %rdi
movq %r12, %rsi
callq 0x2170
movq %r15, %rdi
movq %r13, %rsi
callq 0x2100
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x27f6
movl -0x30(%rbp), %esi
movq %rbx, %rdi
callq 0x2adc
jmp 0x276c
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
andq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq %r15, %rdi
callq 0x2110
movq %r14, %rdi
movq %r12, %rsi
callq 0x2050
movq %r14, %rdi
movq %r12, %rsi
callq 0x2050
leaq -0x1c8(%rbp), %rdi
movq %r12, %rsi
callq 0x2170
movq %r15, %rdi
movq %r13, %rsi
callq 0x2100
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x27f6
movl -0x30(%rbp), %esi
movq %rbx, %rdi
callq 0x2afc
jmp 0x27d0
movq %r15, %rdi
callq 0x2130
movq %r12, %rdi
callq 0x20c0
jmp 0x26d5
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa7cc(%rip), %rdi      # 0xcff0
leaq 0x58cc(%rip), %rsi      # 0x80f7
callq 0x2180
movq %rax, %rdi
callq 0x20d0
pushq $-0x1
popq %rdi
callq 0x21e0
jmp 0x2842
movq %rax, %rbx
jmp 0x285c
jmp 0x284d
jmp 0x284d
jmp 0x284d
movq %rax, %rbx
leaq -0x1d8(%rbp), %rdi
callq 0x2130
leaq -0x50(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/main.cpp
// Function: Output(std::basic_ofstream<char, std::char_traits<char>>&, Quine_McCluskey&, Petrick_Method&)
void Output(ofstream &fout, Quine_McCluskey &QM, Petrick_Method &PM) {
	QM.HW1_Print_Prime_Impli();
	QM.HW1_Print_Prime_Impli(fout);
	PM.HW1_Print_Minimum_Cover();	
	PM.HW1_Print_Minimum_Cover(fout);	
	cout<< endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x3186
movq %r14, %rdi
movq %r15, %rsi
callq 0x3224
movq %rbx, %rdi
callq 0x59fa
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5af0
movq 0xa723(%rip), %rdi      # 0xcfd0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: sort_by_num_of_1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool sort_by_num_of_1(const string a, const string b) {
	int cnt_a = 0 , cnt_b = 0 , size = a.length() ;
	for( int i=0 ; i<size ; i++ ) {
		if( a[i]=='1' )		cnt_a++ ;
		if( b[i]=='1' )		cnt_b++ ;
	}
	return ( cnt_a < cnt_b ) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
xorl %r8d, %r8d
cmpq %rcx, %rax
je 0x2a19
movq (%rdi), %r9
xorl %r10d, %r10d
cmpb $0x31, (%r9,%rcx)
sete %r10b
addl %r10d, %r8d
movq (%rsi), %r9
xorl %r10d, %r10d
cmpb $0x31, (%r9,%rcx)
sete %r10b
addl %r10d, %edx
incq %rcx
jmp 0x29eb
cmpl %edx, %r8d
setb %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: sort_by_num_of_literal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool sort_by_num_of_literal(const string a, const string b) {
	int cnt_a = 0 , cnt_b = 0 , size = a.length() ;
	for( int i=0 ; i<size ; i++ ) {
		if( a[i]!='-' )		cnt_a++ ;
		if( b[i]!='-' )		cnt_b++ ;
	}
	return ( cnt_a < cnt_b ) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
xorl %r8d, %r8d
cmpq %rcx, %rax
je 0x2a62
movq (%rdi), %r9
xorl %r10d, %r10d
cmpb $0x2d, (%r9,%rcx)
setne %r10b
addl %r10d, %r8d
movq (%rsi), %r9
xorl %r10d, %r10d
cmpb $0x2d, (%r9,%rcx)
setne %r10b
addl %r10d, %edx
incq %rcx
jmp 0x2a34
cmpl %edx, %r8d
setb %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Solve[abi:cxx11]()
vector<string> Quine_McCluskey::Solve() {
	Init_Impli();
	sort( Impli.begin() , Impli.end() );
	sort( Impli.begin() , Impli.end() , sort_by_num_of_1 );

	int round = 0 ;
	while( !Impli.empty() ) {
//		cout<<"round "<< round++ <<" : "<< endl;
//		Print_Impli();
		Generate_Prime_Impli();
	}
	return Prime_Impli ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2b7e
movq 0x50(%r14), %rdi
movq 0x58(%r14), %rsi
callq 0x35be
movq 0x50(%r14), %rdi
movq 0x58(%r14), %rsi
leaq -0x175(%rip), %rdx      # 0x29d8
callq 0x3d95
movq 0x50(%r14), %rax
cmpq 0x58(%r14), %rax
je 0x2b66
movq %r14, %rdi
callq 0x2c68
jmp 0x2b52
addq $0x68, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32e4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Init_Impli()
void Quine_McCluskey::Init_Impli() {
	int size;	
	// on set
	size = On_Set.size() ;
	for( int i=0 ; i<size ; i++ ) {
		Impli.push_back( Dec2Bin(On_Set[i]) ) ;
		s_On_Set.push_back( Impli.back() );
	}
	// don't care set
	size = DC_Set.size() ;
	for( int i=0 ; i<size ; i++ )
		Impli.push_back( Dec2Bin(DC_Set[i]) ) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r13
subq 0x8(%rdi), %r13
shrq $0x2, %r13
leaq 0x50(%rdi), %r14
leaq 0x38(%rdi), %rax
movq %rax, -0x30(%rbp)
xorl %r15d, %r15d
testl %r13d, %r13d
cmovlel %r15d, %r13d
leaq -0x50(%rbp), %r12
cmpq %r15, %r13
je 0x2bf9
movq 0x8(%rbx), %rax
movl (%rax,%r15,4), %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3010
movq %r14, %rdi
movq %r12, %rsi
callq 0x5006
movq %r12, %rdi
callq 0x20c0
movq 0x58(%rbx), %rsi
addq $-0x20, %rsi
movq -0x30(%rbp), %rdi
callq 0x3384
incq %r15
jmp 0x2bb8
movq 0x28(%rbx), %r12
subq 0x20(%rbx), %r12
shrq $0x2, %r12
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
leaq -0x50(%rbp), %r15
cmpq %r13, %r12
je 0x2c43
movq 0x20(%rbx), %rax
movl (%rax,%r13,4), %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3010
movq %r14, %rdi
movq %r15, %rsi
callq 0x5006
movq %r15, %rdi
callq 0x20c0
incq %r13
jmp 0x2c13
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c54
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::is_GrayCode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Quine_McCluskey::is_GrayCode(string a, string b) {
	int flag = 0 , size = a.length() ;
	for( int i=0 ; i<size ; i++ ) {
		if( a[i]!=b[i] )
			flag++ ;
	}
	return ( flag==1 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rsi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edi, %edi
cmpq %rcx, %rax
je 0x2fbe
movq (%rsi), %r8
movb (%r8,%rcx), %r8b
movq (%rdx), %r9
xorl %r10d, %r10d
cmpb (%r9,%rcx), %r8b
setne %r10b
addl %r10d, %edi
incq %rcx
jmp 0x2f9c
cmpl $0x1, %edi
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Merge(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Quine_McCluskey::Merge(string a, string b) {
	int size = a.length() ;
	for( int i=0 ; i<size ; i++ ) {
		if( a[i]!=b[i] ) {
			a[i] = '-' ;
			return a ;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdx), %eax
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
cmpq %rsi, %rax
je 0x3006
movq (%rdx), %rdi
movb (%rdi,%rsi), %r9b
movq (%rcx), %r10
leaq 0x1(%rsi), %r8
cmpb (%r10,%rsi), %r9b
movq %r8, %rsi
je 0x2fd9
movb $0x2d, -0x1(%rdi,%r8)
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Dec2Bin[abi:cxx11](int)
string Quine_McCluskey::Dec2Bin(int n) {
	string s;
	while( n!=0 ) {
		s += '0'+n%2 ;
		n /= 2 ;
	}
	int pad = Num_Var - s.length() ;
	while( pad-- ) {
		s += '0' ;
	}
	reverse( s.begin() , s.end() );
	return s ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %edx, %ecx
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
pushq $0x2
popq %r12
testl %ecx, %ecx
je 0x305d
movl %ecx, %eax
cltd
idivl %r12d
movl %eax, %r15d
subl %r15d, %ecx
subl %r15d, %ecx
addb $0x30, %cl
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x2150
movl %r15d, %ecx
jmp 0x3037
movl (%r14), %r15d
notl %r15d
addl 0x8(%rbx), %r15d
pushq $0x30
popq %r14
incl %r15d
je 0x307d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2150
jmp 0x306b
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
callq 0x510a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x309c
jmp 0x309c
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Print_Prime_Impli()
void Quine_McCluskey::Print_Prime_Impli() {
	int size = Prime_Impli.size() ;
	cout<<"Total number of Prime Implicant = "<< size << endl;
	for( int i=0 ; i<size ; i++ )
		cout<< Prime_Impli[i] << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %r14
subq 0x68(%rdi), %r14
shrq $0x5, %r14
movq 0x9ea5(%rip), %r15      # 0xcfd0
leaq 0x4fd9(%rip), %rsi      # 0x810b
movq %r15, %rdi
callq 0x2180
movq %rax, %rdi
movl %r14d, %esi
callq 0x22a0
movq %rax, %rdi
callq 0x20d0
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
shlq $0x5, %r14
cmpq %r12, %r14
je 0x317d
movq 0x68(%rbx), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
addq $0x20, %r12
jmp 0x315b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::HW1_Print_Prime_Impli()
void Quine_McCluskey::HW1_Print_Prime_Impli() {
	sort( Prime_Impli.begin() , Prime_Impli.end() , sort_by_num_of_literal );
	int size = Prime_Impli.size() ;
	cout<<".pi "<< size << endl;
	for( int i=0 ; i<size && i<20 ; i++ )
		cout<< Prime_Impli[i] << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
movq 0x70(%rbx), %rsi
leaq -0x785(%rip), %rdx      # 0x2a21
callq 0x3d95
movq 0x70(%rbx), %r15
subq 0x68(%rbx), %r15
shrq $0x5, %r15
movq 0x9e12(%rip), %r14      # 0xcfd0
leaq 0x4f69(%rip), %rsi      # 0x812e
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
movl %r15d, %esi
callq 0x22a0
movq %rax, %rdi
callq 0x20d0
movslq %r15d, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r15, %r13
jge 0x3214
cmpq $0x14, %r13
jae 0x3214
movq 0x68(%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
incq %r13
addq $0x20, %r12
jmp 0x31e9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::HW1_Print_Prime_Impli(std::basic_ofstream<char, std::char_traits<char>>&)
void Quine_McCluskey::HW1_Print_Prime_Impli(ofstream &fout) {
	sort( Prime_Impli.begin() , Prime_Impli.end() , sort_by_num_of_literal );
	int size = Prime_Impli.size() ;
	fout<<".pi "<< size << endl;
	for( int i=0 ; i<size && i<20 ; i++ )
		fout<< Prime_Impli[i] << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rdi
movq 0x70(%r14), %rsi
leaq -0x826(%rip), %rdx      # 0x2a21
callq 0x3d95
movq 0x70(%r14), %r15
subq 0x68(%r14), %r15
shrq $0x5, %r15
leaq 0x4ecf(%rip), %rsi      # 0x812e
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
movl %r15d, %esi
callq 0x22a0
movq %rax, %rdi
callq 0x20d0
movslq %r15d, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r15, %r13
jge 0x32ae
cmpq $0x14, %r13
jae 0x32ae
movq 0x68(%r14), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
incq %r13
addq $0x20, %r12
jmp 0x3283
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Petrick_Method(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::__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>>>>&)
Petrick_Method::Petrick_Method(vector<string> &Prime_Impli, vector<string> &On_Set) {
	int size1 = On_Set.size(), size2 = Prime_Impli.size() ;
	for( int i=0 ; i<size1 ; i++ ) {
		vector<string> sum;
		for( int j=0 ; j<size2 ; j++ ) {
			if( is_On_in_Prime_Impli( On_Set[i] , Prime_Impli[j] ) )
				sum.push_back( Prime_Impli[j] ) ;
		}
		POS.push_back( sum );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
andl $0x0, 0x38(%rdi)
leaq 0x38(%rdi), %rax
andq $0x0, 0x40(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movups %xmm0, 0x58(%rdi)
movq %rdi, -0x30(%rbp)
movups %xmm0, 0x68(%rdi)
movq 0x8(%rdx), %rax
movq %rdx, -0x50(%rbp)
subq (%rdx), %rax
shrq $0x5, %rax
movq 0x8(%rsi), %rcx
movq %rsi, -0x38(%rbp)
subq (%rsi), %rcx
shrq $0x5, %rcx
xorl %r14d, %r14d
testl %ecx, %ecx
cmovlel %r14d, %ecx
testl %eax, %eax
cmovlel %r14d, %eax
movq %rax, -0x40(%rbp)
shlq $0x5, %rcx
movq %rcx, -0x58(%rbp)
leaq -0x90(%rbp), %r13
leaq -0xb0(%rbp), %rbx
cmpq -0x40(%rbp), %r14
je 0x5273
andq $0x0, -0x60(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq %r14, -0x48(%rbp)
shlq $0x5, %r14
xorl %r15d, %r15d
cmpq %r15, -0x58(%rbp)
je 0x524f
movq -0x50(%rbp), %rax
movq (%rax), %rsi
addq %r14, %rsi
movq %r13, %rdi
callq 0x2230
movq -0x38(%rbp), %rax
movq (%rax), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x2230
movq %r13, %rsi
movq %rbx, %rdx
callq 0x52dc
movl %eax, %r12d
movq %rbx, %rdi
callq 0x20c0
movq %r13, %rdi
callq 0x20c0
testb %r12b, %r12b
je 0x5249
movq -0x38(%rbp), %rax
movq (%rax), %rsi
addq %r15, %rsi
leaq -0x70(%rbp), %rdi
callq 0x3384
addq $0x20, %r15
jmp 0x51e9
movq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %r14
movq %r14, %rsi
callq 0x5be2
movq %r14, %rdi
callq 0x28bc
movq -0x48(%rbp), %r14
incq %r14
jmp 0x51c8
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5298
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x20c0
jmp 0x529b
movq %rax, %rbx
movq -0x30(%rbp), %r13
leaq 0x60(%r13), %r14
leaq 0x18(%r13), %r15
leaq 0x30(%r13), %r12
leaq -0x70(%rbp), %rdi
callq 0x28bc
movq %r14, %rdi
callq 0x3426
movq %r12, %rdi
callq 0x28e8
movq %r15, %rdi
callq 0x5c1e
movq %r13, %rdi
callq 0x5c4a
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::is_On_in_Prime_Impli(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Petrick_Method::is_On_in_Prime_Impli(string On, string Prime_Impli) {
	int size = On.size() ;
	for( int i=0 ; i<size ; i++ ) {
		if( Prime_Impli[i]!='-' && Prime_Impli[i]!=On[i] )
			return false ;
	}
	return true ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edi
cmovgl %eax, %edi
cmpq %rcx, %rdi
je 0x5310
movq (%rdx), %r8
movb (%r8,%rcx), %r8b
cmpb $0x2d, %r8b
je 0x530b
movq (%rsi), %r9
cmpb (%r9,%rcx), %r8b
jne 0x5310
incq %rcx
jmp 0x52f0
cltq
cmpq %rax, %rcx
setge %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Solve[abi:cxx11]()
set<string> Petrick_Method::Solve() {
	POS2SOP();
	sort( SOP.begin() , SOP.end() , sort_by_SOP );
	CountAllCost();
	return SOP[0] ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5392
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq -0x244(%rip), %rdx      # 0x512c
callq 0x6270
movq %rbx, %rdi
callq 0x53f4
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x5cd2
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::CountAllCost()
void Petrick_Method::CountAllCost() {
	int min_cover = SOP[0].size() ;
	for( int i=0 ; SOP[i].size()==min_cover ; i++ ) {
		int cost = 0 ;
		for( iter=SOP[i].begin() ; iter!=SOP[i].end() ; iter++ )
			cost += CountCost( *iter ) ;
		SOP_cost.push_back(cost);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x28(%rax), %rcx
movslq %ecx, %rdx
movq %rdx, -0x40(%rbp)
leaq 0x60(%rdi), %rdx
movq %rdx, -0x38(%rbp)
xorl %r14d, %r14d
leaq -0x60(%rbp), %r12
leaq 0x7d63(%rip), %r13      # 0xd190
cmpq -0x40(%rbp), %rcx
jne 0x54a4
andl $0x0, -0x2c(%rbp)
imulq $0x30, %r14, %r15
movq 0x18(%rax,%r15), %rsi
movq %rsi, 0x7d49(%rip)      # 0xd190
addq %r15, %rax
addq $0x8, %rax
cmpq %rax, %rsi
je 0x5489
addq $0x20, %rsi
movq %r12, %rdi
callq 0x2230
movq %r12, %rsi
callq 0x56ae
addl %eax, -0x2c(%rbp)
movq %r12, %rdi
callq 0x20c0
movq %r13, %rdi
xorl %esi, %esi
callq 0x5cb2
movq 0x18(%rbx), %rax
movq 0x7d09(%rip), %rsi      # 0xd190
jmp 0x5447
movq -0x38(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x32be
incq %r14
movq 0x18(%rbx), %rax
movq 0x58(%r15,%rax), %rcx
jmp 0x542d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Expansion(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<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>>>>&, int, int)
void Petrick_Method::Expansion(set<string> &product, int i_POS, int maxi) {
	if( i_POS==maxi ) { 
		string s = set2string(product) ;
		if( s_SOP.find(s)==s_SOP.end() ) {
			s_SOP.insert( s );
			SOP.push_back( product );
		}
	}
	int size = POS[ i_POS ].size() ;
	for( int i=0 ; i<size ; i++ ) {
		if( product.find( POS[ i_POS ][i] )==product.end() ) {
			product.insert( POS[ i_POS ][ i ] );
			Expansion( product , i_POS+1 , maxi );
			product.erase( POS[ i_POS ][i] );
		}
		else
			Expansion( product , i_POS+1 , maxi );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r12
movl %ecx, -0x30(%rbp)
movl %edx, %ebx
cmpl %ecx, %edx
jne 0x551f
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x55e6
leaq 0x30(%r12), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x6d90
leaq 0x38(%r12), %rcx
cmpq %rcx, %rax
jne 0x5516
leaq -0x58(%rbp), %rsi
movq %r13, %rdi
callq 0x6e1a
leaq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0x5c76
leaq -0x58(%rbp), %rdi
callq 0x20c0
movl %ebx, %edx
movslq %ebx, %rax
movq (%r12), %rcx
imulq $0x18, %rax, %r13
movq 0x8(%rcx,%r13), %rbx
subq (%rcx,%r13), %rbx
shrq $0x5, %rbx
leaq 0x8(%r15), %rax
movq %rax, -0x38(%rbp)
incl %edx
movl %edx, -0x2c(%rbp)
xorl %r14d, %r14d
testl %ebx, %ebx
cmovlel %r14d, %ebx
shlq $0x5, %rbx
cmpq %r14, %rbx
je 0x55c1
movq (%r12), %rax
movq (%rax,%r13), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x6d90
cmpq -0x38(%rbp), %rax
je 0x5584
movq %r12, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x54b4
jmp 0x55bb
movq (%r12), %rax
movq (%rax,%r13), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x6e1a
movq %r12, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x54b4
movq (%r12), %rax
movq (%rax,%r13), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x717c
addq $0x20, %r14
jmp 0x5553
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x55d2
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::set2string(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<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>>>>&)
string Petrick_Method::set2string(set<string> &temp) {
	stringstream ss;
	for( iter=temp.begin() ; iter!=temp.end() ; iter++ )
		ss<< *iter ;
	string s;
	ss>> s ;
	return s ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x2110
movq 0x18(%r14), %rsi
movq %rsi, 0x7b7b(%rip)      # 0xd190
addq $0x8, %r14
leaq -0x198(%rbp), %r15
leaq 0x7b69(%rip), %r12      # 0xd190
cmpq %r14, %rsi
je 0x564b
addq $0x20, %rsi
movq %r15, %rdi
callq 0x2170
movq %r12, %rdi
xorl %esi, %esi
callq 0x5cb2
movq 0x7b47(%rip), %rsi      # 0xd190
jmp 0x5627
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x1a8(%rbp), %rdi
movq %rbx, %rsi
callq 0x2200
leaq -0x1a8(%rbp), %rdi
callq 0x2130
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
jmp 0x5699
movq %rax, %r14
leaq -0x1a8(%rbp), %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::CountCost(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Petrick_Method::CountCost(string impli) {
	int size = impli.size(), cost = 0 ;
	for( int i=0 ; i<size ; i++ ) {
		if( impli[i]!='-' )
			cost++ ;
	}
	return cost ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rsi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x56d9
movq (%rsi), %rdi
xorl %r8d, %r8d
cmpb $0x2d, (%rdi,%rdx)
setne %r8b
addl %r8d, %eax
incq %rdx
jmp 0x56be
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Print_POS()
void Petrick_Method::Print_POS() {
	cout<<"Product of Sum = ";
	int size1 = POS.size() ;
	for( int i=0 ; i<size1 ; i++ ) {
		cout<<"( "<< POS[i][0] ;
		int size2 = POS[i].size() ;
		for( int j=1 ; j<size2 ; j++ )
			cout<<" + "<< POS[i][j] ;
		cout<<" )";
	}
	cout<< endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x78d9(%rip), %rdi      # 0xcfd0
leaq 0x2a82(%rip), %rsi      # 0x8180
callq 0x2180
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %eax
movq %rax, -0x30(%rbp)
cmpq -0x30(%rbp), %r14
je 0x57b9
movq 0x78a0(%rip), %rdi      # 0xcfd0
leaq 0x2a5b(%rip), %rsi      # 0x8192
callq 0x2180
movq (%rbx), %rcx
movq %r14, -0x38(%rbp)
imulq $0x18, %r14, %r15
movq (%rcx,%r15), %rsi
movq %rax, %rdi
callq 0x2170
movq (%rbx), %rax
movq 0x8(%rax,%r15), %rcx
subq (%rax,%r15), %rcx
shrq $0x5, %rcx
movslq %ecx, %r12
pushq $0x20
popq %r14
pushq $0x1
popq %r13
movq 0x785b(%rip), %rdi      # 0xcfd0
cmpq %r12, %r13
jge 0x57a1
leaq 0x2a14(%rip), %rsi      # 0x8195
callq 0x2180
movq (%rbx), %rcx
movq (%rcx,%r15), %rsi
addq %r14, %rsi
movq %rax, %rdi
callq 0x2170
incq %r13
addq $0x20, %r14
jmp 0x576e
leaq 0x29f1(%rip), %rsi      # 0x8199
callq 0x2180
movq -0x38(%rbp), %r14
incq %r14
jmp 0x571f
movq 0x7810(%rip), %rdi      # 0xcfd0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Print_SOP()
void Petrick_Method::Print_SOP() {
	cout<<"Sum of Product = "<< endl;
	int size = SOP.size() ;
	for( int i=0 ; i<size ; i++ ) {
		iter = SOP[i].begin() ;
		cout<<"("<< *iter <<")";
		for( iter++ ; iter!=SOP[i].end() ; iter++ )
			cout<<"("<< *iter <<")";
		cout<< endl;
	}
	cout<< endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x77e1(%rip), %r12      # 0xcfd0
leaq 0x29a6(%rip), %rsi      # 0x819c
movq %r12, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movq %rax, -0x38(%rbp)
leaq 0x2986(%rip), %r13      # 0x81ae
leaq 0x7961(%rip), %r15      # 0xd190
leaq 0x2964(%rip), %rbx      # 0x819a
movq %r14, -0x30(%rbp)
cmpq -0x38(%rbp), %rcx
je 0x58b8
movq 0x18(%r14), %rax
movq %rcx, -0x40(%rbp)
imulq $0x30, %rcx, %r14
movq 0x18(%rax,%r14), %rax
movq %rax, 0x7938(%rip)      # 0xd190
movq %r12, %rdi
movq %r13, %rsi
callq 0x2180
movq 0x7926(%rip), %rsi      # 0xd190
addq $0x20, %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
movq %r15, %rdi
xorl %esi, %esi
callq 0x5cb2
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
addq %r14, %rax
addq $0x8, %rax
cmpq %rax, 0x78ef(%rip)      # 0xd190
jne 0x5858
movq %r12, %rdi
callq 0x20d0
movq -0x40(%rbp), %rcx
incq %rcx
movq -0x30(%rbp), %r14
jmp 0x583a
movq 0x7711(%rip), %rdi      # 0xcfd0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Print_FewestTerm_P()
void Petrick_Method::Print_FewestTerm_P() {
	int min_cover = SOP[0].size() ;
	for( int i=0 ; SOP[i].size()==min_cover ; i++ ) {
		cout<<"Answer "<< i+1 <<" : "<< endl;
		iter = SOP[i].begin() ;
		cout<< *iter ;
		for( iter++ ; iter!=SOP[i].end() ; iter++ )
			cout<<"\n"<< *iter ;
		cout<< endl ;
		cout<<"cost = "<< SOP_cost[i] << endl ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movslq 0x28(%rax), %rcx
movq %rcx, -0x38(%rbp)
xorl %edx, %edx
movq 0x76d5(%rip), %r14      # 0xcfd0
leaq 0x788e(%rip), %r13      # 0xd190
leaq 0x2731(%rip), %r12      # 0x803a
imulq $0x30, %rdx, %r15
movq -0x38(%rbp), %rcx
cmpq %rcx, 0x28(%rax,%r15)
jne 0x59ea
movq %r14, %rdi
leaq 0x288a(%rip), %rsi      # 0x81b0
movq %rdx, -0x30(%rbp)
callq 0x2180
movq -0x30(%rbp), %rcx
leaq 0x1(%rcx), %rsi
movq %rax, %rdi
movq %rsi, -0x40(%rbp)
callq 0x22a0
movq %rax, %rdi
leaq 0x286b(%rip), %rsi      # 0x81b8
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq 0x18(%rbx), %rax
movq 0x18(%rax,%r15), %rsi
movq %rsi, 0x7826(%rip)      # 0xd190
movq %r14, %rdi
addq $0x20, %rsi
callq 0x2170
movq %r13, %rdi
xorl %esi, %esi
callq 0x5cb2
movq 0x18(%rbx), %rax
addq %r15, %rax
addq $0x8, %rax
cmpq %rax, 0x77fe(%rip)      # 0xd190
je 0x59ab
movq %r14, %rdi
movq %r12, %rsi
callq 0x2180
movq %rax, %rdi
movq 0x77e7(%rip), %rsi      # 0xd190
jmp 0x596d
movq %r14, %rdi
callq 0x20d0
movq %r14, %rdi
leaq 0x27ff(%rip), %rsi      # 0x81bc
callq 0x2180
movq 0x60(%rbx), %rcx
movq -0x30(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq %rax, %rdi
callq 0x22a0
movq %rax, %rdi
callq 0x20d0
movq 0x18(%rbx), %rax
movq -0x40(%rbp), %rdx
jmp 0x5909
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::HW1_Print_Minimum_Cover()
void Petrick_Method::HW1_Print_Minimum_Cover() {
	int min_cover = SOP[0].size(), min_cost = SOP_cost[0] , ans = 0 ;
	int size = SOP.size() ;
	for( int i=0 ; SOP[i].size()==min_cover ; i++ ) {
		if( SOP_cost[i]<min_cost ) {
			min_cost = SOP_cost[i] ;
			ans = i ;
		}
	}
	cout<<".mc "<< min_cover << endl;
	for( iter=SOP[ans].begin() ; iter!=SOP[ans].end() ; iter++ )
		cout<< *iter << endl;
	cout<<"cost="<< min_cost << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq 0x60(%rdi), %rcx
movq 0x28(%rax), %r12
addq $0x28, %rax
movl (%rcx), %ebx
movslq %r12d, %rdx
xorl %esi, %esi
xorl %r13d, %r13d
cmpq %rdx, (%rax)
jne 0x5a3f
movl (%rcx,%rsi,4), %edi
cmpl %ebx, %edi
cmovll %esi, %r13d
cmovll %edi, %ebx
incq %rsi
addq $0x30, %rax
jmp 0x5a25
movq 0x758a(%rip), %r15      # 0xcfd0
leaq 0x2777(%rip), %rsi      # 0x81c4
movq %r15, %rdi
callq 0x2180
movq %rax, %rdi
movl %r12d, %esi
callq 0x22a0
movq %rax, %rdi
callq 0x20d0
movslq %r13d, %rcx
movq 0x18(%r14), %rax
imulq $0x30, %rcx, %r13
movq 0x18(%rax,%r13), %rsi
movq %rsi, 0x7711(%rip)      # 0xd190
leaq 0x770a(%rip), %r12      # 0xd190
addq %r13, %rax
addq $0x8, %rax
cmpq %rax, %rsi
je 0x5abd
addq $0x20, %rsi
movq %r15, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq %r12, %rdi
xorl %esi, %esi
callq 0x5cb2
movq 0x18(%r14), %rax
movq 0x76d5(%rip), %rsi      # 0xd190
jmp 0x5a86
movq 0x750c(%rip), %rdi      # 0xcfd0
leaq 0x26fe(%rip), %rsi      # 0x81c9
callq 0x2180
movq %rax, %rdi
movl %ebx, %esi
callq 0x22a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::HW1_Print_Minimum_Cover(std::basic_ofstream<char, std::char_traits<char>>&)
void Petrick_Method::HW1_Print_Minimum_Cover(ofstream &fout) {
	int min_cover = SOP[0].size(), min_cost = SOP_cost[0] , ans = 0 ;
	int size = SOP.size() ;
	for( int i=0 ; SOP[i].size()==min_cover ; i++ ) {
		if( SOP_cost[i]<min_cost ) {
			min_cost = SOP_cost[i] ;
			ans = i ;
		}
	}
	fout<<".mc "<< min_cover << endl;
	for( iter=SOP[ans].begin() ; iter!=SOP[ans].end() ; iter++ )
		fout<< *iter << endl;
	fout<<"cost="<< min_cost << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rax
movq 0x60(%rdi), %rcx
movq 0x28(%rax), %r12
addq $0x28, %rax
movl (%rcx), %r14d
movslq %r12d, %rdx
xorl %esi, %esi
xorl %r13d, %r13d
cmpq %rdx, (%rax)
jne 0x5b3b
movl (%rcx,%rsi,4), %edi
cmpl %r14d, %edi
cmovll %esi, %r13d
cmovll %edi, %r14d
incq %rsi
addq $0x30, %rax
jmp 0x5b1f
leaq 0x2682(%rip), %rsi      # 0x81c4
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
movl %r12d, %esi
callq 0x22a0
movq %rax, %rdi
callq 0x20d0
movslq %r13d, %rcx
movq 0x18(%r15), %rax
imulq $0x30, %rcx, %r13
movq 0x18(%rax,%r13), %rsi
movq %rsi, 0x761c(%rip)      # 0xd190
leaq 0x7615(%rip), %r12      # 0xd190
addq %r13, %rax
addq $0x8, %rax
cmpq %rax, %rsi
je 0x5bb2
addq $0x20, %rsi
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq %r12, %rdi
xorl %esi, %esi
callq 0x5cb2
movq 0x18(%r15), %rax
movq 0x75e0(%rip), %rsi      # 0xd190
jmp 0x5b7b
leaq 0x2610(%rip), %rsi      # 0x81c9
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
movl %r14d, %esi
callq 0x22a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day08/ex00/./easyfind.hpp
// Function: int easyfind<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>>&, int)
int	easyfind(T &t, int i)
{
	typename T::iterator iterator;

	iterator = std::find(t.begin(), t.end(), i);
	if (iterator != t.end())
		return (*iterator);
	throw std::exception();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0xc(%rbp), %rdx
movl %esi, (%rdx)
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x1824
cmpq 0x8(%rbx), %rax
je 0x1579
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x1080
movq 0x2a38(%rip), %rcx      # 0x3fc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x2a42(%rip), %rsi      # 0x3fd8
movq 0x2a53(%rip), %rdx      # 0x3ff0
movq %rax, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/ssearch_x.c
// Function: on_match
static int
on_match(int strnum, const char *textp, MEMREF const *pattv)
{
    ++hits;
    if (verbose > 1)
	fprintf(stderr, "match patt[%d] '%.*s' at %"FSIZE"d\n",
		strnum, (int)pattv[strnum].len, pattv[strnum].ptr,
		textp - text.ptr);
    return  1;
}

// Assembly:
incl 0x6fcc(%rip)            # 0xa770
cmpl $0x2, 0x6fad(%rip)      # 0xa758
jge 0x37b1
pushq $0x1
popq %rax
retq
pushq %rax
movq %rsi, %r9
movq 0x681c(%rip), %rax      # 0x9fd8
movq (%rax), %rax
movslq %edi, %r10
movq %r10, %rsi
shlq $0x4, %rsi
movl 0x8(%rdx,%rsi), %ecx
movq (%rdx,%rsi), %r8
subq 0x6f88(%rip), %r9       # 0xa760
leaq 0x391a(%rip), %rsi      # 0x70f9
movq %rax, %rdi
movl %r10d, %edx
xorl %eax, %eax
callq 0x3260
addq $0x8, %rsp
jmp 0x37ad
nop
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/ssearch.c
// Function: ssearch_destroy
void
ssearch_destroy(SSEARCH*ssp)
{
    if (!ssp)
        return;

    free(ssp->mapv);
    map_destroy(ssp->suffixh);
    free(ssp->prefixv);
    free(ssp);
}

// Assembly:
testq %rdi, %rdi
je 0x4b26
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3200
movq 0x18(%rbx), %rdi
callq 0x5188
movq 0x20(%rbx), %rdi
callq 0x3200
movq %rbx, %rdi
popq %rbx
jmp 0x3200
retq