LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/ska_flat_hash_map/./flat_hash_map.hpp
// Function: std::pair<ska::detailv3::sherwood_v3_table<std::pair<unsigned int, unsigned int>, unsigned int, Hash32, ska::detailv3::KeyOrValueHasher<unsigned int, std::pair<unsigned int, unsigned int>, Hash32>, std::equal_to<unsigned int>, ska::detailv3::KeyOrValueEquality<unsigned int, std::pair<unsigned int, unsigned int>, std::equal_to<unsigned int>>, std::allocator<std::pair<unsigned int, unsigned int>>, std::allocator<ska::detailv3::sherwood_v3_entry<std::pair<unsigned int, unsigned int>>>>::templated_iterator<std::pair<unsigned int, unsigned int>>, bool> ska::detailv3::sherwood_v3_table<std::pair<unsigned int, unsigned int>, unsigned int, Hash32, ska::detailv3::KeyOrValueHasher<unsigned int, std::pair<unsigned int, unsigned int>, Hash32>, std::equal_to<unsigned int>, ska::detailv3::KeyOrValueEquality<unsigned int, std::pair<unsigned int, unsigned int>, std::equal_to<unsigned int>>, std::allocator<std::pair<unsigned int, unsigned int>>, std::allocator<ska::detailv3::sherwood_v3_entry<std::pair<unsigned int, unsigned int>>>>::emplace<std::pair<unsigned int, unsigned int>>(std::pair<unsigned int, unsigned int>&&)
std::pair<iterator, bool> emplace(Key && key, Args &&... args)
    {
        size_t index = hash_policy.index_for_hash(hash_object(key), num_slots_minus_one);
        EntryPointer current_entry = entries + ptrdiff_t(index);
        int8_t distance_from_desired = 0;
        for (; current_entry->distance_from_desired >= distance_from_desired; ++current_entry, ++distance_from_desired)
        {
            if (compares_equal(key, current_entry->value))
                return { { current_entry }, false };
        }
        return emplace_new_key(distance_from_desired, current_entry, std::forward<Key>(key), std::forward<Args>(args)...);
    }

// Assembly:
pushq %rax
movq %rsi, %r8
movl (%rsi), %edx
movabsq $-0x61c8864680b583eb, %rax # imm = 0x9E3779B97F4A7C15
imulq %rdx, %rax
movb 0x10(%rdi), %cl
shrq %cl, %rax
imulq $0xc, %rax, %rax
addq (%rdi), %rax
xorl %ecx, %ecx
cmpb %cl, (%rax)
jl 0x16da
cmpl 0x4(%rax), %edx
je 0x16ea
addq $0xc, %rax
incb %cl
jmp 0x16c9
movsbl %cl, %esi
movq %rax, %rdx
movq %r8, %rcx
callq 0x16ee
jmp 0x16ec
xorl %edx, %edx
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/ska_flat_hash_map/./flat_hash_map.hpp
// Function: ska::detailv3::sherwood_v3_table<std::pair<unsigned int, unsigned int>, unsigned int, Hash32, ska::detailv3::KeyOrValueHasher<unsigned int, std::pair<unsigned int, unsigned int>, Hash32>, std::equal_to<unsigned int>, ska::detailv3::KeyOrValueEquality<unsigned int, std::pair<unsigned int, unsigned int>, std::equal_to<unsigned int>>, std::allocator<std::pair<unsigned int, unsigned int>>, std::allocator<ska::detailv3::sherwood_v3_entry<std::pair<unsigned int, unsigned int>>>>::reset_to_empty_state()
void reset_to_empty_state()
    {
        deallocate_data(entries, num_slots_minus_one, max_lookups);
        entries = Entry::empty_default_table();
        num_slots_minus_one = 0;
        hash_policy.reset();
        max_lookups = detailv3::min_lookups - 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movsbl 0x11(%rdi), %ecx
callq 0x163c
callq 0x1656
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movw $0x33f, 0x10(%rbx)      # imm = 0x33F
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/ska_flat_hash_map/./flat_hash_map.hpp
// Function: ska::detailv3::log2(unsigned long)
inline int8_t log2(size_t value)
{
    static constexpr int8_t table[64] =
    {
        63,  0, 58,  1, 59, 47, 53,  2,
        60, 39, 48, 27, 54, 33, 42,  3,
        61, 51, 37, 40, 49, 18, 28, 20,
        55, 30, 34, 11, 43, 14, 22,  4,
        62, 57, 46, 52, 38, 26, 32, 41,
        50, 36, 17, 19, 29, 10, 13, 21,
        56, 45, 25, 31, 35, 16,  9, 12,
        44, 24, 15,  8, 23,  7,  6,  5
    };
    value |= value >> 1;
    value |= value >> 2;
    value |= value >> 4;
    value |= value >> 8;
    value |= value >> 16;
    value |= value >> 32;
    return table[((value - (value >> 1)) * 0x07EDD5E59A4E28C2) >> 58];
}

// Assembly:
movq %rdi, %rax
shrq %rax
orq %rdi, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x20, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq %rax
subq %rax, %rcx
movabsq $0x7edd5e59a4e28c2, %rax # imm = 0x7EDD5E59A4E28C2
imulq %rcx, %rax
shrq $0x3a, %rax
leaq 0x603(%rip), %rcx       # 0x20d0
movb (%rax,%rcx), %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lindorx[P]train/assistFun.cpp
// Function: CutStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
std::string CutStr(const std::string& str, int num = 0)
{
	std::string m;
	bool w = false;
	if (num < 2)w = true;
	//��ȥ��ͷ���ֿ��ܴ��ڵ��޹��ַ���0x20Ϊ�ո�
	while(num<(int)str.size()){
		if (str[num] != 0x20 
			&& str[num]!='\t' 
			&& str[num]!=','
			&& str[num]!='"')break;
		num++;
	}
	//��ȡ�ַ���
	while (num<(int)str.size() && (isalnum(str[num]) || str[num] == '$' || str[num] == '+' || str[num] == '-' || str[num] == '*' || str[num] == '/')){
		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 %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movslq %edx, %rdx
movslq %eax, %rdi
cmpl %edi, %edx
movl %edi, %esi
cmovgl %edx, %esi
movabsq $0x100500000200, %r8    # imm = 0x100500000200
cmpq %rdi, %rdx
jge 0x363b
movzbl (%rcx,%rdx), %r9d
cmpq $0x2c, %r9
ja 0x3639
btq %r9, %r8
jae 0x3639
incq %rdx
jmp 0x361e
movl %edx, %esi
movslq %esi, %r12
movabsq $0xac1000000000, %r13   # imm = 0xAC1000000000
cltq
cmpq %rax, %r12
jge 0x3689
movq (%r14), %rax
movsbl (%rax,%r12), %r15d
movl %r15d, %edi
callq 0x21e0
testl %eax, %eax
jne 0x3674
movzbl %r15b, %eax
cmpl $0x2f, %eax
ja 0x3689
movl %eax, %eax
btq %rax, %r13
jae 0x3689
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x2170
incq %r12
movq 0x8(%r14), %rax
jmp 0x3648
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
callq 0x2358
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/lindorx[P]train/HelpInsPro.cpp
// Function: NumToUc(long, int)
std::vector<unsigned char>NumToUc(long n,int num)
{
	std::vector<unsigned char>data;
	for (int i = 0; i<num; i++){
		data.push_back((unsigned char)(n >> (8 * i)));
	}
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %r14d
shlq $0x3, %r14
leaq -0x29(%rbp), %r13
cmpq %r12, %r14
je 0x3edc
movq %r15, %rax
movl %r12d, %ecx
sarq %cl, %rax
movb %al, -0x29(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5c1e
addq $0x8, %r12
jmp 0x3eba
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
callq 0x5be8
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/lindorx[P]train/HelpInsPro.cpp
// Function: FoundMathChar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
char FoundMathChar(const std::string& str)
{
	for (int i = 0; i < (int)str.size(); ++i){
		switch (str[i]){
		case '+':return '+';
		case '-':return '-';
		case '*':return '*';
		case '/':return '/';
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
movq (%rdi), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
movl $0x2b, %edi
cmpq %rsi, %rax
je 0x3f36
movb (%rdx,%rsi), %cl
addb $-0x2a, %cl
cmpb $0x6, %cl
jae 0x3f31
movzbl %cl, %r8d
btl %r8d, %edi
jb 0x3f3a
incq %rsi
jmp 0x3f17
xorl %eax, %eax
jmp 0x3f4a
shlb $0x3, %cl
movabsq $0x2f2b2d2b2b2a, %rax   # imm = 0x2F2B2D2B2B2A
shrq %cl, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, -0x60(%rbp)
andq $0x0, -0x50(%rbp)
movq 0x8(%rsi), %r14
movq %rsi, %rdi
movl %ecx, %esi
callq 0x3f4c
testl %eax, %eax
js 0x424e
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jmp 0x432c
movq (%r15), %rax
cmpb $0x30, (%rax)
jne 0x42b7
movzbl 0x1(%rax), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x42b7
movl %r12d, -0x2c(%rbp)
movq %rbx, -0x38(%rbp)
movslq %r14d, %r12
leal -0x3(%r14), %r13d
xorl %r14d, %r14d
pushq $0x2
popq %rbx
cmpq %r12, %rbx
jge 0x4321
cvtsi2sd %r13d, %xmm0
mulsd 0x8e6b(%rip), %xmm0     # 0xd0f8
callq 0x21a0
movsd %xmm0, -0x40(%rbp)
movq (%r15), %rax
movsbl (%rax,%rbx), %edi
callq 0x3df3
cvttsd2si -0x40(%rbp), %ecx
cwtl
imull %ecx, %eax
addl %eax, %r14d
incq %rbx
decl %r13d
jmp 0x4277
movq %r15, %rdi
callq 0x3e3a
testb %al, %al
je 0x4355
movl %r12d, -0x2c(%rbp)
movq %rbx, -0x38(%rbp)
xorl %r12d, %r12d
testl %r14d, %r14d
movl $0x0, %r13d
cmovgl %r14d, %r13d
leal -0x1(%r14), %ebx
xorl %r14d, %r14d
cmpq %r12, %r13
je 0x4321
cvtsi2sd %ebx, %xmm1
movsd 0x8e09(%rip), %xmm0     # 0xd100
callq 0x22f0
movsd %xmm0, -0x40(%rbp)
movq (%r15), %rax
movsbl (%rax,%r12), %edi
callq 0x3df3
cvttsd2si -0x40(%rbp), %ecx
cwtl
imull %ecx, %eax
addl %eax, %r14d
incq %r12
decl %ebx
jmp 0x42e6
movslq %r14d, %rax
movq -0x38(%rbp), %rbx
movl -0x2c(%rbp), %r12d
movq %rbx, %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x3e87
leaq -0x60(%rbp), %rdi
callq 0x5be8
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movapd %xmm0, -0x60(%rbp)
andq $0x0, -0x50(%rbp)
jmp 0x433a
jmp 0x4372
jmp 0x4372
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x5be8
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/lindorx[P]train/HelpInsPro.cpp
// Function: acdb(unsigned char, unsigned char, short, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<unsigned char>acdb(unsigned char n1,unsigned char n2,short a,std::string str)
{
	using namespace std;
	vector<unsigned char>data;
	for (int i = 0; i < 16; ++i){
		//�ж��Ƿ�Ϊ16λ�Ĵ���
		if (str == reg2[i]){
			data.push_back(n1);
			if (i>7)data.push_back(b1[i-8][a]);
			else data.push_back(b1[i][a]);
			if (a == 1)data.push_back(0x00);
			return data;
		}
		if (str == reg_1[i]){
			data.push_back(n2);
			if (i>7)data.push_back(b1[i - 8][a]);
			else data.push_back(b1[i][a]);
			if (a == 1)data.push_back(0x00);
			return data;
		}
	}
	cout << "���������룺" << str << endl;
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, -0x30(%rbp)
movq %rdi, %rbx
movb %sil, -0x2a(%rbp)
movb %dl, -0x29(%rbp)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0xc080(%rip), %r12      # 0x113e0
leaq 0xc279(%rip), %r13      # 0x115e0
xorl %r14d, %r14d
cmpq $-0x10, %r14
je 0x539f
movq %r15, %rdi
movq %r13, %rsi
callq 0x5aa9
testb %al, %al
jne 0x53ca
movq %r15, %rdi
movq %r12, %rsi
callq 0x5aa9
testb %al, %al
jne 0x5422
decq %r14
addq $0x20, %r12
addq $0x20, %r13
jmp 0x536a
movq 0xbc32(%rip), %rdi      # 0x10fd8
leaq 0x8029(%rip), %rsi      # 0xd3d6
callq 0x21b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movq %rax, %rdi
callq 0x2100
jmp 0x5478
leaq -0x2a(%rbp), %rsi
movq %rbx, %rdi
callq 0x5ae6
movl -0x30(%rbp), %r15d
movq %r14, %rax
negq %rax
movl $0xfffffff8, %ecx       # imm = 0xFFFFFFF8
subl %r14d, %ecx
cmpq $0x8, %rax
cmovbq %rax, %rcx
movswq %r15w, %rax
leaq 0x7c65(%rip), %rdx      # 0xd060
leaq (%rdx,%rcx,4), %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x5ae6
cmpw $0x1, %r15w
jne 0x5478
leaq -0x2c(%rbp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x5c1e
jmp 0x5478
leaq -0x29(%rbp), %rsi
movq %rbx, %rdi
callq 0x5ae6
movl -0x30(%rbp), %r15d
movq %r14, %rax
negq %rax
movl $0xfffffff8, %ecx       # imm = 0xFFFFFFF8
subl %r14d, %ecx
cmpq $0x8, %rax
cmovbq %rax, %rcx
movswq %r15w, %rax
leaq 0x7c0d(%rip), %rdx      # 0xd060
leaq (%rdx,%rcx,4), %rsi
addq %rax, %rsi
movq %rbx, %rdi
callq 0x5ae6
cmpw $0x1, %r15w
jne 0x5478
leaq -0x2b(%rbp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x5c1e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5490
jmp 0x5490
jmp 0x5490
movq %rax, %r14
movq %rbx, %rdi
callq 0x5be8
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
movslq %edx, %rcx
movslq %esi, %rdx
cmpl %edx, %ecx
movl %edx, %esi
cmovgl %ecx, %esi
cmpq %rdx, %rcx
jge 0x83b3
movzbl (%rax,%rcx), %edi
cmpl $0x20, %edi
je 0x83ac
cmpl $0x9, %edi
jne 0x83b1
incq %rcx
jmp 0x8399
movl %ecx, %esi
movq %r15, %rdi
callq 0x36cf
movq %rax, %r13
movq %rax, %rdi
callq 0x57e4
movq %rax, %r12
addq $0x20, %r13
movq %r13, %rdi
callq 0x57e4
movq %rax, %r13
cmpb $0x0, 0x40(%r12)
jne 0x83e7
cmpb $0x0, 0x40(%r13)
je 0x8400
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %r14d, %r8d
callq 0x6443
jmp 0x8483
leaq 0x5229(%rip), %rsi      # 0xd630
movq %r12, %rdi
callq 0x5ad5
testb %al, %al
jne 0x8426
leaq 0x4da9(%rip), %rsi      # 0xd1c3
movq %r12, %rdi
callq 0x5ad5
testb %al, %al
je 0x8472
leaq 0x4dd1(%rip), %rsi      # 0xd1fe
movq %r13, %rdi
callq 0x5ad5
testb %al, %al
jne 0x844c
leaq 0x4dc3(%rip), %rsi      # 0xd203
movq %r13, %rdi
callq 0x5ad5
testb %al, %al
je 0x8472
movq 0x8b85(%rip), %rdi      # 0x10fd8
leaq 0x4fd1(%rip), %rsi      # 0xd42b
callq 0x21b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %r14d, %ecx
callq 0x606c
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_O2/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 $0x40, %rsp
movl %ecx, %r14d
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
andq $0x0, -0x30(%rbp)
movups %xmm0, (%rdi)
movaps %xmm0, -0x40(%rbp)
leaq -0x60(%rbp), %rsi
movb $-0x33, (%rsi)
callq 0x5c1e
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x35dc
leaq -0x60(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x2358
leaq -0x60(%rbp), %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
movl %r14d, %ecx
callq 0x420a
leaq -0x40(%rbp), %r14
leaq -0x60(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d96
movq %r15, %rdi
callq 0x5be8
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x5ae6
leaq -0x40(%rbp), %rdi
callq 0x5be8
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9928
jmp 0x9928
jmp 0x9928
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x5be8
movq %rbx, %rdi
callq 0x5be8
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/lindorx[P]train/InsPro.cpp
// Function: Shl_Shr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, unsigned char)
std::vector<unsigned char>Shl_Shr(const std::string& str, int n, int num,unsigned char cmd_ch)
{
	using namespace std;
	string *ch;
	ch = CS(str, n);//CS����������ȡ���������ߵ�Ŀ���Ĵ�������Դ���������Զ�ȥ���ո�
	unsigned char m[2] = {0};
	vector<unsigned char>data;
	vector<unsigned char>d;
	for (int i = 0; i < 16; ++i){
		if (ch[0] == reg_1[i]){
			m[0] = 0xc0;
			if (i>7)m[1] = cmd_ch + i - 8;
			else m[1] = cmd_ch + i;

		}
		if (ch[0] == reg2[i]){
			m[0] = 0xc1;
			if (i>7)m[1] = cmd_ch + i - 8;
			else m[1] = cmd_ch + i;
		}
	}
	d = Num(ch[1], 1, num);
	if ((int)d.size() > 0 && m[0] != 0 && m[1] != 0){
		data.push_back(m[0]);
		data.push_back(m[1]);
		data.push_back(d[0]);
		return data;
	}
	cout << "����-021��������ָ�" << str << endl;
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r14d
movl %ecx, -0x3c(%rbp)
movq %rdi, %rbx
movq %rsi, -0x78(%rbp)
movq %rsi, %rdi
movl %edx, %esi
callq 0x36cf
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, -0x38(%rbp)
andq $0x0, 0x10(%rbx)
movaps %xmm0, -0x70(%rbp)
andq $0x0, -0x60(%rbp)
leal -0x8(%r14), %eax
movq %rax, -0x50(%rbp)
movl %r14d, %eax
movq %rax, -0x48(%rbp)
leaq 0x7f91(%rip), %r15      # 0x11cf0
leaq 0x7d8a(%rip), %r14      # 0x11af0
xorl %ebx, %ebx
movl $0x0, -0x30(%rbp)
xorl %r12d, %r12d
cmpq $0x10, %rbx
je 0x9dd3
movq %r13, %rdi
movq %r14, %rsi
callq 0x5aa9
testb %al, %al
je 0x9d9f
cmpq $0x8, %rbx
jb 0x9d93
movq -0x50(%rbp), %rax
jmp 0x9d97
movq -0x48(%rbp), %rax
addl %ebx, %eax
movl %eax, -0x30(%rbp)
movb $-0x40, %r12b
movq %r13, %rdi
movq %r15, %rsi
callq 0x5aa9
testb %al, %al
je 0x9dc6
cmpq $0x8, %rbx
jb 0x9dba
movq -0x50(%rbp), %rax
jmp 0x9dbe
movq -0x48(%rbp), %rax
addl %ebx, %eax
movl %eax, -0x30(%rbp)
movb $-0x3f, %r12b
incq %rbx
addq $0x20, %r15
addq $0x20, %r14
jmp 0x9d72
movl -0x30(%rbp), %ebx
movb %bl, -0x29(%rbp)
movb %r12b, -0x2a(%rbp)
addq $0x20, %r13
leaq -0x90(%rbp), %rdi
pushq $0x1
popq %rdx
movq %r13, %rsi
movl -0x3c(%rbp), %ecx
callq 0x420a
leaq -0x70(%rbp), %r14
leaq -0x90(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d96
movq %r15, %rdi
callq 0x5be8
movl 0x8(%r14), %eax
subl (%r14), %eax
testl %eax, %eax
jle 0x9e52
testb %r12b, %r12b
je 0x9e52
testb %bl, %bl
je 0x9e52
leaq -0x2a(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x5ae6
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
callq 0x5ae6
movq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x5ae6
jmp 0x9e7d
movq 0x717f(%rip), %rdi      # 0x10fd8
leaq 0x3646(%rip), %rsi      # 0xd4a6
movq -0x38(%rbp), %rbx
callq 0x21b0
movq %rax, %rdi
movq -0x78(%rbp), %rsi
callq 0x2190
movq %rax, %rdi
callq 0x2100
leaq -0x70(%rbp), %rdi
callq 0x5be8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9e9a
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x5be8
movq -0x38(%rbp), %rdi
callq 0x5be8
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/lindorx[P]train/InsPro.cpp
// Function: Not(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
std::vector<unsigned char>Not(const std::string& str, int n)
{
	using namespace std;
	string ch = CutStr(str, n);
	vector<unsigned char>data;
	for (int i = 0; i < 16; ++i){
		if (ch == reg_1[i]){
			data.push_back(0xf6);
			if (i>7)data.push_back(logic_not[i - 8]);
			else data.push_back(logic_not[8]);
			return data;
		}
		if (ch == reg2[i]){
			data.push_back(0xf7);
			if (i>7)data.push_back(logic_not[i - 8]);
			else data.push_back(logic_not[8]);
			return data;
		}
	}
	cout << "����-026������������:" << str << endl;
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %rsi, -0x38(%rbp)
callq 0x35dc
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0x78ef(%rip), %r12      # 0x11cf0
leaq 0x76e8(%rip), %r13      # 0x11af0
xorl %r14d, %r14d
cmpq $-0x10, %r14
je 0xa43c
movq %r15, %rdi
movq %r13, %rsi
callq 0x5aa9
testb %al, %al
jne 0xa465
movq %r15, %rdi
movq %r12, %rsi
callq 0x5aa9
testb %al, %al
jne 0xa476
decq %r14
addq $0x20, %r12
addq $0x20, %r13
jmp 0xa40b
movq 0x6b95(%rip), %rdi      # 0x10fd8
leaq 0x30d6(%rip), %rsi      # 0xd520
callq 0x21b0
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x2190
movq %rax, %rdi
callq 0x2100
jmp 0xa4b4
leaq -0x29(%rbp), %rsi
movb $-0xa, (%rsi)
movq %rbx, %rdi
callq 0x5c1e
jmp 0xa485
leaq -0x29(%rbp), %rsi
movb $-0x9, (%rsi)
movq %rbx, %rdi
callq 0x5c1e
movq %r14, %rax
negq %rax
cmpq $0x8, %rax
jb 0xa4a5
movl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
subl %r14d, %eax
leaq 0x3138(%rip), %rsi      # 0xd5d8
addq %rax, %rsi
jmp 0xa4ac
leaq 0x3134(%rip), %rsi      # 0xd5e0
movq %rbx, %rdi
callq 0x5ae6
leaq -0x58(%rbp), %rdi
callq 0x2358
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa4d5
jmp 0xa4d5
jmp 0xa4d5
movq %rax, %r14
movq %rbx, %rdi
callq 0x5be8
leaq -0x58(%rbp), %rdi
callq 0x2358
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/lindorx[P]train/main.cpp
// Function: main
int main(int argc, char* argv[])
{
	using namespace std;
	int i, n = 0;
	if (argc == 1)return 0;
	for (i = 1; i < argc; ++i) {
		FileSize = 0;//�������ɵ��ļ���С
	Number = 0;//����ƫ�Ƶ�ַ
	Line_num = 1;//�к�
	is_Title = false;//��־λ������ֵΪtrue˵��CutStrCode()�����ڴ��������ҵ��ˡ�:��,������ʽΪ�棬�жϺ�Ӧ���¸�ֵΪfalse
		fin_src = argv[i];
		cout<<"code file="<<fin_src<<endl;
		if (fin_src.rfind(".asm") == 0) {//.asmΪ���������ļ����������ǣ��������룬����ʾ��׺������
			cout << "The suffix name is not \".asm\"" << endl;//��ʾ��׺�������⣬��������
		}
		n = fin_src.rfind(".");
		if (n == 0)return 0;
		fout_src = fin_src.substr(0, n)+".bin";
		CompileCode();//����Դ�ļ����ı����룬���ɶ�Ӧ�Ķ������ļ�
		EndCode();//�����ļ��в�������ȷ��������ֵ��λ�ã�������β����
		FileOut();
		cout << "file size=\t" << FileSize << "\tbyte" << endl<<endl;
	}
	cout << endl<<"compile done." << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, -0x38(%rbp)
cmpl $0x1, %edi
je 0xad0b
movslq %edi, %rax
movq %rax, -0x30(%rbp)
pushq $0x1
popq %rbx
leaq 0x7485(%rip), %r14      # 0x12018
pushq $-0x1
popq %r15
leaq -0x78(%rbp), %r12
cmpq -0x30(%rbp), %rbx
jge 0xace8
andl $0x0, 0x7448(%rip)      # 0x11ff4
andl $0x0, 0x7445(%rip)      # 0x11ff8
movl $0x1, 0x743f(%rip)      # 0x11ffc
movb $0x0, 0x7564(%rip)      # 0x12128
movq -0x38(%rbp), %rax
movq (%rax,%rbx,8), %rsi
movq %r14, %rdi
callq 0x2330
movq 0x63fd(%rip), %rdi      # 0x10fd8
leaq 0x2a0e(%rip), %rsi      # 0xd5f0
callq 0x21b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2190
movq %rax, %rdi
callq 0x2100
movq %r14, %rdi
leaq 0x29f7(%rip), %rsi      # 0xd5fb
movq %r15, %rdx
callq 0x22d0
testq %rax, %rax
jne 0xac2c
movq 0x63c0(%rip), %rdi      # 0x10fd8
leaq 0x29e1(%rip), %rsi      # 0xd600
callq 0x21b0
movq %rax, %rdi
callq 0x2100
movq %r14, %rdi
leaq 0x2a0b(%rip), %rsi      # 0xd641
movq %r15, %r13
movq %r15, %rdx
callq 0x22d0
testl %eax, %eax
je 0xad0b
movslq %eax, %rcx
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21f0
movq %r12, %rdi
movq %r15, %rsi
leaq 0x29b4(%rip), %rdx      # 0xd61e
callq 0xca4a
leaq 0x73c2(%rip), %rdi      # 0x12038
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x2358
movq %r15, %rdi
callq 0x2358
callq 0xad30
callq 0xbf75
callq 0xc134
movq 0x6334(%rip), %rdi      # 0x10fd8
leaq 0x2978(%rip), %rsi      # 0xd623
callq 0x21b0
movl 0x733e(%rip), %esi      # 0x11ff4
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
leaq 0x2967(%rip), %rsi      # 0xd62f
callq 0x21b0
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x2100
incq %rbx
movq %r13, %r15
jmp 0xab9b
movq 0x62e9(%rip), %rdi      # 0x10fd8
callq 0x2100
leaq 0x293a(%rip), %rsi      # 0xd635
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2358
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/lindorx[P]train/main.cpp
// Function: EndCode()
void EndCode(void)
{
	using namespace std;
	int i, j;
	std::vector<unsigned char>data;
	short d;
	for (i = 0; i < (int)Title.size(); ++i)
		for (j = 0; j < (int)Mov_place.size(); ++j) {
			if (Title[i].str == Mov_place[j].str) {
				d = isReg(Data[Mov_place[j].s]);
				//��������������data
				if (d == 1) {
					data = NumToUc(Title[i].num, 1);
					Data[Mov_place[j].s + 1] = data[0];
				}
				else if (d == 2) {
					data = NumToUc(Title[i].num, 2);
					Data[Mov_place[j].s + 1] = data[0];
					Data[Mov_place[j].s + 2] = data[1];
				}
				else {
					std::cout << "����Χ��error-006!\n";
				}
			}
		}
	//����jmpָ��
	jmpch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorl %ecx, %ecx
pushq $0x28
popq %r13
leaq -0x60(%rbp), %r14
movq 0x60ba(%rip), %rax      # 0x12060
subq 0x60ab(%rip), %rax      # 0x12058
cqto
idivq %r13
cltq
cmpq %rax, %rcx
jge 0xc0fd
movq %rcx, -0x48(%rbp)
imulq $0x28, %rcx, %r15
xorl %r12d, %r12d
xorl %ebx, %ebx
movq 0x60cf(%rip), %rax      # 0x120a0
movq 0x60c0(%rip), %rsi      # 0x12098
subq %rsi, %rax
cqto
idivq %r13
cltq
cmpq %rax, %rbx
jge 0xc0f1
movq 0x6066(%rip), %rdi      # 0x12058
addq %r15, %rdi
addq %r12, %rsi
callq 0x5aa9
testb %al, %al
je 0xc0e5
movq 0x608c(%rip), %rax      # 0x12098
movslq 0x24(%rax,%r12), %rax
movq 0x5fe8(%rip), %rcx      # 0x12000
movzbl (%rcx,%rax), %edi
callq 0x36ae
cmpw $0x2, %ax
je 0xc066
movzwl %ax, %eax
cmpl $0x1, %eax
jne 0xc0d2
movq 0x601e(%rip), %rax      # 0x12058
movslq 0x20(%rax,%r15), %rsi
movq %r14, %rdi
pushq $0x1
popq %rdx
callq 0x3e87
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x5d96
movq %r14, %rdi
callq 0x5be8
movq -0x40(%rbp), %rax
pushq $0x1
jmp 0xc0b7
movq 0x5feb(%rip), %rax      # 0x12058
movslq 0x20(%rax,%r15), %rsi
movq %r14, %rdi
pushq $0x2
popq %rdx
callq 0x3e87
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x5d96
movq %r14, %rdi
callq 0x5be8
movq -0x40(%rbp), %rax
movb (%rax), %al
movq 0x5ffa(%rip), %rcx      # 0x12098
movslq 0x24(%rcx,%r12), %rcx
movq 0x5f56(%rip), %rdx      # 0x12000
movb %al, 0x1(%rdx,%rcx)
movq -0x40(%rbp), %rax
incq %rax
pushq $0x2
popq %rcx
movb (%rax), %al
movq 0x5fd7(%rip), %rdx      # 0x12098
movslq 0x24(%rdx,%r12), %rdx
addq 0x5f33(%rip), %rdx      # 0x12000
movb %al, (%rcx,%rdx)
jmp 0xc0e5
movq 0x4eff(%rip), %rdi      # 0x10fd8
leaq 0x16bd(%rip), %rsi      # 0xd79d
callq 0x21b0
incq %rbx
addq $0x28, %r12
jmp 0xbfca
movq -0x48(%rbp), %rcx
incq %rcx
jmp 0xbf9f
callq 0xc373
leaq -0x40(%rbp), %rdi
callq 0x5be8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc120
jmp 0xc120
jmp 0xc120
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x5be8
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5eef(%rip), %rsi      # 0x12038
leaq -0x210(%rbp), %rdi
pushq $0x4
popq %rdx
callq 0x2340
leaq -0x1a0(%rbp), %rdi
callq 0x2070
testb %al, %al
jne 0xc18b
movq 0x4e69(%rip), %rdi      # 0x10fd8
callq 0x2100
leaq 0x1636(%rip), %rsi      # 0xd7b1
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x2100
xorl %r14d, %r14d
leaq -0x210(%rbp), %rbx
movl 0x5e6d(%rip), %ecx      # 0x12008
movq 0x5e5e(%rip), %rax      # 0x12000
subl %eax, %ecx
movslq %ecx, %rcx
cmpq %rcx, %r14
jge 0xc1be
movsbl (%rax,%r14), %esi
movq %rbx, %rdi
callq 0x2040
incq %r14
jmp 0xc195
leaq -0x210(%rbp), %rdi
callq 0x2260
leaq -0x210(%rbp), %rdi
callq 0x2280
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xc1e4
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x2280
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movslq %edx, %rdx
movslq %eax, %rdi
cmpl %edi, %edx
movl %edi, %esi
cmovgl %edx, %esi
movabsq $0x100100000200, %r8    # imm = 0x100100000200
cmpq %rdi, %rdx
jge 0xc25a
movzbl (%rcx,%rdx), %r9d
cmpq $0x2c, %r9
ja 0xc258
btq %r9, %r8
jae 0xc258
incq %rdx
jmp 0xc23d
movl %edx, %esi
movslq %esi, %r12
cltq
cmpq %rax, %r12
jge 0xc2b2
movq (%r14), %rax
movsbl (%rax,%r12), %r15d
movzbl %r15b, %r13d
movl %r15d, %edi
callq 0x21e0
testl %eax, %eax
je 0xc284
cmpl $0x3a, %r13d
jne 0xc290
jmp 0xc2ab
cmpl $0x24, %r13d
je 0xc290
cmpl $0x5f, %r13d
jne 0xc2a5
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x2170
incq %r12
movq 0x8(%r14), %rax
jmp 0xc25d
cmpl $0x3a, %r13d
jne 0xc2b2
movb $0x1, 0x5e76(%rip)      # 0x12128
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
callq 0x2358
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc349
movl %edi, %ebx
movq 0x5cdf(%rip), %rsi      # 0x12008
leaq 0x5cd0(%rip), %rdi      # 0x12000
movl %ebx, %edx
leaq -0x9(%rbp), %rcx
callq 0xa902
addl %ebx, 0x5cb3(%rip)      # 0x11ff4
addl %ebx, 0x5cb1(%rip)      # 0x11ff8
jmp 0xc34b
js 0xc352
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x4c7f(%rip), %rdi      # 0x10fd8
leaq 0x145f(%rip), %rsi      # 0xd7bf
callq 0x21b0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x10(%rsp), %rbx
vxorps %xmm0, %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
vmovaps %xmm0, (%rbx)
pushq $0x5
popq %rbp
leaq -0x56(%rip), %r14       # 0x126c
leaq 0x8(%rsp), %r15
subl $0x1, %ebp
jb 0x12ec
movq %r15, %rdi
movq %r14, %rsi
callq 0x135c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1446
movq %r15, %rdi
callq 0x13c2
jmp 0x12c7
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x1309
movq %rbx, %rdi
callq 0x1120
addq $0x8, %rbx
jmp 0x12f6
leaq 0x10(%rsp), %rdi
callq 0x13d0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1322
movq %rax, %rbx
jmp 0x1334
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x13c2
leaq 0x10(%rsp), %rdi
callq 0x13d0
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x5976(%rip), %rdi      # 0x7ff0
leaq 0x29dd(%rip), %rsi      # 0x505e
callq 0x21b0
leaq 0x29f2(%rip), %rsi      # 0x507f
movq %rax, %rdi
callq 0x21b0
movl 0x54(%rbx), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
popq %rbx
jmp 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdx, 0x10(%rsp)
andq $0x0, (%rdx)
andl $0x0, 0x50(%rdi)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r12
andq $0x0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x18(%rdi), %r13
leaq 0xc(%rsp), %rbp
leaq 0x18(%rsp), %r14
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x388a
testl %eax, %eax
je 0x27cf
movl 0xc(%rsp), %edi
movq %r12, %rsi
callq 0x4118
movq %rax, 0x18(%rsp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x2fc0
movq 0x28(%rsp), %rax
subq 0x20(%rsp), %rax
shrq $0x2, %rax
addl 0x50(%rbx), %eax
movl %eax, 0x50(%rbx)
incq 0x8(%rbx)
cmpl 0x54(%rbx), %eax
jb 0x272e
movq %r15, %rdi
callq 0x3882
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq 0x585c(%rip), %rdi      # 0x7ff0
leaq 0x2938(%rip), %rsi      # 0x50d3
callq 0x21b0
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x21a0
leaq 0x2943(%rip), %rsi      # 0x50f6
movq %rax, %rdi
callq 0x21b0
movl 0xc(%rsp), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20d0
leaq 0x20(%rsp), %rdi
callq 0x2f8c
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27ee
jmp 0x27ee
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2f8c
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x57da(%rip), %rdi      # 0x7ff0
leaq 0x28e3(%rip), %rsi      # 0x5100
callq 0x21b0
movq %rax, %rdi
callq 0x20d0
movq 0x20(%rbx), %rax
movq %rax, %r14
subq 0x18(%rbx), %r14
je 0x289c
shrq $0x3, %r14
movq -0x8(%rax), %r15
addl $-0x2, %r14d
testl %r14d, %r14d
js 0x2890
movl %r14d, %r12d
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rdi
movl 0x4(%rdi), %eax
cmpl 0x4(%r15), %eax
jae 0x2875
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x287a
movl 0x8(%rdi,%rcx,4), %edx
leaq 0x1(%rcx), %rsi
cmpl 0x8(%r15,%rcx,4), %edx
movq %rsi, %rcx
je 0x285e
movq %rdi, %r15
jmp 0x288b
subl %eax, 0x50(%rbx)
callq 0x415c
movq 0x18(%rbx), %rax
andq $0x0, (%rax,%r12,8)
decl %r14d
jmp 0x2843
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2887(%rip), %rdi      # 0x512a
leaq 0x2893(%rip), %rsi      # 0x513d
leaq 0x28ae(%rip), %rcx      # 0x515f
movl $0xa6, %edx
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x5722(%rip), %rdi      # 0x7ff0
leaq 0x28e6(%rip), %rsi      # 0x51bb
callq 0x21b0
movq %rax, %rdi
callq 0x20d0
leaq 0x30(%r14), %r15
leaq 0x18(%r14), %rbx
movq 0x20(%r14), %rax
movq -0x8(%rax), %rax
movl 0x8(%rax), %esi
incl %esi
movq %r15, %rdi
callq 0x2cc4
xorl %edi, %edi
pushq $-0x1
popq %r8
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movq 0x18(%r14), %r12
movq 0x20(%r14), %rsi
subq %r12, %rsi
sarq $0x3, %rsi
movslq %edx, %r10
movslq %r8d, %r9
cmpq %rsi, %rcx
jae 0x2974
movq (%r12,%rcx,8), %rsi
testq %rsi, %rsi
je 0x295a
movq %rcx, %r11
subq %r10, %r11
movq %rsi, (%r12,%r11,8)
testq %rdi, %rdi
je 0x295e
movl 0x8(%rdi), %r10d
cmpl %r10d, 0x8(%rsi)
je 0x296f
movq (%r15), %rdi
incl %eax
cmpl %r10d, %eax
ja 0x2966
movl %eax, %r8d
movq %r9, (%rdi,%r8,8)
jmp 0x294a
incl %edx
jmp 0x296f
movl %r11d, %r8d
movq %rsi, %rdi
jmp 0x296f
movl %r11d, %r8d
movq %rsi, %rdi
movl %r10d, %eax
incq %rcx
jmp 0x290b
movl 0x8(%rdi), %ecx
movq (%r15), %rdx
incl %eax
cmpl %ecx, %eax
ja 0x2988
movl %eax, %edi
movq %r9, (%rdx,%rdi,8)
jmp 0x297a
subq %r10, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2cf6
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29d0
cmpl $0x2, 0x4(%rcx)
jae 0x29b8
retq
leaq (%rdx,%rax,8), %rsi
addq $0x8, %rcx
addq $0x8, %rsi
movq 0x20(%rdi), %rdx
xorl %r8d, %r8d
jmp 0x2a8e
pushq %rax
leaq 0x27f7(%rip), %rdi      # 0x51cf
leaq 0x275e(%rip), %rsi      # 0x513d
leaq 0x27f6(%rip), %rcx      # 0x51dc
movl $0xe5, %edx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movl %r15d, %r15d
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0x2a74
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x2a6f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c52
movq %r14, %rdi
callq 0x415c
incl %r15d
jmp 0x2a39
cmpq %rax, %rcx
je 0x2a7d
movq %rax, 0x20(%rbx)
movq 0x554c(%rip), %rdi      # 0x7fd0
popq %rbx
popq %r14
popq %r15
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c8f
cmpl $0x2, %eax
je 0x2c77
cmpl $0x1, %eax
jne 0x2c91
movl (%rsi), %esi
movq 0x5360(%rip), %rdi      # 0x7fd0
callq 0x2110
jmp 0x2c83
movq 0x5352(%rip), %rdi      # 0x7fd0
callq 0x4161
pushq $0xa
popq %rsi
movq %rax, %rdi
popq %rax
jmp 0x21f0
popq %rax
retq
movq 0x5338(%rip), %rdi      # 0x7fd0
leaq 0x26c8(%rip), %rsi      # 0x5367
callq 0x21b0
leaq 0x26c2(%rip), %rdi      # 0x536d
leaq 0x248b(%rip), %rsi      # 0x513d
leaq 0x26b6(%rip), %rcx      # 0x536f
movl $0x19b, %edx            # imm = 0x19B
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/roberto-bayardo[P]google-extremal-sets/all-maximal-sets-lexicographic.cc
// Function: google_extremal_sets::AllMaximalSetsLexicographic::DeleteSubsumedSets(__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)
inline void AllMaximalSetsLexicographic::DeleteSubsumedSets(
    CandidateList::iterator* begin_range_it,
    CandidateList::iterator end_range_it,
    unsigned int depth) {
  // If current_set_->size() == depth, then the current set
  // cannot *properly* subsume any candidates.
  if (current_set_->size > depth) {
    while (*begin_range_it != end_range_it &&
           (!**begin_range_it || (**begin_range_it)->size == depth)) {
      if (**begin_range_it) {
        // Subsumed!
        items_in_ram_ -= (**begin_range_it)->size;
        SetProperties::Delete(**begin_range_it);
        **begin_range_it = 0;
      }
      ++(*begin_range_it);
      }
  } else {
    // Otherwise just skip over already-deleted itemsets.
    while (*begin_range_it != end_range_it && !**begin_range_it) {
      ++(*begin_range_it);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x48(%rdi), %rax
cmpl %ecx, 0x4(%rax)
jbe 0x2d74
movl %ecx, %ebp
movq %rdi, %r15
movq (%r14), %rax
cmpq %rbx, %rax
je 0x2d8b
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2d6b
cmpl %ebp, 0x4(%rdi)
jne 0x2d8b
subl %ebp, 0x50(%r15)
callq 0x415c
movq (%r14), %rax
andq $0x0, (%rax)
movq (%r14), %rax
addq $0x8, %rax
movq %rax, (%r14)
jmp 0x2d46
movq (%r14), %rax
cmpq %rbx, %rax
je 0x2d8b
cmpq $0x0, (%rax)
jne 0x2d8b
addq $0x8, %rax
movq %rax, (%r14)
jmp 0x2d77
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq