LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x61ba(%rip), %rdi      # 0x11fd0
callq 0x3230
movq %rax, %r15
leaq 0x170d(%rip), %rsi      # 0xd532
movl $0x27, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0x3270
movq %rax, %r15
leaq 0x173b(%rip), %rsi      # 0xd583
movl $0x6, %edx
movq %rax, %rdi
callq 0x31a0
movzbl 0xb8(%rbx), %esi
movq %r15, %rdi
callq 0x3260
leaq 0x1604(%rip), %rsi      # 0xd46f
movl $0x1, %edx
movq %rax, %rdi
callq 0x31a0
movq 0xd0(%rbx), %rax
testq %rax, %rax
je 0xbedc
movq 0x28(%rax), %r15
movl $0x38, %edi
callq 0x3160
leaq 0x630f(%rip), %rcx      # 0x121a8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
leaq -0xb7(%rip), %rcx       # 0xbdfc
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rcx, 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 0x60ed(%rip), %rdi      # 0x11fd0
leaq 0x1670(%rip), %rsi      # 0xd55a
movl $0xa, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0xb0(%rdi), %xmm0
movq 0x60c0(%rip), %rdi      # 0x11fd0
callq 0x3230
movq %rax, %r14
leaq 0x1646(%rip), %rsi      # 0xd565
movl $0x24, %edx
movq %rax, %rdi
callq 0x31a0
movzbl 0xb8(%rbx), %esi
movq %r14, %rdi
callq 0x3260
leaq 0x152d(%rip), %rsi      # 0xd46f
movl $0x1, %edx
movq %rax, %rdi
callq 0x31a0
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0xbfc2
movq 0x28(%rax), %r14
movl $0x38, %edi
callq 0x3160
leaq 0x6238(%rip), %rcx      # 0x121a8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
leaq -0x90(%rip), %rcx       # 0xbefa
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
leaq 0x6215(%rip), %rdx      # 0x121b0
movq (%rdx), %rsi
movq %rsi, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rcx, (%rdx)
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
movq 0x6007(%rip), %rdi      # 0x11fd0
leaq 0x158a(%rip), %rsi      # 0xd55a
movl $0xa, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x393c
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a70
movq %rbx, %rdi
callq 0x6a3a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6bbe
movq 0xa404(%rip), %rbx      # 0xcfd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2f7a
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
cmpq %r12, %r15
je 0x2efe
movq %r12, %rax
subq %r15, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ee4
movq %r15, %rdi
movq %r12, %rsi
callq 0x3fd5
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
cmpq %r12, %r15
je 0x2f4f
movq %r12, %rax
subq %r15, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0x221(%rip), %r13      # 0x2d08
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x4758
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4864
jmp 0x2f4f
movq %r14, %rdi
callq 0x30a0
movq 0x50(%r14), %rax
cmpq 0x58(%r14), %rax
jne 0x2f47
addq $0x68, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b98
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testl %r13d, %r13d
jle 0x3009
leaq 0x50(%rbx), %rax
movq %rax, -0x50(%rbp)
leaq 0x38(%rbx), %r15
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
leaq -0x48(%rbp), %r12
movq 0x8(%rbx), %rax
movl (%rax,%r14,4), %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x36dc
movq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x5af0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2ff1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq 0x58(%rbx), %rsi
addq $-0x20, %rsi
movq %r15, %rdi
callq 0x3c80
incq %r14
cmpq %r14, %r13
jne 0x2fb9
movq 0x28(%rbx), %r12
subq 0x20(%rbx), %r12
shrq $0x2, %r12
testl %r12d, %r12d
jle 0x306b
leaq 0x50(%rbx), %r14
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq -0x48(%rbp), %r15
movq 0x20(%rbx), %rax
movl (%rax,%r13,4), %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x36dc
movq %r14, %rdi
movq %r15, %rsi
callq 0x5af0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3063
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
incq %r13
cmpq %r13, %r12
jne 0x302c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x307c
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3098
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rax
movq 0x8(%rdx), %rdi
testl %edi, %edi
jle 0x36db
pushq %rbp
movq %rsp, %rbp
movq (%rdx), %rsi
movq (%rcx), %rcx
movb (%rsi), %r8b
cmpb (%rcx), %r8b
jne 0x3696
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movl $0x1, %r9d
cmpq %r9, %rdi
je 0x36da
movb (%rsi,%r9), %r10b
leaq 0x1(%r9), %r8
cmpb (%rcx,%r9), %r10b
movq %r8, %r9
je 0x367b
decq %r8
jmp 0x3699
xorl %r8d, %r8d
movb $0x2d, (%rsi,%r8)
leaq 0x10(%rax), %rsi
movq %rsi, (%rax)
movq (%rdx), %rdi
leaq 0x10(%rdx), %rcx
cmpq %rcx, %rdi
je 0x36bd
movq %rdi, (%rax)
movq (%rcx), %rsi
movq %rsi, 0x10(%rax)
jmp 0x36c3
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq %rcx, (%rdx)
movq $0x0, 0x8(%rdx)
movb $0x0, 0x10(%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %edx, %edx
je 0x373e
movl %edx, %r15d
movl %edx, %r13d
shrl $0x1f, %r13d
addl %r15d, %r13d
movl %r13d, %eax
andl $0xfe, %eax
movl %r15d, %ecx
subl %eax, %ecx
addb $0x30, %cl
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x2180
sarl %r13d
incl %r15d
cmpl $0x3, %r15d
movl %r13d, %r15d
jae 0x370d
movl (%r14), %r14d
notl %r14d
addl 0x8(%rbx), %r14d
incl %r14d
je 0x375c
movq %rbx, %rdi
movl $0x30, %esi
callq 0x2180
jmp 0x3748
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
setne %dl
addq %rax, %rcx
decq %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x379d
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x3782
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37b1
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x37c8
movq (%r12), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %r14
subq 0x68(%rdi), %r14
shrq $0x5, %r14
movq 0x974e(%rip), %r15      # 0xcfd0
leaq 0x5882(%rip), %rsi      # 0x910b
movl $0x22, %edx
movq %r15, %rdi
callq 0x2210
movq %r15, %rdi
movl %r14d, %esi
callq 0x22d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
testl %r14d, %r14d
jle 0x392c
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movl $0x8, %r13d
movq 0x96ec(%rip), %r15      # 0xcfd0
movq 0x68(%rbx), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r15, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x20, %r13
decq %r14
jne 0x38e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r14
movq 0x70(%rdi), %r15
cmpq %r15, %r14
je 0x3994
movq %r15, %rax
subq %r14, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0xc1f(%rip), %r12      # 0x2d59
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4758
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4864
movq 0x70(%rbx), %r14
subq 0x68(%rbx), %r14
shrq $0x5, %r14
movq 0x9629(%rip), %r15      # 0xcfd0
leaq 0x5780(%rip), %rsi      # 0x912e
movl $0x4, %edx
movq %r15, %rdi
callq 0x2210
movq %r15, %rdi
movl %r14d, %esi
callq 0x22d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
testl %r14d, %r14d
jle 0x3a60
decl %r14d
cmpq $0x13, %r14
movl $0x13, %r12d
cmovbq %r14, %r12
shll $0x5, %r12d
addq $0x20, %r12
xorl %r13d, %r13d
movq 0x95b8(%rip), %r14      # 0xcfd0
movq 0x68(%rbx), %rax
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %r14, %rdi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x20, %r13
cmpq %r13, %r12
jne 0x3a18
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r15
movq 0x70(%rdi), %r12
cmpq %r12, %r15
je 0x3acb
movq %r12, %rax
subq %r15, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0xd56(%rip), %r13      # 0x2d59
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x4758
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4864
movq 0x70(%r14), %r15
subq 0x68(%r14), %r15
shrq $0x5, %r15
leaq 0x5650(%rip), %rsi      # 0x912e
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
movl %r15d, %esi
callq 0x22d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
testl %r15d, %r15d
jle 0x3b89
decl %r15d
cmpq $0x13, %r15
movl $0x13, %r12d
cmovbq %r15, %r12
shll $0x5, %r12d
addq $0x20, %r12
xorl %r13d, %r13d
movq 0x68(%r14), %rax
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x20, %r13
cmpq %r13, %r12
jne 0x3b41
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x60c0
movq 0x18(%r14), %r15
movq 0x20(%r14), %r12
cmpq %r12, %r15
je 0x6099
movq %r12, %rax
subq %r15, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0x371(%rip), %r13      # 0x5d0c
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x7284
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x7383
movq %r14, %rdi
callq 0x6126
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x6e4a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18(%rdi), %rax
movq 0x28(%rax), %rcx
movslq %ecx, %rdx
movq %rdx, -0x40(%rbp)
cmpq %rdx, %rcx
jne 0x624f
movq %rdi, %rbx
leaq -0x50(%rbp), %r15
leaq 0x60(%rdi), %rcx
movq %rcx, -0x38(%rbp)
xorl %r14d, %r14d
leaq -0x60(%rbp), %r12
movl $0x0, -0x2c(%rbp)
movq 0x18(%rax), %rax
movq %rax, 0x7041(%rip)      # 0xd1b8
movq 0x18(%rbx), %rcx
leaq (%r14,%r14,2), %r13
shlq $0x4, %r13
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x6207
movq %r15, -0x60(%rbp)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x3ccc
movq -0x58(%rbp), %rax
testl %eax, %eax
jle 0x61d1
movq -0x60(%rbp), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
xorl %edx, %edx
xorl %edi, %edi
cmpb $0x2d, (%rcx,%rsi)
setne %dil
addl %edi, %edx
incq %rsi
cmpq %rsi, %rax
jne 0x61bb
jmp 0x61d3
xorl %edx, %edx
addl %edx, -0x2c(%rbp)
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x61eb
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21d0
movq 0x6fc6(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x6fba(%rip)      # 0xd1b8
movq 0x18(%rbx), %rcx
jmp 0x6183
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0x6220
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x68(%rbx)
jmp 0x622d
movq -0x38(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x3da4
incq %r14
movq 0x18(%rbx), %rcx
leaq (%r14,%r14,2), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq -0x40(%rbp), %rsi
cmpq %rsi, 0x28(%rcx,%rdx)
je 0x6165
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r12
movl %ecx, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
cmpl %ecx, %edx
jne 0x62da
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x63d4
leaq 0x30(%r12), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x806c
leaq 0x38(%r12), %rcx
cmpq %rcx, %rax
jne 0x62c1
leaq -0x68(%rbp), %rsi
movq %r13, %rdi
callq 0x810a
leaq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0x6e0e
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62da
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21d0
movslq -0x2c(%rbp), %rax
movq (%r12), %rcx
leaq (%rax,%rax,2), %r13
movq 0x8(%rcx,%r13,8), %rbx
subq (%rcx,%r13,8), %rbx
shrq $0x5, %rbx
testl %ebx, %ebx
jle 0x639e
leaq 0x8(%r15), %rcx
movq %rcx, -0x48(%rbp)
incl -0x2c(%rbp)
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %r14d, %r14d
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
movq %rax, -0x40(%rbp)
movq %r13, -0x38(%rbp)
movq (%r12), %rax
movq (%rax,%r13,8), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x806c
cmpq -0x48(%rbp), %rax
je 0x634b
movq %r12, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x625e
jmp 0x6395
movq (%r12), %rax
movq -0x40(%rbp), %r13
movq (%rax,%r13), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x810a
movq %r12, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x625e
movq (%r12), %rax
movq (%rax,%r13), %rsi
movq -0x38(%rbp), %r13
addq %r14, %rsi
movq %r15, %rdi
callq 0x8468
movq %r15, %rdi
movq %rax, %rsi
callq 0x851a
addq $0x20, %r14
decq %rbx
jne 0x631f
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x63af
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63cb
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x2110
movq 0x18(%r14), %rax
addq $0x8, %r14
movq %rax, 0x6db3(%rip)      # 0xd1b8
cmpq %r14, %rax
je 0x6439
leaq -0x190(%rbp), %r15
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %r15, %rdi
callq 0x2210
movq 0x6d90(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x6d84(%rip)      # 0xd1b8
cmpq %r14, %rax
jne 0x6411
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x1a0(%rbp), %rdi
movq %rbx, %rsi
callq 0x2250
movq 0x6b4e(%rip), %rsi      # 0xcfb0
leaq -0x1a0(%rbp), %rdi
callq 0x2140
leaq -0x120(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x64a6
movq (%r15), %rsi
incq %rsi
callq 0x21d0
jmp 0x64a6
movq %rax, %r14
movq 0x6b03(%rip), %rsi      # 0xcfb0
leaq -0x1a0(%rbp), %rdi
callq 0x2140
leaq -0x120(%rbp), %rdi
callq 0x2090
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq 0x6ab5(%rip), %rdi      # 0xcfd0
leaq 0x2c8e(%rip), %rsi      # 0x91b0
movl $0x11, %edx
callq 0x2210
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rcx, -0x30(%rbp)
testl %ecx, %ecx
jle 0x6638
movq -0x30(%rbp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, -0x30(%rbp)
xorl %ebx, %ebx
movq 0x6a69(%rip), %r15      # 0xcfd0
movq %r14, -0x40(%rbp)
movl $0x2, %edx
movq %r15, %rdi
leaq 0x2c48(%rip), %rsi      # 0x91c2
callq 0x2210
movq (%r14), %rax
movq %rbx, -0x38(%rbp)
leaq (,%rbx,8), %rcx
leaq (%rcx,%rcx,2), %rbx
movq (%rax,%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x2210
movq (%r14), %rax
movq 0x8(%rax,%rbx), %r12
subq (%rax,%rbx), %r12
shrq $0x5, %r12
cmpl $0x2, %r12d
leaq 0x2c05(%rip), %r14      # 0x91c5
jl 0x660f
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
decq %r12
movl $0x28, %r13d
movq -0x38(%rbp), %rax
leaq (%rax,%rax,2), %rbx
movl $0x3, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2210
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq (%rax,%rbx,8), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r15, %rdi
callq 0x2210
addq $0x20, %r13
decq %r12
jne 0x65da
movl $0x2, %edx
movq %r15, %rdi
leaq 0x2bab(%rip), %rsi      # 0x91c9
callq 0x2210
movq -0x38(%rbp), %rbx
incq %rbx
cmpq -0x30(%rbp), %rbx
movq -0x40(%rbp), %r14
jne 0x656b
movq 0x6991(%rip), %rbx      # 0xcfd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6941(%rip), %rbx      # 0xcfd0
leaq 0x2b36(%rip), %rsi      # 0x91cc
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rcx, -0x30(%rbp)
testl %ecx, %ecx
jle 0x6821
movq -0x30(%rbp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, -0x30(%rbp)
xorl %ecx, %ecx
leaq 0x2ad8(%rip), %r15      # 0x91de
leaq 0x2abd(%rip), %r12      # 0x91ca
movq 0x18(%r14), %rax
movq %rcx, -0x38(%rbp)
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %r13
movq 0x18(%rax,%r13), %rax
movq %rax, 0x6a8f(%rip)      # 0xd1b8
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
movq 0x6a78(%rip), %rax      # 0xd1b8
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x2210
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
movq 0x6a51(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x6a45(%rip)      # 0xd1b8
movq 0x18(%r14), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x67e9
movq -0x38(%rbp), %rax
leaq (%rax,%rax,2), %r13
shlq $0x4, %r13
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
movq 0x6a12(%rip), %rax      # 0xd1b8
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x2210
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
movq 0x69eb(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x69df(%rip)      # 0xd1b8
movq 0x18(%r14), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x678f
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq -0x38(%rbp), %rcx
incq %rcx
cmpq -0x30(%rbp), %rcx
jne 0x670d
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18(%rdi), %rax
movq 0x28(%rax), %rax
movslq %eax, %rcx
movq %rcx, -0x30(%rbp)
cmpq %rcx, %rax
jne 0x6a2b
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x6744(%rip), %r14      # 0xcfd0
leaq 0x27a7(%rip), %r15      # 0x903a
movl $0x7, %edx
movq %r14, %rdi
leaq 0x293e(%rip), %rsi      # 0x91e0
callq 0x2210
leaq 0x1(%r12), %rsi
movq %r14, %rdi
movq %rsi, -0x38(%rbp)
callq 0x22d0
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x291e(%rip), %rsi      # 0x91e8
callq 0x2210
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%rbx), %rax
movq %r12, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %r13
movq 0x18(%rax,%r13), %rax
movq %rax, 0x68a6(%rip)      # 0xd1b8
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %r14, %rdi
callq 0x2210
movq 0x688f(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x6883(%rip)      # 0xd1b8
movq 0x18(%rbx), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x6997
leaq (%r12,%r12,2), %r13
shlq $0x4, %r13
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
movq 0x6854(%rip), %rax      # 0xd1b8
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %r14, %rdi
callq 0x2210
movq 0x683d(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x6831(%rip)      # 0xd1b8
movq 0x18(%rbx), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x694d
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movl $0x7, %edx
movq %r14, %rdi
leaq 0x281f(%rip), %rsi      # 0x91ec
callq 0x2210
movq 0x60(%rbx), %rax
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x22d0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%rbx), %rax
movq -0x38(%rbp), %r12
leaq (%r12,%r12,2), %rcx
shlq $0x4, %rcx
movq -0x30(%rbp), %rdx
cmpq %rdx, 0x28(%rax,%rcx)
je 0x6893
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movq 0x60(%rdi), %rax
movq 0x28(%rcx), %r15
movl (%rax), %ebx
movslq %r15d, %rdx
xorl %r13d, %r13d
cmpq %rdx, %r15
jne 0x6a88
addq $0x58, %rcx
xorl %esi, %esi
movl (%rax,%rsi,4), %edi
cmpl %ebx, %edi
cmovll %esi, %r13d
cmovll %edi, %ebx
incq %rsi
leaq 0x30(%rcx), %rdi
cmpq %rdx, (%rcx)
movq %rdi, %rcx
je 0x6a6a
movslq %r13d, %r13
movq 0x6541(%rip), %r12      # 0xcfd0
leaq 0x275e(%rip), %rsi      # 0x91f4
movl $0x4, %edx
movq %r12, %rdi
callq 0x2210
movq %r12, %rdi
movl %r15d, %esi
callq 0x22d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%r14), %rax
leaq (%r13,%r13,2), %r13
shlq $0x4, %r13
leaq (%rax,%r13), %rcx
addq $0x8, %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x66c0(%rip)      # 0xd1b8
cmpq %rcx, %rax
je 0x6b61
movq 0x64cc(%rip), %r15      # 0xcfd0
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %r15, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x6673(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x6667(%rip)      # 0xd1b8
movq 0x18(%r14), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x6b04
movq 0x6468(%rip), %r14      # 0xcfd0
leaq 0x268a(%rip), %rsi      # 0x91f9
movl $0x5, %edx
movq %r14, %rdi
callq 0x2210
movq %r14, %rdi
movl %ebx, %esi
callq 0x22d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movq 0x60(%rdi), %rax
movq 0x28(%rcx), %r12
movl (%rax), %r14d
movslq %r12d, %rdx
xorl %r13d, %r13d
cmpq %rdx, %r12
jne 0x6c12
addq $0x58, %rcx
xorl %esi, %esi
movl (%rax,%rsi,4), %edi
cmpl %r14d, %edi
cmovll %esi, %r13d
cmovll %edi, %r14d
incq %rsi
leaq 0x30(%rcx), %rdi
cmpq %rdx, (%rcx)
movq %rdi, %rcx
je 0x6bf2
movslq %r13d, %r13
leaq 0x25db(%rip), %rsi      # 0x91f4
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
movl %r12d, %esi
callq 0x22d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%r15), %rax
leaq (%r13,%r13,2), %r13
shlq $0x4, %r13
leaq (%rax,%r13), %rcx
addq $0x8, %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x653d(%rip)      # 0xd1b8
cmpq %rcx, %rax
je 0x6cda
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x64f7(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x64eb(%rip)      # 0xd1b8
movq 0x18(%r15), %rcx
addq %r13, %rcx
addq $0x8, %rcx
jmp 0x6c7b
leaq 0x2518(%rip), %rsi      # 0x91f9
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
movl %r14d, %esi
callq 0x22d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day08/ex00/./easyfind.hpp
// Function: int easyfind<std::__cxx11::list<int, std::allocator<int>>>(std::__cxx11::list<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
movq (%rdi), %rax
cmpq %rdi, %rax
je 0x1755
cmpl %esi, 0x10(%rax)
je 0x1755
movq (%rax), %rax
jmp 0x1746
cmpq %rdi, %rax
je 0x175f
movl 0x10(%rax), %eax
popq %rbp
retq
movl $0x8, %edi
callq 0x1090
movq 0x2850(%rip), %rcx      # 0x3fc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x285a(%rip), %rsi      # 0x3fd8
movq 0x286b(%rip), %rdx      # 0x3ff0
movq %rax, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/ssearch_x.c
// Function: main
int
main(int argc, char **argv)
{
    char    *pgm = strrchr(argv[0], '/');
    pgm	= pgm ? pgm + 1 : argv[0];

    while (argc > 1 && !strcmp(argv[1], "-v"))
	++verbose, ++argv;

    if (argc < 2) {
	fprintf(stderr, "Usage: %s [-v [-v]...] <patt_file> [text_file [matches]]\n", pgm);
	return	1;
    }

    MEMBUF  patt = chomp(slurp(argv[1]));
    fprintf(stderr, "# %s: %"FSIZE"d bytes\n", argv[1], patt.len);

    int	    npatts, i;
    MEMREF  *pattv = refsplit(patt.ptr, '\n', &npatts);
    text = argc > 2 && strcmp(argv[1], argv[2]) ? slurp(argv[2]) : patt;
    // text now contains \0's instead of \n's,
    //  but ssearch treats \0 like any other byte.
    int	    matches = argc > 3 ? atoi(argv[3]) : npatts;

    SSEARCH *ssp = ssearch_create(pattv, npatts);
    ssearch_dump(ssp, verbose ? stderr : fopen("/dev/null", "w")); // coverage

    plan_tests(4);
    ok(patt.ptr, "patt_file loaded");
    ok(npatts, "text_file loaded");
    ok(ssp, "ssearch_create returns a value");

    hits = 0;
    double	t = tick();
    (void)ssearch_scan(ssp, bufref(text), (SSEARCH_CB)on_match, pattv);
    t = tick() - t;
    if (!ok(hits == matches, "match count"))
	fprintf(stderr, "# actual: %d expected: %d\n", hits, matches);
    fprintf(stderr, "# elapsed: %G secs\n", t);
    if (verbose)
        for (i = 0; i < 16; ++i)
            if (ssearch_skip[i]) 
                fprintf(stderr, "# skip %2d: %8d\n", i, ssearch_skip[i]);
    ssearch_destroy(ssp);   // coverage
    buffree(patt);
    free(pattv);
    return exit_status();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movl %edi, %ebx
movq (%rsi), %r12
movq %r12, %rdi
movl $0x2f, %esi
callq 0x31b0
leaq 0x1(%rax), %r15
testq %rax, %rax
cmoveq %r12, %r15
cmpl $0x2, %ebx
jl 0x3866
movl 0x6f23(%rip), %r13d     # 0xa758
incl %r13d
leaq 0x37c5(%rip), %r12      # 0x7004
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x3350
testl %eax, %eax
jne 0x3866
addq $0x8, %r14
movl %r13d, 0x6efe(%rip)     # 0xa758
leal 0x1(%r13), %eax
movl %eax, %r13d
cmpl $0x1, %ebx
jg 0x383f
cmpl $0x1, %ebx
jg 0x388d
movq 0x6766(%rip), %rax      # 0x9fd8
movq (%rax), %rdi
leaq 0x378b(%rip), %rsi      # 0x7007
movq %r15, %rdx
xorl %eax, %eax
callq 0x3260
movl $0x1, %eax
jmp 0x38a2
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x3360
movl (%r15), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6eba(%rip)            # 0xa770
cmpl $0x2, 0x6e9b(%rip)      # 0xa758
jge 0x38c5
movl $0x1, %eax
retq
pushq %rax
movq %rsi, %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x364d
addq $0x8, %rsp
jmp 0x38bf
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d0d
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3200
movq 0x18(%rbx), %rdi
callq 0x5417
movq 0x20(%rbx), %rdi
callq 0x3200
movq %rbx, %rdi
popq %rbx
jmp 0x3200
retq
// File: /workspace/github_cpp_makefile_star2_O1/A-deLuna[P]encora-cpp-test/bitwise_add.cpp
// Function: add(int, int)
int add(int a, int b) {
  uint8_t bitCount = sizeof(int) * 8;
  int result = 0;

  uint8_t carry = 0;

  for (uint8_t i = 0; i < bitCount; i++) {
    uint8_t addition = carry + ((a >> i) & 1) + ((b >> i) & 1);
    carry = (addition & 0b10) >> 1;
    result |= ((addition & 1) << i);
  }

  // Overflow is not possible when first bit differs in arguments.
  if ((a >> (bitCount - 1)) != (b >> (bitCount - 1))) {
    return result;
  }

  // Overflow occurs when first bit is different in result and arguments.
  if ((a >> (bitCount - 1)) != (result >> (bitCount - 1))) {
    throw std::overflow_error{"Addition overflow"};
  }

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ecx, %ecx
xorl %eax, %eax
xorl %edx, %edx
xorl %r8d, %r8d
btl %ecx, %edi
setb %r8b
btl %ecx, %esi
adcl %edx, %r8d
movl %r8d, %edx
shrl %edx
andl $0x1, %r8d
shll %cl, %r8d
andl $0x1, %edx
orl %r8d, %eax
incl %ecx
cmpl $0x20, %ecx
jne 0x1346
sarl $0x1f, %edi
sarl $0x1f, %esi
cmpl %esi, %edi
jne 0x1382
movl %eax, %ecx
sarl $0x1f, %ecx
cmpl %ecx, %edi
jne 0x138a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1070
movq %rax, %rbx
leaq 0x1c66(%rip), %rsi      # 0x3004
movq %rax, %rdi
callq 0x1030
movq 0x3c1b(%rip), %rsi      # 0x4fc8
movq 0x3c0c(%rip), %rdx      # 0x4fc0
movq %rbx, %rdi
callq 0x1140
movq %rax, %r14
movq %rbx, %rdi
callq 0x10a0
movq %r14, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O1/yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: root(unsigned int, SummaryGraph&)
unsigned root(unsigned id, SummaryGraph& sGraph){
    SummaryNode* node = sGraph.nodes[id];
    if(node->id != node->belongto){
        node->belongto = root(sGraph.nodes[node->belongto]->id, sGraph);
    }
    return node->belongto;
    // postcondition: root(node).belongto == node
    // node.belongto = root(node)
}

// Assembly:
pushq %rbx
movl %edi, %ecx
movq 0x70(%rsi), %rax
movq (%rax,%rcx,8), %rbx
movl 0x68(%rbx), %ecx
cmpl %ecx, (%rbx)
je 0x25fc
movq (%rax,%rcx,8), %rax
movl (%rax), %edi
callq 0x25dc
movl %eax, 0x68(%rbx)
movl 0x68(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/yuanboli233[P]interdyck_graph_reduce/graphtest.cpp
// Function: findMatch(unsigned int, SummaryGraph&)
void findMatch(unsigned nodeID, SummaryGraph& sGraph){
    SummaryNode* node = sGraph.nodes[nodeID];
    unordered_set<unsigned> usedNodes;
    //usedNodes.insert(nodeID);
    for(vector<NodewithEID>::iterator it = node->outBlueEdgeNodes.begin(); it != node->outBlueEdgeNodes.end(); it++){
        unsigned eid = it->edgeID;
        unsigned nextnid = it->nodeID;
        cout << "Candidate: " << nodeID << " -" << eid << "-> " << nextnid;
        findMatch(nextnid, sGraph, eid, usedNodes, nodeID, nextnid);
        cout << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edi, 0xc(%rsp)
movl %edi, %ecx
movq %rsi, 0x10(%rsp)
movq 0x70(%rsi), %rax
movq %rcx, 0x18(%rsp)
movq (%rax,%rcx,8), %rbp
leaq 0x50(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq 0x50(%rbp), %r14
cmpq 0x58(%rbp), %r14
je 0x291c
movq 0x777a(%rip), %r15      # 0x9fd8
movl (%r14), %r12d
movl 0x4(%r14), %r13d
movl $0xb, %edx
movq %r15, %rdi
leaq 0x47e0(%rip), %rsi      # 0x7054
callq 0x21e0
movq %r15, %rdi
movq 0x18(%rsp), %rsi
callq 0x20e0
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
leaq 0x47c8(%rip), %rsi      # 0x7060
callq 0x21e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x20e0
movq %rax, %rbx
movl $0x3, %edx
movq %rax, %rdi
leaq 0x47a9(%rip), %rsi      # 0x7063
callq 0x21e0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20e0
movl %r12d, %edi
movq 0x10(%rsp), %rsi
movl %r13d, %edx
leaq 0x20(%rsp), %rcx
movl 0xc(%rsp), %r8d
movl %r12d, %r9d
callq 0x2601
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x8, %r14
cmpq 0x58(%rbp), %r14
jne 0x285e
leaq 0x20(%rsp), %rdi
callq 0x3aac
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3aac
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::constructGraph()
void constructGraph(){
        unordered_map<string, unsigned> string2nodeid = readNodes();
        int vtxNum = string2nodeid.size();
        //cout << "Node Number: " << vtxNum << endl;
        nodes.reserve(vtxNum);
        unordered_map<string, unsigned> str2eid = getEdgeIDs();
        eid2origeidstring = getEidToOrig(str2eid);
        eidNum = str2eid.size() + 1;
        for(int i = 0; i < vtxNum; i++){
            nodes.push_back(new SummaryNode(i, str2eid.size()));
        }
        readEdges(string2nodeid, str2eid);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4176
movq 0x18(%r14), %r12
leaq 0x70(%rbx), %r14
movslq %r12d, %rsi
movq %r14, %rdi
callq 0x45f0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4686
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq 0x4894
leaq 0x38(%rbx), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2320
leaq 0x40(%rsp), %rdi
callq 0x3f8c
movl 0x20(%rsp), %eax
incl %eax
movl %eax, 0x230(%rbx)
testl %r12d, %r12d
jle 0x410d
xorl %ebp, %ebp
leaq 0x40(%rsp), %r15
movl $0x70, %edi
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movl %ebp, (%rax)
movl %ebp, 0x68(%rax)
movq %rax, 0x40(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x570c
incl %ebp
cmpl %ebp, %r12d
jne 0x40cc
leaq 0x78(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x4904
leaq 0x8(%rsp), %rdi
callq 0x5964
leaq 0x78(%rsp), %rdi
callq 0x5964
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4156
movq %rax, %rdi
callq 0x3b1b
jmp 0x4156
jmp 0x4151
movq %rax, %rbx
jmp 0x4163
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5964
leaq 0x78(%rsp), %rdi
callq 0x5964
movq %rbx, %rdi
callq 0x22b0
nop