LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/lindorx[P]train/HelpInsPro.cpp
// Function: Num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int)
std::vector<unsigned char>Num(const std::string& str, int num, int a)
{
	using namespace std;
	vector<unsigned char>data;
	int i, sum = 0, n = str.size();
	int w = IntNum(str, a);
	if (!(w < 0)){ return NumToUc(w, num); }
	else if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')){
		for (i = 2; i < n; ++i){
			sum += (int)pow(16.0, (double)(n - 1 - i))*HexOct(str[i]);
		}
		return NumToUc(sum, num);
	}
	else if (IsHexNum(str)){
		//�������ַ���ת��Ϊ�ɹ������ĸ�ʽ
		for (i = 0; i < n; ++i){
			sum += (int)pow(10.0, (double)(n - i - 1))*HexOct(str[i]);
		}
		return NumToUc(sum, num);
		//cout << "Numת����������ȷ��Ϊ�Ĵ����ĸ�ֵ��ȷ��error-004!" << endl;
		//�����Ǳ����ַ���,����data�Ĵ�СΪ0
	}
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq %rsi, %rdi
movl %ecx, %esi
callq 0x460a
testl %eax, %eax
js 0x493b
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x4a34
movq (%r15), %rax
cmpb $0x30, (%rax)
jne 0x49b6
movzbl 0x1(%rax), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x49b6
xorl %r12d, %r12d
cmpl $0x3, %r14d
jl 0x4a2e
movl %r13d, -0x2c(%rbp)
movq %rbx, -0x38(%rbp)
movl %r14d, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
addl $-0x3, %r14d
movl $0x2, %ebx
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0xc771(%rip), %xmm0     # 0x110f8
callq 0x21a0
movsd %xmm0, -0x40(%rbp)
movq (%r15), %rax
movsbl (%rax,%rbx), %edi
callq 0x4489
cvttsd2si -0x40(%rbp), %ecx
cwtl
imull %ecx, %eax
addl %eax, %r12d
incq %rbx
decl %r14d
cmpq %rbx, %r13
jne 0x4977
jmp 0x4a23
movq %r15, %rdi
callq 0x44d5
testb %al, %al
je 0x4a4e
xorl %r12d, %r12d
testl %r14d, %r14d
jle 0x4a2e
movl %r13d, -0x2c(%rbp)
movq %rbx, -0x38(%rbp)
movl %r14d, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
leal -0x1(%r14), %ebx
xorl %r14d, %r14d
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
movsd 0xc70a(%rip), %xmm0     # 0x11100
callq 0x22f0
movsd %xmm0, -0x40(%rbp)
movq (%r15), %rax
movsbl (%rax,%r14), %edi
callq 0x4489
cvttsd2si -0x40(%rbp), %ecx
cwtl
imull %ecx, %eax
addl %eax, %r12d
incq %r14
decl %ebx
cmpq %r14, %r13
jne 0x49e7
movslq %r12d, %r12
movq -0x38(%rbp), %rbx
movl -0x2c(%rbp), %r13d
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x4534
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x4a3c
// File: /workspace/github_cpp_makefile_star2_O1/lindorx[P]train/InsPro.cpp
// Function: MOVE(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int)
std::vector<unsigned char>MOVE(const std::string& str, int k, int num)
{
	using namespace std;
	int str_size = str.size();
	string *ch;//ch1��ch2�ֱ��������涺��ǰ�����ַ�����DEST �� SRC��
	//�����ո�
	while (k < str_size && (str[k] == 0x20 || str[k] == '\t'))k++;
	ch = CS(str, k);//���涺��ǰ�������ַ���
	STRINF *m1 = hep(ch[0]);
	STRINF *m2 = hep(ch[1]);
	
	if (!m1->w && !m2->w){
		//û������ʱ����Move1����Ҫ��һЩ������������
		if ((m1->explain == "byte" || m1->explain == "BYTE") && (m2->explain == "word" || m2->explain == "WORD"))cout << "���棬����ʹ��word�����򽫶�����������,���������룺" << str << endl;
		return Move1(m1, m2, num);
	}//������ʱ����Move2
	return Move2(str, m1, m2, num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpl %edx, %eax
jle 0xa45c
movslq %edx, %rcx
addq (%r15), %rcx
movzbl (%rcx), %esi
cmpl $0x20, %esi
je 0xa451
cmpl $0x9, %esi
jne 0xa45c
incl %edx
incq %rcx
cmpl %edx, %eax
jne 0xa444
movl %eax, %edx
movq %r15, %rdi
movl %edx, %esi
callq 0x3c1e
movq %rax, %r13
movq %rax, %rdi
callq 0x641b
movq %rax, %r12
addq $0x20, %r13
movq %r13, %rdi
callq 0x641b
movq %rax, %r13
cmpb $0x0, 0x40(%r12)
jne 0xa492
cmpb $0x0, 0x40(%r13)
je 0xa4ab
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %r14d, %r8d
callq 0x707e
jmp 0xa55d
leaq 0x7187(%rip), %rsi      # 0x11639
movq %r12, %rdi
callq 0x20a0
testl %eax, %eax
je 0xa4d1
leaq 0x6cfe(%rip), %rsi      # 0x111c3
movq %r12, %rdi
callq 0x20a0
testl %eax, %eax
jne 0xa54c
leaq 0x6d26(%rip), %rsi      # 0x111fe
movq %r13, %rdi
callq 0x20a0
testl %eax, %eax
je 0xa4f7
leaq 0x6d18(%rip), %rsi      # 0x11203
movq %r13, %rdi
callq 0x20a0
testl %eax, %eax
jne 0xa54c
movq 0xaada(%rip), %rdi      # 0x14fd8
leaq 0x6f3f(%rip), %rsi      # 0x11444
movl $0x33, %edx
callq 0x2210
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0xaabb(%rip), %rdi      # 0x14fd8
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2130
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %r14d, %ecx
callq 0x6c48
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/lindorx[P]train/InsPro.cpp
// Function: Int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, int)
std::vector<unsigned char>Int(std::string& str,int n,int num)
{
	using namespace std;
	vector<unsigned char>data;
	vector<unsigned char>d;
	data.push_back(0xcd);
	str = CutStr(str, n);
	d = Num(str, 1, num);
	data.push_back(d[0]);
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r14d
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x40(%rbp), %rsi
movb $-0x33, (%rsi)
callq 0x67f0
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x3b1c
leaq -0x40(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
movq (%r12), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0xbd8f
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movl $0x1, %edx
movl %r14d, %ecx
callq 0x48ff
movq -0x40(%rbp), %r14
movq -0x30(%rbp), %r12
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xbdc0
movb (%r14), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0xbdcb
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6920
testq %r14, %r14
je 0xbdde
subq %r14, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0xbe00
jmp 0xbdf7
jmp 0xbdf7
movq %rax, %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
testq %r14, %r14
je 0xbe13
subq %r14, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbe27
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/lindorx[P]train/main.cpp
// Function: FileOut()
void FileOut(void)
{
	using namespace std;
	std::ofstream fout(fout_src, std::ios::binary);
	if (!fout.is_open())cout << endl << "�ļ�д��ʧ��!" << endl;
	for (int i = 0; i < (int)Data.size(); i++) {
		fout.put(Data[i]);
	}
	fout.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
leaq 0x6758(%rip), %rsi      # 0x16038
leaq -0x210(%rbp), %rdi
movl $0x4, %edx
callq 0x2340
leaq -0x1a0(%rbp), %rdi
callq 0x2060
testb %al, %al
jne 0xf96e
movq 0x56d0(%rip), %rdi      # 0x14fd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq 0x56b5(%rip), %rdi      # 0x14fd8
callq 0x2040
movq %rax, %rdi
callq 0x2130
movq %rax, %rbx
leaq 0x1e80(%rip), %rsi      # 0x117ba
movl $0xd, %edx
movq %rax, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2130
movl 0x6694(%rip), %ecx      # 0x16008
movq 0x6685(%rip), %rax      # 0x16000
subl %eax, %ecx
testl %ecx, %ecx
jle 0xf9b2
xorl %r14d, %r14d
leaq -0x210(%rbp), %rbx
movsbl (%rax,%r14), %esi
movq %rbx, %rdi
callq 0x2040
incq %r14
movl 0x6667(%rip), %ecx      # 0x16008
movq 0x6658(%rip), %rax      # 0x16000
subl %eax, %ecx
movslq %ecx, %rcx
cmpq %rcx, %r14
jl 0xf98b
leaq -0x210(%rbp), %rdi
callq 0x2260
movq 0x560b(%rip), %rax      # 0x14fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x2170
leaq -0x118(%rbp), %rdi
callq 0x20b0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xfa02
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x2280
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/lindorx[P]train/main.cpp
// Function: CutStrCode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
std::string CutStrCode(const std::string& str, int num = 0)//�ж��Ƿ����б��ţ�û���򷵻�ָ���ַ���
{
	using namespace std;
	std::string m;
	//��ȥ��ͷ���ֿ��ܴ��ڵ��޹��ַ���0x20Ϊ�ո�
	while (num < (int)str.size()) {
		if (str[num] != 0x20 && str[num] != '\t' && str[num] != ',')break;
		num++;
	}
	//��ȡ�ַ���
	while (num < (int)str.size() && (isalnum(str[num]) || str[num] == '$' || str[num] == ':' || str[num] == '_')) {
		if (str[num] == ':') {
			is_Title = true;
			break;
		}
		m.push_back(str[num]); num++;
	}
	return m;
}

// 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), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x8(%rsi), %eax
cmpl %edx, %eax
jle 0xfa75
movslq %edx, %rcx
addq (%r14), %rcx
movabsq $0x100100000200, %rsi   # imm = 0x100100000200
movzbl (%rcx), %edi
cmpq $0x2c, %rdi
ja 0xfa75
btq %rdi, %rsi
jae 0xfa75
incl %edx
incq %rcx
cmpl %edx, %eax
jne 0xfa5b
movl %eax, %edx
cmpl 0x8(%r14), %edx
jge 0xfad1
movslq %edx, %r13
movq (%r14), %rax
movsbl (%rax,%r13), %r15d
movzbl %r15b, %r12d
movl %r15d, %edi
callq 0x21e0
testl %eax, %eax
je 0xfa9e
cmpl $0x3a, %r12d
jne 0xfaaa
jmp 0xfaca
cmpl $0x24, %r12d
je 0xfaaa
cmpl $0x5f, %r12d
jne 0xfac4
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x2180
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0xfa7e
jmp 0xfad1
cmpl $0x3a, %r12d
jne 0xfad1
movb $0x1, 0x6657(%rip)      # 0x16128
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0xfafe
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/lindorx[P]train/main.cpp
// Function: DataChar(int, unsigned char)
void DataChar(int n, unsigned char ch)
{
	using namespace std;
	if (n > 0) {
		Data.insert(Data.end(), n, ch);
		FileSize += n;
		Number += n;
	}
	else if (n < 0) {
		cout << "����-027����������resbָ��������������������С��0" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb %sil, -0x9(%rbp)
testl %edi, %edi
jle 0xfb78
movl %edi, %ebx
movq 0x64b0(%rip), %rsi      # 0x16008
leaq 0x64a1(%rip), %rdi      # 0x16000
movl %ebx, %edx
leaq -0x9(%rbp), %rcx
callq 0xd428
addl %ebx, 0x6484(%rip)      # 0x15ff4
addl %ebx, 0x6482(%rip)      # 0x15ff8
jmp 0xfb7a
js 0xfb81
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x5450(%rip), %rbx      # 0x14fd8
leaq 0x1c39(%rip), %rsi      # 0x117c8
movl $0x31, %edx
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/threads/part1/Hello1.cpp
// Function: main
int main(){
    std::vector<std::thread> threads;

    for(int i = 0; i < 5; ++i){
        threads.push_back(std::thread(hello));
    }

    for(auto& thread : threads){
        thread.join();
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
vmovaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x5, %ebp
leaq -0xa1(%rip), %r14       # 0x128c
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x13ae
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1472
cmpq $0x0, 0x8(%rsp)
jne 0x13a9
decl %ebp
jne 0x1332
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x1371
movq %rbx, %rdi
callq 0x1130
addq $0x8, %rbx
jmp 0x135e
leaq 0x10(%rsp), %rdi
callq 0x1428
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1394
jmp 0x1394
cmpq $0x0, 0x8(%rsp)
jne 0x13a9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1428
movq %rbx, %rdi
callq 0x1140
callq 0x1040
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::Init()
void AllMaximalSetsLexicographic::Init() {
  maximal_sets_count_ = input_sets_count_ = canidate_seek_count_ = 0;
  std::cerr << "; Finding all maximal itemsets.\n"
            << "; Limit on number of items in main memory: "
            << max_items_in_ram_ << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x5912(%rip), %r14      # 0x7ff0
leaq 0x2979(%rip), %rsi      # 0x505e
movl $0x20, %edx
movq %r14, %rdi
callq 0x21e0
leaq 0x2986(%rip), %rsi      # 0x507f
movl $0x2b, %edx
movq %r14, %rdi
callq 0x21e0
movl 0x54(%rbx), %esi
movq %r14, %rdi
callq 0x20f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::ReadNextChunk(google_extremal_sets::DataSourceIterator*, long*)
bool AllMaximalSetsLexicographic::ReadNextChunk(
    DataSourceIterator* data, off_t* resume_offset) {
  *resume_offset = 0;
  items_in_ram_ = 0;
  ItemSet current_set;
  uint32_t set_id;
  bool result;
  while ((result = data->Next(&set_id, &current_set)) > 0) {
    candidates_.push_back(SetProperties::Create(set_id, current_set));
    items_in_ram_ += current_set.size();
    ++input_sets_count_;
    // Check if we've exceeded the RAM limit and if so stop
    // retaining any further itemsets in memory until the next
    // scan.
    if (items_in_ram_ >= max_items_in_ram_) {
      *resume_offset = data->Tell();
      std::cerr << "; Halted scan at input set number "
                << input_sets_count_ << " with id " << set_id << std::endl;
      return true;
    }
  }  // while ((result = data->Next() ...
  return result == 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movq %rdx, 0x28(%rsp)
movq %rax, (%rdx)
movl $0x0, 0x50(%rdi)
leaq 0x10(%rsp), %r12
movq %rax, 0x10(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
leaq 0x18(%rdi), %r13
leaq 0xc(%rsp), %rbp
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x3b20
testl %eax, %eax
sete %r14b
je 0x28cb
movl 0xc(%rsp), %edi
movq %r12, %rsi
callq 0x45d8
movq %rax, 0x30(%rsp)
movq %r13, %rdi
leaq 0x30(%rsp), %rsi
callq 0x3100
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
shrq $0x2, %rax
addl 0x50(%rbx), %eax
movl %eax, 0x50(%rbx)
incq 0x8(%rbx)
cmpl 0x54(%rbx), %eax
jb 0x27ee
movq %r15, %rdi
callq 0x3b18
movq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movq 0x5796(%rip), %rdi      # 0x7ff0
leaq 0x2872(%rip), %rsi      # 0x50d3
movl $0x22, %edx
callq 0x21e0
movq 0x8(%rbx), %rsi
movq 0x577a(%rip), %rdi      # 0x7ff0
callq 0x2170
movq %rax, %rbx
leaq 0x2871(%rip), %rsi      # 0x50f6
movl $0x9, %edx
movq %rax, %rdi
callq 0x21e0
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movb $0x1, %r14b
movq %rax, %rdi
callq 0x2100
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x28e2
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28f8
jmp 0x28f8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2912
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::DeleteTriviallySubsumedCandidates()
void AllMaximalSetsLexicographic::DeleteTriviallySubsumedCandidates() {
  // Now iterate over the current chunk backwards and delete
  // itemsets that are tivially subsumed based on prefix comparison.
  std::cerr << "; Deleting trivially subsumed itemsets..." << std::endl;
  assert(candidates_.size());
  SetProperties* not_a_prefix_itemset = candidates_.back();
  for (int i = candidates_.size() - 2; i >= 0; --i) {
    SetProperties* candidate = candidates_[i];
    bool subsumed = false;
    if (candidate->size < not_a_prefix_itemset->size) {
      subsumed = true;
      for (unsigned int j = 0; j < candidate->size; ++j) {
        if (candidate->item[j] != not_a_prefix_itemset->item[j]) {
          subsumed = false;
          break;
        }
      }
    }
    if (subsumed) {
      items_in_ram_ -= candidate->size;
      SetProperties::Delete(candidate);
      candidates_[i] = 0;
    } else {
      not_a_prefix_itemset = candidate;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x56c7(%rip), %r14      # 0x7ff0
leaq 0x27d0(%rip), %rsi      # 0x5100
movl $0x29, %edx
movq %r14, %rdi
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x20(%rbx), %rax
movq %rax, %rcx
subq 0x18(%rbx), %rcx
je 0x29d6
shrq $0x3, %rcx
addl $-0x2, %ecx
js 0x29d0
movq -0x8(%rax), %r15
movl %ecx, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
movl 0x4(%rdi), %eax
cmpl 0x4(%r15), %eax
jae 0x29c1
testq %rax, %rax
je 0x29ab
xorl %ecx, %ecx
movl 0x8(%rdi,%rcx,4), %edx
cmpl 0x8(%r15,%rcx,4), %edx
jne 0x29c1
incq %rcx
cmpl %ecx, %eax
jne 0x2999
subl %eax, 0x50(%rbx)
callq 0x461c
movq 0x18(%rbx), %rax
movq $0x0, (%rax,%r14,8)
jmp 0x29c4
movq %rdi, %r15
leaq -0x1(%r14), %rax
testq %r14, %r14
movq %rax, %r14
jg 0x2981
popq %rbx
popq %r14
popq %r15
retq
leaq 0x274d(%rip), %rdi      # 0x512a
leaq 0x2759(%rip), %rsi      # 0x513d
leaq 0x2774(%rip), %rcx      # 0x515f
movl $0xa6, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::BuildIndex()
void AllMaximalSetsLexicographic::BuildIndex() {
  // Finally, we compress out the blanks, identify blocks of candidates that
  // start with the same item id, and build the index.
  std::cerr << "; Building index..." << std::endl;
  int blanks = 0;
  index_.resize(candidates_.back()->item[0] + 1);
  int begin_candidate_index = -1;
  SetProperties* begin_candidate = 0;  // candidate at the beginning of a block.
  uint32_t previous_item = 0;
  for (size_t i = 0; i < candidates_.size(); ++i) {
    SetProperties* candidate = candidates_[i];
    if (!candidate) {
      blanks++;
    } else {
      candidates_[i - blanks] = candidate;
      if (!begin_candidate) {
        begin_candidate = candidate;
        begin_candidate_index = i - blanks;
      } else if (candidate->item[0] != begin_candidate->item[0]) {
        // We've started a new block. Update the index with
        // the stats from the previous block.
        for (uint32_t item = previous_item + 1; item <= begin_candidate->item[0]; ++item) {
          index_[item] = begin_candidate_index;
        }
        previous_item = begin_candidate->item[0];
        begin_candidate = candidate;
        begin_candidate_index = i - blanks;
      }
    }
  }  // for()
  // Finish processing the final block.
  for (uint32_t item = previous_item + 1; item <= begin_candidate->item[0]; ++item) {
    index_[item] = begin_candidate_index;
  }
  candidates_.resize(candidates_.size() - blanks);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x55eb(%rip), %r14      # 0x7ff0
leaq 0x27af(%rip), %rsi      # 0x51bb
movl $0x13, %edx
movq %r14, %rdi
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x30(%rbx), %r15
leaq 0x18(%rbx), %r14
movq 0x20(%rbx), %rax
movq -0x8(%rax), %rax
movl 0x8(%rax), %esi
incl %esi
movq %r15, %rdi
callq 0x2f98
movq 0x18(%rbx), %r9
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq (%r9,%rdx,8), %rsi
testq %rsi, %rsi
je 0x2aba
movslq %eax, %r11
movq %rdx, %r10
subq %r11, %r10
movq %rsi, (%r9,%r10,8)
testq %r8, %r8
je 0x2abe
movl 0x8(%r8), %r9d
cmpl %r9d, 0x8(%rsi)
je 0x2ac4
incl %ecx
cmpl %r9d, %ecx
ja 0x2aaf
movslq %edi, %rdi
movq (%r15), %r8
movl %ecx, %r11d
movq %rdi, (%r8,%r11,8)
incl %ecx
cmpl %r9d, %ecx
jbe 0x2aa1
movl %r10d, %edi
movq %rsi, %r8
movl %r9d, %ecx
jmp 0x2ac4
incl %eax
jmp 0x2ac4
movl %r10d, %edi
movq %rsi, %r8
incq %rdx
movq 0x18(%rbx), %r9
movq 0x20(%rbx), %rsi
subq %r9, %rsi
sarq $0x3, %rsi
cmpq %rsi, %rdx
jb 0x2a6f
movl 0x8(%r8), %edx
incl %ecx
cmpl %edx, %ecx
ja 0x2af8
movslq %edi, %rdi
movq (%r15), %r8
movl %ecx, %r9d
movq %rdi, (%r8,%r9,8)
incl %ecx
cmpl %edx, %ecx
jbe 0x2aeb
cltq
subq %rax, %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2fca
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::DeleteSubsumedCandidates(unsigned int)
void AllMaximalSetsLexicographic::DeleteSubsumedCandidates(unsigned int current_set_index) {
  current_set_ = candidates_[current_set_index];
  assert(current_set_);
  if (current_set_->size <= 1)
    return;

  const uint32_t* current_set_it = current_set_->begin();
  // The first candidate_set we consider is the first set following
  // current_set in the ordering, if one exists.
  CandidateList::iterator begin_range_it =
      candidates_.begin() + current_set_index + 1;
  DeleteSubsumedFromRange(begin_range_it, candidates_.end(), current_set_it, 0);
}

// Assembly:
movl %esi, %eax
movq 0x18(%rdi), %rdx
movq (%rdx,%rax,8), %rcx
movq %rcx, 0x48(%rdi)
testq %rcx, %rcx
je 0x2b3c
cmpl $0x2, 0x4(%rcx)
jae 0x2b24
retq
leaq (%rdx,%rax,8), %rsi
addq $0x8, %rcx
addq $0x8, %rsi
movq 0x20(%rdi), %rdx
xorl %r8d, %r8d
jmp 0x2c06
pushq %rax
leaq 0x268b(%rip), %rdi      # 0x51cf
leaq 0x25f2(%rip), %rsi      # 0x513d
leaq 0x268a(%rip), %rcx      # 0x51dc
movl $0xe5, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::DumpMaximalSets()
void AllMaximalSetsLexicographic::DumpMaximalSets() {
  for (unsigned int i = 0; i < candidates_.size(); ++i) {
    SetProperties* maximal_set = candidates_[i];
    if (maximal_set) {
      FoundMaximalSet(*maximal_set);
      SetProperties::Delete(maximal_set);
    }
  }
  candidates_.clear();
  std::cout << std::flush;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rdx
cmpq %rax, %rdx
je 0x2bec
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x2bd1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f18
movq %r14, %rdi
callq 0x461c
movl %ebp, %ecx
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
movq %rdx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rcx, %rsi
ja 0x2bb5
cmpq %rax, %rdx
je 0x2bf5
movq %rax, 0x20(%rbx)
movq 0x53d4(%rip), %rdi      # 0x7fd0
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::FoundMaximalSet(google_extremal_sets::SetProperties const&)
void AllMaximalSetsLexicographic::FoundMaximalSet(const SetProperties& maximal_set) {
  ++maximal_sets_count_;
  switch (output_mode_) {
    case COUNT_ONLY:
      break;
    case ID:
      std::cout << maximal_set.set_id << '\n';
      break;
    case ID_AND_ITEMS:
      std::cout << maximal_set << '\n';
      break;
    default:
      std::cout << "Huh?\n";
      assert(0);
      break;
  }
}

// Assembly:
pushq %rax
incq (%rdi)
movl 0x58(%rdi), %eax
testl %eax, %eax
je 0x2f63
cmpl $0x2, %eax
je 0x2f42
cmpl $0x1, %eax
jne 0x2f65
movl (%rsi), %esi
movq 0x509a(%rip), %rdi      # 0x7fd0
callq 0x20f0
leaq 0x6(%rsp), %rsi
jmp 0x2f53
movq 0x5087(%rip), %rdi      # 0x7fd0
callq 0x4621
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x21e0
popq %rax
retq
movq 0x5064(%rip), %rdi      # 0x7fd0
leaq 0x23f4(%rip), %rsi      # 0x5367
callq 0x2190
leaq 0x23ee(%rip), %rdi      # 0x536d
leaq 0x21b7(%rip), %rsi      # 0x513d
leaq 0x23e2(%rip), %rcx      # 0x536f
movl $0x19b, %edx            # imm = 0x19B
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::GetNewEndRangeIt(__gnu_cxx::__normal_iterator<google_extremal_sets::SetProperties**, std::vector<google_extremal_sets::SetProperties*, std::allocator<google_extremal_sets::SetProperties*>>>, __gnu_cxx::__normal_iterator<google_extremal_sets::SetProperties**, std::vector<google_extremal_sets::SetProperties*, std::allocator<google_extremal_sets::SetProperties*>>>, unsigned int, unsigned int)
inline
AllMaximalSetsLexicographic::CandidateList::iterator AllMaximalSetsLexicographic::GetNewEndRangeIt(
    CandidateList::iterator begin_range_it,
    CandidateList::iterator end_range_it,
    uint32_t current_item,
    unsigned int depth) {
  ++canidate_seek_count_;
  CandidateList::iterator new_end_range_it;
  if (depth == 0) {
    // At depth 0 we can use the index rather than binary search.
    if (current_item + 1 < index_.size()) {
      new_end_range_it = candidates_.begin() + index_[current_item + 1];
      assert(new_end_range_it <= end_range_it);
    } else {
      new_end_range_it = end_range_it;
    }
  } else {
    new_end_range_it = find_new_it(
        begin_range_it,
        end_range_it,
        current_item,
        depth,
        std::equal_to<uint32_t>());
  }
  return new_end_range_it;
}

// Assembly:
pushq %rax
incq 0x10(%rdi)
testl %r8d, %r8d
je 0x30b2
cmpq %rdx, %rsi
je 0x301b
cmpq $0x0, (%rsi)
jne 0x301b
addq $0x8, %rsi
jmp 0x300a
movq %rdx, %rdi
subq %rsi, %rdi
shrq $0x3, %rdi
testl %edi, %edi
jle 0x308a
movl %r8d, %eax
movl %edi, %r8d
shrl %r8d
leaq (%rsi,%r8,8), %r9
cmpq %rdx, %r9
jae 0x3047
cmpq $0x0, (%r9)
jne 0x3047
addq $0x8, %r9
jmp 0x3036
cmpq %rdx, %r9
je 0x3082
movq (%r9), %r9
cmpl %ecx, 0x8(%r9,%rax,4)
jne 0x3082
movl %r8d, %r9d
leaq (%rsi,%r9,8), %rsi
addq $0x8, %rsi
notl %r8d
addl %r8d, %edi
cmpq %rdx, %rsi
jae 0x307a
cmpq $0x0, (%rsi)
jne 0x307a
addq $0x8, %rsi
decl %edi
jmp 0x3067
movl %edi, %r8d
cmpq %rdx, %rsi
je 0x30dc
movl %r8d, %edi
testl %r8d, %r8d
jg 0x302c
cmpq $0x0, (%rsi)
movq %rsi, %rdx
jne 0x30dc
leaq 0x2418(%rip), %rdi      # 0x54b2
leaq 0x209c(%rip), %rsi      # 0x513d
leaq 0x2411(%rip), %rcx      # 0x54b9
movl $0x46, %edx
callq 0x20e0
incl %ecx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rsi
subq %rax, %rsi
sarq $0x3, %rsi
cmpq %rcx, %rsi
jbe 0x30dc
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq 0x18(%rdi), %rax
cmpq %rdx, %rax
movq %rax, %rdx
ja 0x30e1
movq %rdx, %rax
popq %rcx
retq
leaq 0x22e6(%rip), %rdi      # 0x53ce
leaq 0x204e(%rip), %rsi      # 0x513d
leaq 0x22f9(%rip), %rcx      # 0x53ef
movl $0x13f, %edx            # imm = 0x13F
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/data-source-iterator.cc
// Function: google_extremal_sets::DataSourceIterator::Get(char const*)
DataSourceIterator* DataSourceIterator::Get(const char* filename) {
  FILE* data = fopen(filename, "rb");
  if (!data) {
    std::cerr << "ERROR: Failed to open input file ("
              << filename << "): " << strerror(errno) << "\n";
    return 0;
  }
  return new DataSourceIterator(data);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1f77(%rip), %rsi      # 0x5811
callq 0x21f0
testq %rax, %rax
je 0x38d4
movq %rax, %r14
movl $0x30, %edi
callq 0x21b0
movq %r14, (%rax)
movl $0x0, 0x8(%rax)
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movb $0x0, 0x20(%rax)
jmp 0x39a4
movq 0x4715(%rip), %r14      # 0x7ff0
leaq 0x1f32(%rip), %rsi      # 0x5814
movl $0x22, %edx
movq %r14, %rdi
callq 0x21e0
testq %rbx, %rbx
je 0x3910
movq %rbx, %rdi
callq 0x20a0
movq 0x46ed(%rip), %rdi      # 0x7ff0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21e0
jmp 0x3928
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2260
movq 0x46c1(%rip), %rbx      # 0x7ff0
leaq 0x1f01(%rip), %rsi      # 0x5837
movl $0x3, %edx
movq %rbx, %rdi
callq 0x21e0
callq 0x2040
movl (%rax), %edi
callq 0x2070
testq %rax, %rax
je 0x3973
movq %rax, %r14
movq %rax, %rdi
callq 0x20a0
movq 0x468a(%rip), %rdi      # 0x7ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x21e0
jmp 0x398a
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2260
movq 0x465f(%rip), %rdi      # 0x7ff0
leaq 0x16e5(%rip), %rsi      # 0x507d
movl $0x1, %edx
callq 0x21e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/data-source-iterator.cc
// Function: google_extremal_sets::DataSourceIterator::Seek(long)
bool DataSourceIterator::Seek(off_t resume_offset) {
  if (fseeko(data_, resume_offset, 0)) {
    error_ = "fseek failed: " +  std::string(strerror(errno));
    return false;
  }
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
xorl %edx, %edx
callq 0x20d0
movl %eax, %ebx
testl %eax, %eax
je 0x3ae1
callq 0x2040
movl (%rax), %edi
callq 0x2070
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x4272
leaq 0x1df7(%rip), %rcx      # 0x583b
movl $0xe, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3a7e
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x3a86
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
addq $0x10, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x3ac6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ae1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
testl %ebx, %ebx
sete %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b10
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/roberto-bayardo[P]google-extremal-sets/set-properties.cc
// Function: google_extremal_sets::operator<<(std::ostream&, google_extremal_sets::SetProperties const&)
std::ostream& operator<<(std::ostream& os, const SetProperties& output_me) {
  os << output_me.set_id << ": ";
  for (uint32_t i = 0; i < output_me.size; ++i) {
    if (i != 0)
      os << ' ';
    os << output_me.item[i];
  }
  return os;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x20f0
leaq 0x11fb(%rip), %rsi      # 0x5838
movl $0x2, %edx
movq %rax, %rdi
callq 0x21e0
cmpl $0x0, 0x4(%r14)
je 0x468c
xorl %r12d, %r12d
leaq 0x7(%rsp), %r15
testq %r12, %r12
je 0x4673
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movl 0x8(%r14,%r12,4), %esi
movq %rbx, %rdi
callq 0x20f0
incq %r12
movl 0x4(%r14), %eax
cmpq %rax, %r12
jb 0x4659
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/akojo[P]quickfind/qfind.cpp
// Function: usage()
void usage(void)
{
    cerr << "Quickfind version 1.0" << endl;
    cerr << "Usage: qfind [-adf] <pattern> [path...]" << endl;
    cerr << "       qfind -h" << endl;
    cerr << "Where options are:" << endl;
    cerr << "  -a  Show also hidden files and directories" << endl;
    cerr << "  -d  Print matching directories" << endl;
    cerr << "  -f  Print matching files" << endl;
    cerr << "  -h  Print this info and exit" << endl;
    cerr << "Omitting both 'd' and 'f' flags is the same as specifying -df" << endl;
    exit(1);
}

// Assembly:
pushq %rbx
movq 0x4c3c(%rip), %rbx      # 0x6ff0
leaq 0x2c49(%rip), %rsi      # 0x5004
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c48(%rip), %rsi      # 0x501a
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c59(%rip), %rsi      # 0x5042
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c52(%rip), %rsi      # 0x5052
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c4e(%rip), %rsi      # 0x5065
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c64(%rip), %rsi      # 0x5092
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c6e(%rip), %rsi      # 0x50b3
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c72(%rip), %rsi      # 0x50ce
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
leaq 0x2c7a(%rip), %rsi      # 0x50ed
movq %rbx, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
movl $0x1, %edi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/akojo[P]quickfind/dir.cpp
// Function: walk(char*, int, std::function<void (char const*)>)
static void walk(char *name, int opts, function<void(const char*)> func) noexcept
{
    auto dir = opendir(name);
    auto namelen = strlen(name);
    auto endp = name + namelen;
    struct dirent *d;

    if (!dir) return;

    *endp++ = '/';

    while ((d = readdir(dir)) != NULL) {
        if (skip(d->d_name, opts)) continue;
        if (strlen(d->d_name) + namelen >= FILENAME_MAX) continue;

        strcpy(endp, d->d_name);

        if (is_dir(d, name)) {
           if (opts & DW_DIRECTORIES) func(name);
           walk(name, opts, func);
        }
        else if (opts & DW_FILES) {
            func(name);
        }
    }
    closedir(dir);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x21a0
movq %rax, %r15
movq %r14, %rdi
callq 0x2080
testq %r15, %r15
je 0x332e
movq %rax, %r12
addq %r14, %rax
incq %rax
movq %rax, 0x10(%rsp)
movq %r14, 0x8(%rsp)
movb $0x2f, (%r14,%r12)
movq %r15, %rdi
callq 0x21b0
movq %rax, %r13
testq %rax, %rax
je 0x3326
movq %r13, %r14
cmpb $0x2e, 0x13(%r13)
jne 0x323d
testb $0x1, %bpl
je 0x3204
movzbl 0x14(%r14), %eax
testl %eax, %eax
je 0x3204
cmpl $0x2e, %eax
jne 0x323d
cmpb $0x0, 0x15(%r14)
je 0x3204
addq $0x13, %r13
movq %r13, %rdi
callq 0x2080
addq %r12, %rax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x3204
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x2110
movzbl 0x12(%r14), %eax
cmpl $0x4, %eax
je 0x32c6
testl %eax, %eax
movq 0x8(%rsp), %r14
jne 0x3297
movq %r14, %rdi
leaq 0x38(%rsp), %rsi
callq 0x2100
testl %eax, %eax
jne 0x3297
movl 0x50(%rsp), %eax
movl $0xf000, %ecx           # imm = 0xF000
andl %ecx, %eax
cmpl $0x4000, %eax           # imm = 0x4000
je 0x32cb
testb $0x4, %bpl
je 0x3204
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x3340
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
callq *0x18(%rbx)
jmp 0x3204
movq 0x8(%rsp), %r14
testb $0x2, %bpl
je 0x32e8
movq %r14, 0x38(%rsp)
cmpq $0x0, 0x10(%rbx)
je 0x3340
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
callq *0x18(%rbx)
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x3352
movq %r14, %rdi
movl %ebp, %esi
leaq 0x18(%rsp), %rdx
callq 0x31ba
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x3204
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3204
movq %r15, %rdi
callq 0x21e0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2060
jmp 0x3349
jmp 0x3349
movq %rax, %rdi
callq 0x29f1
nop
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/vector3.cpp
// Function: Vector3::cross(Vector3)
Vector3 Vector3::cross(Vector3 v) {
    return Vector3(
        -z * v.get_y() + y * v.get_z(),
        z * v.get_x() - x * v.get_z(),
        -y * v.get_x() + x * v.get_y()
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movsd 0x10(%rsi), %xmm0
movsd 0x10(%rbp), %xmm1
movsd 0x18(%rbp), %xmm2
movsd (%rsi), %xmm3
movsd 0x8(%rsi), %xmm4
movsd 0x20(%rbp), %xmm5
movapd %xmm4, %xmm6
mulsd %xmm5, %xmm6
movapd %xmm0, %xmm7
mulsd %xmm2, %xmm7
subsd %xmm7, %xmm6
mulsd %xmm3, %xmm5
mulsd %xmm1, %xmm0
subsd %xmm5, %xmm0
mulsd %xmm3, %xmm2
mulsd %xmm1, %xmm4
subsd %xmm4, %xmm2
movsd %xmm6, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm2, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/sphere.cpp
// Function: Sphere::Sphere()
Sphere::Sphere() {
    center = Vector3(0, 0, 0);
    radius = 0;

    PhongMaterial m = PhongMaterial(0, 0, 0, 0, Color(0, 0, 0), Color(0, 0, 0), Color(0, 0, 0));
    set_material(&m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x6034(%rip), %rax      # 0x8ca0
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0x284c
leaq -0xa8(%rbp), %r14
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r14, %rdi
callq 0x2838
movq 0x10(%r14), %rax
movq %rax, 0x20(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x28(%rbx)
leaq -0x58(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x35f4
leaq -0x48(%rbp), %r12
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x35f4
leaq -0x38(%rbp), %r13
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x35f4
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq (%r12), %rcx
movl 0x8(%r12), %r8d
movl 0x8(%r13), %eax
movq (%r13), %r9
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorps %xmm3, %xmm3
movq %r14, %rdi
pushq %rax
pushq %r9
callq 0x3830
addq $0x10, %rsp
movq %r14, 0x8(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/perspective_camera.cpp
// Function: PerspectiveCamera::PerspectiveCamera(double, Vector3, Vector3, Vector3, Vector3)
PerspectiveCamera::PerspectiveCamera(double d, Vector3 lb, Vector3 h, Vector3 v, Vector3 p) {
    distance = d;
    left_bottom_pos = lb;
    horizontal = h;
    vertical = v;
    camera_pos = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsd %xmm0, -0x10(%rbp)
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x284c
leaq 0x20(%rbx), %rdi
callq 0x284c
leaq 0x38(%rbx), %rdi
callq 0x284c
leaq 0x50(%rbx), %rdi
callq 0x284c
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rbx)
movq 0x20(%rbp), %rax
movq %rax, 0x18(%rbx)
movaps 0x10(%rbp), %xmm0
movups %xmm0, 0x8(%rbx)
movq 0x38(%rbp), %rax
movq %rax, 0x30(%rbx)
movups 0x28(%rbp), %xmm0
movups %xmm0, 0x20(%rbx)
movaps 0x40(%rbp), %xmm0
movups %xmm0, 0x38(%rbx)
movq 0x50(%rbp), %rax
movq %rax, 0x48(%rbx)
movups 0x58(%rbp), %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x68(%rbp), %rax
movq %rax, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/perspective_camera.cpp
// Function: PerspectiveCamera::generate_ray(double, double)
Ray3 PerspectiveCamera::generate_ray(double u, double v) {
    return Ray3(
        camera_pos,
        left_bottom_pos.add(horizontal.scale(u))
                       .add(vertical.scale(v))
                       .subtract(camera_pos)
                       .normalize()
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movsd %xmm1, -0x28(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0x60(%rsi), %rax
movq %rax, -0x30(%rbp)
movups 0x50(%rsi), %xmm1
movaps %xmm1, -0x40(%rbp)
leaq 0x8(%rsi), %r15
addq $0x20, %rsi
leaq -0x70(%rbp), %r12
movq %r12, %rdi
callq 0x2a06
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
leaq -0x88(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x297c
leaq 0x38(%r14), %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x2a06
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x297c
movq 0x60(%r14), %rax
movq %rax, 0x10(%rsp)
movups 0x50(%r14), %xmm0
movups %xmm0, (%rsp)
leaq -0xb8(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x29d2
leaq -0xd0(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x28de
movq 0x10(%r15), %rax
movq %rax, 0x28(%rsp)
movups (%r15), %xmm0
movups %xmm0, 0x18(%rsp)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x2b14
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/geometry_union.cpp
// Function: GeometryUnion::intersect(Ray3)
IntersectResult GeometryUnion::intersect(Ray3 ray) {
    int size = geometries.size();
    double min_dis = MAX_DISTANCE;
    IntersectResult res(0, 0, Vector3(0, 0, 0), Vector3(0, 0, 0));
    for(int i = 0; i < size; i++) {
        IntersectResult tmp = geometries[i] -> intersect(ray);
        if(tmp.geometry && tmp.distance < min_dis) {
            min_dis = tmp.distance;
            res = tmp;
        }
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r13
subq (%rsi), %r13
shrq $0x3, %r13
leaq -0xc0(%rbp), %r15
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x2838
leaq -0xa8(%rbp), %r12
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r12, %rdi
callq 0x2838
movq 0x10(%r12), %rax
movq %rax, -0x60(%rbp)
movups (%r12), %xmm0
movaps %xmm0, -0x70(%rbp)
movups (%r15), %xmm0
movaps %xmm0, -0x90(%rbp)
movq 0x10(%r15), %rax
movq %rax, -0x80(%rbp)
leaq 0x10(%rbx), %rdi
callq 0x284c
leaq 0x28(%rbx), %rdi
callq 0x284c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movaps -0x90(%rbp), %xmm0
movups %xmm0, 0x10(%rbx)
movq -0x80(%rbp), %rax
movq %rax, 0x20(%rbx)
movapd -0x70(%rbp), %xmm0
movupd %xmm0, 0x28(%rbx)
movq -0x60(%rbp), %rax
movq %rax, 0x38(%rbx)
testl %r13d, %r13d
jle 0x349d
leaq 0x10(%rbp), %r12
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
movsd 0x2cf3(%rip), %xmm0     # 0x6110
movsd %xmm0, -0x30(%rbp)
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rsi
movq (%rsi), %rax
movupd (%r12), %xmm0
movupd 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
leaq -0x70(%rbp), %rdi
callq *(%rax)
cmpq $0x0, -0x70(%rbp)
je 0x3495
movsd -0x68(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3495
movupd -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movups -0x50(%rbp), %xmm3
movups -0x40(%rbp), %xmm4
movups %xmm4, 0x30(%rbx)
movups %xmm3, 0x20(%rbx)
movups %xmm2, 0x10(%rbx)
movupd %xmm1, (%rbx)
movsd %xmm0, -0x30(%rbp)
incq %r15
cmpq %r15, %r13
jne 0x3425
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/phong_material.cpp
// Function: PhongMaterial::PhongMaterial(double, double, double, double, Color, Color, Color)
PhongMaterial::PhongMaterial(double a, double d, double s, double h, Color a_c, Color d_c, Color s_c) {
    envir_factor = a;
    diffuse_factor = d;
    specular_factor = s;
    highlight_factor = h;

    envir_color = a_c;
    diffuse_color = d_c;
    specular_color = s_c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r13
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %rdi, %r15
leaq 0x5465(%rip), %rax      # 0x8cd0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x3602
leaq 0x2c(%r15), %rdi
callq 0x3602
leaq 0x38(%r15), %rdi
callq 0x3602
leaq 0x5474(%rip), %rax      # 0x8d08
movq %rax, (%r15)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x8(%r15)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x10(%r15)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x18(%r15)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x48(%r15)
movq %r13, 0x20(%r15)
movl %r12d, 0x28(%r15)
movq %r14, 0x2c(%r15)
movl %ebx, 0x34(%r15)
movq 0x10(%rbp), %rax
movq %rax, 0x38(%r15)
movl 0x18(%rbp), %eax
movl %eax, 0x40(%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Crawler995[P]Cpp-Ray-Tracing/libs/phong_material.cpp
// Function: PhongMaterial::PhongMaterial()
PhongMaterial::PhongMaterial() {
    envir_factor = 0;
    diffuse_factor = specular_factor = 0.5;
    highlight_factor = 5;

    envir_color = Color(0, 0, 0);
    diffuse_color = specular_color = Color(255, 255, 255);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x53c9(%rip), %rax      # 0x8cd0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x3602
leaq 0x2c(%rbx), %rdi
callq 0x3602
leaq 0x38(%rbx), %rdi
callq 0x3602
leaq 0x53d8(%rip), %rax      # 0x8d08
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
movq %rax, 0x48(%rbx)
leaq -0x1c(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x35f4
movl 0x8(%r14), %eax
movl %eax, 0x28(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movl $0xff, %esi
movl $0xff, %edx
movl $0xff, %ecx
callq 0x35f4
movl 0x8(%r14), %eax
movl %eax, 0x40(%rbx)
movq (%r14), %rax
movq %rax, 0x38(%rbx)
movq (%r14), %rax
movq %rax, 0x2c(%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x34(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop