LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x68, %rdi
callq 0x4290
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x68, %rdi
callq 0x42c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0xd61(%rip), %rdx      # 0x3240
callq 0x42f0
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
callq 0x4490
movl %eax, -0x1c(%rbp)
movq 0x15013(%rip), %rdi     # 0x18fd0
leaq 0xd17b(%rip), %rsi      # 0x1113f
callq 0x21d0
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x2330
movq %rax, %rdi
movq 0x14fe2(%rip), %rsi     # 0x18fc0
callq 0x2210
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x4001
cmpl $0x14, -0x20(%rbp)
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x400a
jmp 0x4044
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
movslq -0x20(%rbp), %rsi
callq 0x4580
movq %rax, %rsi
movq 0x14fab(%rip), %rdi     # 0x18fd0
callq 0x21c0
movq %rax, %rdi
movq 0x14f8c(%rip), %rsi     # 0x18fc0
callq 0x2210
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3fea
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x68, %rdi
callq 0x4290
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x68, %rdi
callq 0x42c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0xe55(%rip), %rdx      # 0x3240
callq 0x42f0
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
callq 0x4490
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xd08a(%rip), %rsi      # 0x1113f
callq 0x21d0
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x2330
movq %rax, %rdi
movq 0x14ef1(%rip), %rsi     # 0x18fc0
callq 0x2210
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl -0x24(%rbp), %ecx
movb %al, -0x31(%rbp)
jge 0x40f2
cmpl $0x14, -0x28(%rbp)
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x40fb
jmp 0x413a
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x68, %rdi
movslq -0x28(%rbp), %rsi
callq 0x4580
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
movq 0x14e96(%rip), %rsi     # 0x18fc0
callq 0x2210
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x40db
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xc070
movq -0xa8(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0xb8(%rbp)
callq 0xc090
movq -0xa8(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0xb0(%rbp)
callq 0xc0b0
movq -0xa8(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4140
movq -0x18(%rbp), %rdi
callq 0x4490
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4490
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb03c
leaq -0x40(%rbp), %rdi
callq 0x4160
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xafd8
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x4580
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x20b0
jmp 0xaf0e
movq -0x10(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x4580
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
callq 0x20b0
jmp 0xaf2c
movq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0xb050
movb %al, -0xb9(%rbp)
jmp 0xaf4b
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x68(%rbp), %rdi
callq 0x2120
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0xaf6c
jmp 0xafc8
movq -0x10(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x4580
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x4630
jmp 0xaf87
jmp 0xafc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xb001
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xafbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2120
leaq -0x68(%rbp), %rdi
callq 0x2120
jmp 0xb001
jmp 0xafca
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xaee7
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xc0d0
jmp 0xafea
leaq -0x40(%rbp), %rdi
callq 0x2bc0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xaecb
leaq -0x40(%rbp), %rdi
callq 0x2bc0
movq -0xa0(%rbp), %rdi
callq 0x4180
movq -0xb0(%rbp), %rdi
callq 0x2c20
movq -0xb8(%rbp), %rdi
callq 0xc140
movq -0xa8(%rbp), %rdi
callq 0xc1a0
jmp 0xb045
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2340
nop
// File: 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
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x2140
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xb0e3
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xb0d6
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x2360
movq -0x38(%rbp), %rdi
movsbl (%rax), %eax
movl %eax, -0x44(%rbp)
movslq -0x28(%rbp), %rsi
callq 0x2360
movq %rax, %rcx
movl -0x44(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0xb0d6
movb $0x0, -0x1(%rbp)
jmp 0xb0e7
jmp 0xb0d8
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xb086
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xb1e0
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0xc250
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0xc280
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x3a9(%rip), %rdx      # 0xae00
callq 0xc200
movq -0x38(%rbp), %rdi
callq 0xb250
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc2b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xc2d0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc2b0
movq %rax, %rdi
callq 0xc050
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc050
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jne 0xb39b
movq -0x68(%rbp), %rdi
movl $0x0, -0x14(%rbp)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc4e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0xdf05(%rip)      # 0x191e0
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc3a0
movq %rax, -0x28(%rbp)
leaq 0xdee1(%rip), %rdi      # 0x191e0
leaq -0x28(%rbp), %rsi
callq 0xc510
testb $0x1, %al
jne 0xb30e
jmp 0xb37c
leaq 0xdecb(%rip), %rdi      # 0x191e0
callq 0xc540
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x20b0
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xb790
movl %eax, -0x6c(%rbp)
jmp 0xb33c
movl -0x6c(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2120
leaq 0xde8b(%rip), %rdi      # 0x191e0
xorl %esi, %esi
callq 0xc560
movq %rax, -0x60(%rbp)
jmp 0xb2db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2120
jmp 0xb3a4
movq -0x68(%rbp), %rdi
addq $0x60, %rdi
leaq -0x14(%rbp), %rsi
callq 0x41e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb286
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: 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
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x2150
movq -0x18(%rbp), %rdi
callq 0xc4e0
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rax
movq %rax, 0xdb6e(%rip)      # 0x191e0
movq -0x18(%rbp), %rdi
callq 0xc3a0
movq %rax, -0x1b0(%rbp)
leaq 0xdb57(%rip), %rdi      # 0x191e0
leaq -0x1b0(%rbp), %rsi
callq 0xc510
testb $0x1, %al
jne 0xb69b
jmp 0xb6f6
leaq -0x190(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq 0xdb30(%rip), %rdi      # 0x191e0
callq 0xc540
movq -0x1e8(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
jmp 0xb6c6
jmp 0xb6c8
leaq 0xdb11(%rip), %rdi      # 0x191e0
xorl %esi, %esi
callq 0xc560
movq %rax, -0x1c8(%rbp)
jmp 0xb672
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0xb778
movq -0x1e0(%rbp), %rdi
movb $0x0, -0x1c9(%rbp)
callq 0x22b0
movq -0x1e0(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x2280
jmp 0xb71e
movb $0x1, -0x1c9(%rbp)
testb $0x1, -0x1c9(%rbp)
jne 0xb75c
jmp 0xb750
movq -0x1e0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
callq 0x2120
jmp 0xb778
movq -0x1e0(%rbp), %rdi
callq 0x2120
leaq -0x1a0(%rbp), %rdi
callq 0x2170
movq -0x1d8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x2170
movq -0x1b8(%rbp), %rdi
callq 0x2340
// File: 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
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x2140
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb7f8
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2360
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xb7eb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb7ed
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb7c5
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0xd7a5(%rip), %rdi      # 0x18fd0
leaq 0x5948(%rip), %rsi      # 0x1117a
callq 0x21d0
movq -0x20(%rbp), %rdi
callq 0xc300
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb921
movq 0xd773(%rip), %rdi      # 0x18fd0
leaq 0x5928(%rip), %rsi      # 0x1118c
callq 0x21d0
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
movslq -0x10(%rbp), %rsi
callq 0xc490
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4580
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0xc490
movq %rax, %rdi
callq 0x4490
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb900
movq 0xd710(%rip), %rdi      # 0x18fd0
leaq 0x58c8(%rip), %rsi      # 0x1118f
callq 0x21d0
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
movslq -0x10(%rbp), %rsi
callq 0xc490
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x4580
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb8b1
movq 0xd6c9(%rip), %rdi      # 0x18fd0
leaq 0x5885(%rip), %rsi      # 0x11193
callq 0x21d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb84a
movq 0xd6a8(%rip), %rdi      # 0x18fd0
movq 0xd691(%rip), %rsi      # 0x18fc0
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0xd675(%rip), %rdi      # 0x18fd0
leaq 0x5834(%rip), %rsi      # 0x11196
callq 0x21d0
movq %rax, %rdi
movq 0xd64f(%rip), %rsi      # 0x18fc0
callq 0x2210
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0xc5a0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xbaba
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc4e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0xd81f(%rip)      # 0x191e0
movq 0xd608(%rip), %rdi      # 0x18fd0
leaq 0x57d9(%rip), %rsi      # 0x111a8
callq 0x21d0
movq %rax, -0x40(%rbp)
leaq 0xd801(%rip), %rdi      # 0x191e0
callq 0xc540
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x579a(%rip), %rsi      # 0x11194
callq 0x21d0
leaq 0xd7da(%rip), %rdi      # 0x191e0
xorl %esi, %esi
callq 0xc560
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc3a0
movq %rax, -0x28(%rbp)
leaq 0xd7ab(%rip), %rdi      # 0x191e0
leaq -0x28(%rbp), %rsi
callq 0xc510
testb $0x1, %al
jne 0xba44
jmp 0xba99
movq 0xd585(%rip), %rdi      # 0x18fd0
leaq 0x5756(%rip), %rsi      # 0x111a8
callq 0x21d0
movq %rax, -0x48(%rbp)
leaq 0xd77e(%rip), %rdi      # 0x191e0
callq 0xc540
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x5717(%rip), %rsi      # 0x11194
callq 0x21d0
leaq 0xd757(%rip), %rdi      # 0x191e0
xorl %esi, %esi
callq 0xc560
movq %rax, -0x30(%rbp)
jmp 0xba11
movq 0xd530(%rip), %rdi      # 0x18fd0
movq 0xd519(%rip), %rsi      # 0x18fc0
callq 0x2210
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb98d
movq 0xd50f(%rip), %rdi      # 0x18fd0
movq 0xd4f8(%rip), %rsi      # 0x18fc0
callq 0x2210
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc2b0
movq %rax, %rdi
callq 0xc050
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc050
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbca6
movq 0xd490(%rip), %rdi      # 0x18fd0
leaq 0x5663(%rip), %rsi      # 0x111aa
callq 0x21d0
movq %rax, %rdi
movl -0x10(%rbp), %esi
addl $0x1, %esi
callq 0x2330
movq %rax, %rdi
leaq 0x564e(%rip), %rsi      # 0x111b2
callq 0x21d0
movq %rax, %rdi
movq 0xd44d(%rip), %rsi      # 0x18fc0
callq 0x2210
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc4e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0xd640(%rip)      # 0x191e0
leaq 0xd639(%rip), %rdi      # 0x191e0
callq 0xc540
movq %rax, %rsi
movq 0xd41a(%rip), %rdi      # 0x18fd0
callq 0x21c0
leaq 0xd61e(%rip), %rdi      # 0x191e0
xorl %esi, %esi
callq 0xc560
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc3a0
movq %rax, -0x28(%rbp)
leaq 0xd5ef(%rip), %rdi      # 0x191e0
leaq -0x28(%rbp), %rsi
callq 0xc510
testb $0x1, %al
jne 0xbc00
jmp 0xbc43
movq 0xd3c9(%rip), %rdi      # 0x18fd0
leaq 0x542c(%rip), %rsi      # 0x1103a
callq 0x21d0
movq %rax, -0x40(%rbp)
leaq 0xd5c2(%rip), %rdi      # 0x191e0
callq 0xc540
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
leaq 0xd5aa(%rip), %rdi      # 0x191e0
xorl %esi, %esi
callq 0xc560
movq %rax, -0x30(%rbp)
jmp 0xbbcd
movq 0xd386(%rip), %rdi      # 0x18fd0
movq 0xd36f(%rip), %rsi      # 0x18fc0
callq 0x2210
movq 0xd373(%rip), %rdi      # 0x18fd0
leaq 0x5552(%rip), %rsi      # 0x111b6
callq 0x21d0
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x60, %rdi
movslq -0x10(%rbp), %rsi
callq 0x4810
movq -0x48(%rbp), %rdi
movl (%rax), %esi
callq 0x2330
movq %rax, %rdi
movq 0xd32d(%rip), %rsi      # 0x18fc0
callq 0x2210
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbb13
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc2b0
movq %rax, %rdi
callq 0xc050
movq -0x40(%rbp), %rdi
movl %eax, -0xc(%rbp)
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4810
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
addq $0x18, %rdi
callq 0xc5a0
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc050
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbd73
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4810
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jge 0xbd66
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4810
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xbd68
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbd10
movq 0xd256(%rip), %rdi      # 0x18fd0
leaq 0x543d(%rip), %rsi      # 0x111be
callq 0x21d0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2330
movq %rax, %rdi
movq 0xd225(%rip), %rsi      # 0x18fc0
callq 0x2210
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc4e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, 0xd418(%rip)      # 0x191e0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc3a0
movq %rax, -0x30(%rbp)
leaq 0xd3f4(%rip), %rdi      # 0x191e0
leaq -0x30(%rbp), %rsi
callq 0xc510
testb $0x1, %al
jne 0xbdfb
jmp 0xbe39
leaq 0xd3de(%rip), %rdi      # 0x191e0
callq 0xc540
movq %rax, %rsi
movq 0xd1bf(%rip), %rdi      # 0x18fd0
callq 0x21c0
movq %rax, %rdi
movq 0xd1a0(%rip), %rsi      # 0x18fc0
callq 0x2210
leaq 0xd3b4(%rip), %rdi      # 0x191e0
xorl %esi, %esi
callq 0xc560
movq %rax, -0x38(%rbp)
jmp 0xbdc8
movq 0xd190(%rip), %rdi      # 0x18fd0
leaq 0x537c(%rip), %rsi      # 0x111c3
callq 0x21d0
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x2330
movq %rax, %rdi
movq 0xd15f(%rip), %rsi      # 0x18fc0
callq 0x2210
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc2b0
movq %rax, %rdi
callq 0xc050
movq -0x48(%rbp), %rdi
movl %eax, -0x14(%rbp)
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4810
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
addq $0x18, %rdi
callq 0xc5a0
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movslq -0x24(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc050
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbf37
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
movslq -0x24(%rbp), %rsi
callq 0x4810
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
jge 0xbf2a
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
movslq -0x24(%rbp), %rsi
callq 0x4810
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xbf2c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xbed4
movq -0x10(%rbp), %rdi
leaq 0x527c(%rip), %rsi      # 0x111be
callq 0x21d0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2330
movq %rax, %rdi
movq 0xd064(%rip), %rsi      # 0x18fc0
callq 0x2210
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc4e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0xd257(%rip)      # 0x191e0
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc2b0
movq %rax, %rdi
callq 0xc3a0
movq %rax, -0x38(%rbp)
leaq 0xd233(%rip), %rdi      # 0x191e0
leaq -0x38(%rbp), %rsi
callq 0xc510
testb $0x1, %al
jne 0xbfbc
jmp 0xbfff
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xd215(%rip), %rdi      # 0x191e0
callq 0xc540
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
movq 0xcfda(%rip), %rsi      # 0x18fc0
callq 0x2210
leaq 0xd1ee(%rip), %rdi      # 0x191e0
xorl %esi, %esi
callq 0xc560
movq %rax, -0x40(%rbp)
jmp 0xbf89
movq -0x10(%rbp), %rdi
leaq 0x51b9(%rip), %rsi      # 0x111c3
callq 0x21d0
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x2330
movq %rax, %rdi
movq 0xcf9c(%rip), %rsi      # 0x18fc0
callq 0x2210
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x27b0
movq -0x8(%rbp), %rdi
callq 0x2330
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2180
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0xc(%rbp), %rdx
callq 0x27d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2180
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2820
testb $0x1, %al
jne 0x17ff
jmp 0x1810
leaq -0x18(%rbp), %rdi
callq 0x2790
movl (%rax), %eax
addq $0x40, %rsp
popq %rbp
retq
movl $0x8, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2860
movq -0x40(%rbp), %rdi
movq 0x57a7(%rip), %rsi      # 0x6fd8
movq 0x57b8(%rip), %rdx      # 0x6ff0
callq 0x1120
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl 0x8d37(%rip), %eax      # 0xc790
addl $0x1, %eax
movl %eax, 0x8d2e(%rip)      # 0xc790
cmpl $0x1, 0x8d0f(%rip)      # 0xc778
jle 0x3abb
movq 0x8566(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rax
movq (%rax), %r8
movq -0x10(%rbp), %r9
movq 0x8cd6(%rip), %rax      # 0xc780
subq %rax, %r9
leaq 0x5648(%rip), %rsi      # 0x90fc
movb $0x0, %al
callq 0x3260
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6115
jmp 0x6145
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3200
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6f00
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3200
movq -0x8(%rbp), %rdi
callq 0x3200
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x20, -0xd(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movb $0x0, -0x16(%rbp)
movzbl -0x16(%rbp), %eax
movzbl -0xd(%rbp), %ecx
cmpl %ecx, %eax
jge 0x23ed
movzbl -0x15(%rbp), %eax
movl -0x8(%rbp), %edx
movzbl -0x16(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
addl %ecx, %eax
movl -0xc(%rbp), %edx
movzbl -0x16(%rbp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
addl %ecx, %eax
movb %al, -0x17(%rbp)
movzbl -0x17(%rbp), %eax
andl $0x2, %eax
sarl %eax
movb %al, -0x15(%rbp)
movzbl -0x17(%rbp), %eax
andl $0x1, %eax
movzbl -0x16(%rbp), %ecx
shll %cl, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movb -0x16(%rbp), %al
addb $0x1, %al
movb %al, -0x16(%rbp)
jmp 0x2391
movl -0x8(%rbp), %eax
movzbl -0xd(%rbp), %ecx
subl $0x1, %ecx
sarl %cl, %eax
movl -0xc(%rbp), %edx
movzbl -0xd(%rbp), %ecx
subl $0x1, %ecx
sarl %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
je 0x2413
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2487
movl -0x8(%rbp), %eax
movzbl -0xd(%rbp), %ecx
subl $0x1, %ecx
sarl %cl, %eax
movl -0x14(%rbp), %edx
movzbl -0xd(%rbp), %ecx
subl $0x1, %ecx
sarl %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
je 0x2481
movl $0x10, %edi
callq 0x2080
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x5bb8(%rip), %rsi      # 0x8004
callq 0x2030
jmp 0x2453
movq -0x30(%rbp), %rdi
movq 0xab62(%rip), %rsi      # 0xcfc0
movq 0xab53(%rip), %rdx      # 0xcfb8
callq 0x2170
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20b0
jmp 0x2490
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2190
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movl -0x4(%rbp), %eax
movl %eax, %esi
callq 0x4e30
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x68(%rcx), %eax
je 0x3624
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movq -0x18(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, %esi
callq 0x4e30
movq (%rax), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x35c0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x18(%rbp), %rax
movl 0x68(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movl -0x4(%rbp), %eax
movl %eax, %esi
callq 0x4e30
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5100
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x4fd0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x5040
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5000
testb $0x1, %al
jne 0x392c
jmp 0x3a47
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5070
movq -0x90(%rbp), %rdi
movl 0x4(%rax), %eax
movl %eax, -0x64(%rbp)
callq 0x5070
movl (%rax), %eax
movl %eax, -0x68(%rbp)
movq 0x1a67e(%rip), %rdi     # 0x1dfd8
leaq 0xf6db(%rip), %rsi      # 0x1303c
callq 0x3200
movq %rax, -0x88(%rbp)
jmp 0x396f
movq -0x88(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x3300
movq %rax, -0x98(%rbp)
jmp 0x3987
movq -0x98(%rbp), %rdi
leaq 0xf6b3(%rip), %rsi      # 0x13048
callq 0x3200
movq %rax, -0xa0(%rbp)
jmp 0x39a3
movq -0xa0(%rbp), %rdi
movl -0x64(%rbp), %esi
callq 0x3300
movq %rax, -0xa8(%rbp)
jmp 0x39bb
movq -0xa8(%rbp), %rdi
leaq 0xf682(%rip), %rsi      # 0x1304b
callq 0x3200
movq %rax, -0xb0(%rbp)
jmp 0x39d7
movq -0xb0(%rbp), %rdi
movl -0x68(%rbp), %esi
callq 0x3300
jmp 0x39e8
movl -0x68(%rbp), %r9d
movq -0x10(%rbp), %rsi
movl -0x64(%rbp), %edx
movl -0x4(%rbp), %r8d
leaq -0x50(%rbp), %rcx
movl %r9d, %edi
callq 0x3640
jmp 0x3a05
movq 0x1a5cc(%rip), %rdi     # 0x1dfd8
movq 0x1a5ad(%rip), %rsi     # 0x1dfc0
callq 0x3240
jmp 0x3a1a
jmp 0x3a1c
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x5090
movq %rax, -0x80(%rbp)
jmp 0x3905
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5120
jmp 0x3a59
leaq -0x50(%rbp), %rdi
callq 0x5120
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x8d60
movq -0xe8(%rbp), %rdi
callq 0x9280
movq -0xe0(%rbp), %rdi
movl %eax, -0x44(%rbp)
addq $0x70, %rdi
movslq -0x44(%rbp), %rsi
callq 0x92a0
jmp 0x883f
movq -0xe0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x93a0
jmp 0x8854
movq -0xe0(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x9640
jmp 0x8870
movq -0xe0(%rbp), %rdi
addq $0x38, %rdi
leaq -0xc8(%rbp), %rsi
callq 0x9730
leaq -0xc8(%rbp), %rdi
callq 0x52d0
leaq -0x90(%rbp), %rdi
callq 0x9280
movq %rax, %rcx
movq -0xe0(%rbp), %rax
addq $0x1, %rcx
movl %ecx, 0x230(%rax)
movl $0x0, -0xcc(%rbp)
movl -0xcc(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x8993
movq -0xe0(%rbp), %rax
addq $0x70, %rax
movq %rax, -0xf8(%rbp)
movl $0x70, %edi
callq 0x3210
movq %rax, -0xf0(%rbp)
jmp 0x88f1
movl -0xcc(%rbp), %eax
movl %eax, -0xfc(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x9280
movq -0xf0(%rbp), %rdi
movl -0xfc(%rbp), %esi
movl %eax, %edx
callq 0x9790
jmp 0x891f
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xd8(%rbp), %rsi
callq 0x9760
jmp 0x8942
jmp 0x8944
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
jmp 0x88bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x89d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x89ca
movq -0xf0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x70, %esi
callq 0x3220
jmp 0x89ca
movq -0xe0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x97f0
jmp 0x89ac
leaq -0x90(%rbp), %rdi
callq 0x9d50
leaq -0x40(%rbp), %rdi
callq 0x9d50
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x90(%rbp), %rdi
callq 0x9d50
leaq -0x40(%rbp), %rdi
callq 0x9d50
movq -0x50(%rbp), %rdi
callq 0x3390
nopl (%rax,%rax)
// File: yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::getEidToOrig(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, unsigned int>>>&)
unordered_map<unsigned, string> getEidToOrig(unordered_map<string, unsigned>& str2eid){
        unordered_map<unsigned, string> result;
        for(unordered_map<string, unsigned>::iterator it = str2eid.begin(); it != str2eid.end(); it++){
            result[it->second] = it->first;
        }
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x87b0
movq -0x18(%rbp), %rdi
callq 0xbd40
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa070
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbd70
testb $0x1, %al
jne 0x9695
jmp 0x96fe
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xac90
movq -0x70(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0xac90
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x52a0
movq %rax, -0x60(%rbp)
jmp 0x96c5
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x3030
jmp 0x96d4
jmp 0x96d6
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xbda0
movq %rax, -0x48(%rbp)
jmp 0x9675
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x52d0
jmp 0x971b
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x9711
movq -0x58(%rbp), %rdi
callq 0x52d0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
nop
// File: yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::isEdge(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool isEdge(const string& line) {
        if(line.find("->") == string::npos) 
            return false; 
        else 
            return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x92a4(%rip), %rsi      # 0x1304f
xorl %eax, %eax
movl %eax, %edx
callq 0x33f0
cmpq $-0x1, %rax
jne 0x9dc0
movb $0x0, -0x1(%rbp)
jmp 0x9dc4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::getNodePair(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
pair<string, string> getNodePair(string line){
        string delimiter = "->";
        string str = line.substr(0, line.find_first_of("["));
        string::size_type delimiterstart = str.find_first_of(delimiter);
        string from, to;
        from = str.substr(0, delimiterstart);
        to = str.substr(delimiterstart + delimiter.size());
        return make_pair(from, to);

    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdx, -0x118(%rbp)
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x33a0
movq -0x100(%rbp), %rdx
leaq 0x9232(%rip), %rsi      # 0x1304f
leaq -0x38(%rbp), %rdi
callq 0x4e50
jmp 0x9e28
leaq -0x39(%rbp), %rdi
callq 0x3260
movq -0x118(%rbp), %rdi
leaq 0x9256(%rip), %rsi      # 0x13095
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x120(%rbp)
callq 0x3110
movq -0x118(%rbp), %rsi
movq -0x120(%rbp), %rdx
movq %rax, %rcx
leaq -0x70(%rbp), %rdi
callq 0x3230
jmp 0x9e6b
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x128(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x130(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x31e0
movq %rax, -0x78(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3310
leaq -0xb8(%rbp), %rdi
callq 0x3310
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0xd8(%rbp), %rdi
callq 0x3230
jmp 0x9ec6
leaq -0x98(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
movq %rsi, -0x140(%rbp)
callq 0x32b0
movq -0x140(%rbp), %rdi
callq 0x3408
movq -0x78(%rbp), %rax
movq %rax, -0x138(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3150
movq -0x138(%rbp), %rdx
addq %rax, %rdx
leaq -0xf8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq $-0x1, %rcx
callq 0x3230
jmp 0x9f23
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x148(%rbp)
leaq -0xf8(%rbp), %rsi
movq %rsi, -0x150(%rbp)
callq 0x32b0
movq -0x150(%rbp), %rdi
callq 0x3408
movq -0x110(%rbp), %rdi
movq -0x148(%rbp), %rdx
leaq -0x98(%rbp), %rsi
callq 0xa270
jmp 0x9f6c
leaq -0xb8(%rbp), %rdi
callq 0x3408
leaq -0x98(%rbp), %rdi
callq 0x3408
leaq -0x70(%rbp), %rdi
callq 0x3408
leaq -0x38(%rbp), %rdi
callq 0x3408
movq -0x108(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x3260
jmp 0xa001
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x9ff8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x3408
leaq -0x98(%rbp), %rdi
callq 0x3408
leaq -0x70(%rbp), %rdi
callq 0x3408
leaq -0x38(%rbp), %rdi
callq 0x3408
movq -0x48(%rbp), %rdi
callq 0x3390
nopw (%rax,%rax)
// File: yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::getEdgeLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string getEdgeLabel(const string& l){
        size_t b, e; 
        b = l.find_first_of("\"");
        e = l.find_last_of("\"");
        
        return l.substr(b+1, (e-b-1));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x73bd(%rip), %rsi      # 0x130a7
xorl %eax, %eax
movl %eax, %edx
callq 0x3110
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x73a5(%rip), %rsi      # 0x130a7
movq $-0x1, %rdx
callq 0x31f0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
movq -0x28(%rbp), %rcx
subq -0x20(%rbp), %rcx
subq $0x1, %rcx
callq 0x3230
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::insertBracketEdge(unsigned int, unsigned int, unsigned int)
void insertBracketEdge(unsigned fid, unsigned tid, unsigned eid){
        //cout << "Edge: " << fid << " to " << tid << " color: red.\n";
        NodewithEID eidToNode(tid, eid);
        NodewithEID eidFromNode(fid, eid);
        nodes[fid]->outRedEdgeNodes.push_back(eidToNode);
        nodes[tid]->inRedEdgeNodes.push_back(eidFromNode);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x1c(%rbp), %rdi
callq 0x5140
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x24(%rbp), %rdi
callq 0x5140
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4e30
movq (%rax), %rdi
addq $0x20, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x5160
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x4e30
movq (%rax), %rdi
addq $0x8, %rdi
leaq -0x24(%rbp), %rsi
callq 0x5160
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: cesarblum[P]propertypp/test.cpp
// Function: Test::Test()
Test::Test()
{
    PROPERTYPP_INIT(b);
    PROPERTYPP_INIT(n);
    PROPERTYPP_INIT(m);
    PROPERTYPP_INIT(d);
    PROPERTYPP_INIT(o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x3d80
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3da0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x3dc0
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x3de0
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x3e00
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
callq 0x3e20
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
callq 0x3ea0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
callq 0x3f20
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
callq 0x3fa0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
callq 0x4020
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cesarblum[P]propertypp/test.cpp
// Function: Test::Test(Test const&)
Test::Test(const Test& rhs)
{
    PROPERTYPP_COPY(b, rhs);
    PROPERTYPP_COPY(n, rhs);
    PROPERTYPP_COPY(m, rhs);
    PROPERTYPP_COPY(d, rhs);
    PROPERTYPP_COPY(o, rhs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x3d80
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x3da0
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x3dc0
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x3de0
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x3e00
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %rsi, %rdi
callq 0x40a0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %rsi, %rdi
callq 0x40e0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %rsi, %rdi
callq 0x4120
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %rsi, %rdi
callq 0x4160
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq %rsi, %rdi
callq 0x41a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)