LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/KokiKishimoto[P]cp_decomposition/./random_sampler.hpp
// Function: RandomSampler::negativeSamplingSbj(Triple&, std::set<long long, std::less<long long>, std::allocator<long long>>&)
Triple negativeSamplingSbj(Triple& gold, std::set<long long>& triple_key_set) {
		for (;;) {
			int entity1 = getNextEnt();
			if (triple_key_set.find(key_gen.calcKey(entity1, gold.relation, gold.obj)) == triple_key_set.end()) 
			{
				triple.set(entity1, gold.relation, gold.obj);
				return triple;
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x13a4(%rsi), %r13
leaq 0x8(%rcx), %rbp
movq %r13, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x679c
movl 0x4(%r12), %edx
movl 0x8(%r12), %ecx
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x5758
movl 0x139c(%r14), %edi
imull %eax, %edi
movl 0x13a0(%r14), %r8d
imull %edx, %r8d
addl %ecx, %r8d
addl %edi, %r8d
movslq %r8d, %rdi
movq %rbp, %r8
xorl %r9d, %r9d
cmpq %rdi, 0x20(%rsi)
setl %r9b
cmovgeq %rsi, %r8
movq 0x10(%rsi,%r9,8), %rsi
testq %rsi, %rsi
jne 0x5734
cmpq %rbp, %r8
je 0x5758
cmpq %rdi, 0x20(%r8)
jle 0x56f2
movl %eax, 0x1388(%r14)
movl %edx, 0x138c(%r14)
movl %ecx, 0x1390(%r14)
movl 0x1398(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x1388(%r14), %eax
movl %eax, (%rbx)
movl 0x138c(%r14), %eax
movl %eax, 0x4(%rbx)
movl 0x1390(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0x1394(%r14), %eax
movl %eax, 0xc(%rbx)
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_O3/KokiKishimoto[P]cp_decomposition/./random_sampler.hpp
// Function: RandomSampler::negativeSamplingObj(Triple&, std::set<long long, std::less<long long>, std::allocator<long long>>&)
Triple negativeSamplingObj(Triple& gold, std::set<long long>& triple_key_set) {
		for (;;) {
			int entity1 = getNextEnt();
			if (triple_key_set.find(key_gen.calcKey(gold.subj, gold.relation, entity1)) == triple_key_set.end()) 
			{
				triple.set(gold.subj, gold.relation, entity1);
				return triple;
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x13a4(%rsi), %r13
leaq 0x8(%rcx), %rbp
movq %r13, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x679c
movl (%r12), %edx
movl 0x8(%r12), %ecx
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x5836
movl 0x139c(%r14), %edi
imull %edx, %edi
movl 0x13a0(%r14), %r8d
imull %eax, %r8d
addl %ecx, %edi
addl %r8d, %edi
movslq %edi, %rdi
movq %rbp, %r8
xorl %r9d, %r9d
cmpq %rdi, 0x20(%rsi)
setl %r9b
cmovgeq %rsi, %r8
movq 0x10(%rsi,%r9,8), %rsi
testq %rsi, %rsi
jne 0x5812
cmpq %rbp, %r8
je 0x5836
cmpq %rdi, 0x20(%r8)
jle 0x57d2
movl %edx, 0x1388(%r14)
movl %eax, 0x138c(%r14)
movl %ecx, 0x1390(%r14)
movl 0x1398(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x1388(%r14), %eax
movl %eax, (%rbx)
movl 0x138c(%r14), %eax
movl %eax, 0x4(%rbx)
movl 0x1390(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0x1394(%r14), %eax
movl %eax, 0xc(%rbx)
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_O3/KokiKishimoto[P]cp_decomposition/./signal_operation.hpp
// Function: SignalOperation::product(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
std::vector<double> product(const std::vector<double>& a, const std::vector<double>& b, const std::vector<double>& c, std::vector<double>& out1, std::vector<double>& out2, std::vector<double>& out3) {
		for (int i = 0; i < a.size(); i++) {
			out1[i] = a[i] * b[i];
			out2[i] = b[i] * c[i];
			out3[i] = c[i] * a[i];
		}
		return out1;
	}

// Assembly:
pushq %rbx
movq %r9, %rsi
movq %rdi, %rbx
movq (%rdx), %rax
movq 0x8(%rdx), %rdx
subq %rax, %rdx
je 0x670f
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r9
sarq $0x3, %rdx
movq (%rcx), %rcx
movq (%rsi), %rdi
movq (%r8), %r8
movq (%r9), %r9
movq (%r10), %r10
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %r11d, %r11d
movsd (%rax,%r11,8), %xmm0
mulsd (%rcx,%r11,8), %xmm0
movsd %xmm0, (%rdi,%r11,8)
movsd (%rcx,%r11,8), %xmm0
mulsd (%r8,%r11,8), %xmm0
movsd %xmm0, (%r9,%r11,8)
movsd (%r8,%r11,8), %xmm0
mulsd (%rax,%r11,8), %xmm0
movsd %xmm0, (%r10,%r11,8)
incq %r11
cmpq %r11, %rdx
jne 0x66d1
movq %rbx, %rdi
callq 0x671c
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/nicluo[P]sorting-numbers/merge.cpp
// Function: next(Seq*)
bool next(Seq* seq) {
    if (seq->source.good()) {
        seq->source >> seq->value;
        return true;
    }
    
    return false;
}

// Assembly:
pushq %rbx
movq 0x8(%rdi), %rax
movq -0x18(%rax), %rax
movl 0x28(%rdi,%rax), %ebx
testl %ebx, %ebx
jne 0x1395
movq %rdi, %rsi
addq $0x8, %rdi
callq 0x1080
testl %ebx, %ebx
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/nicluo[P]sorting-numbers/merge.cpp
// Function: merge(std::vector<Seq*, std::allocator<Seq*>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void merge(std::vector<Seq*>& sequences, std::ofstream& output) {
    /* Greater<Seq*> comparator for Seq* to create min heap */
    auto comp = []( const Seq* lhs, const Seq* rhs ) { return lhs->value > rhs->value; };
    std::priority_queue<Seq*, std::vector<Seq*>, decltype(comp)> pq(sequences.begin(), sequences.end(), comp);
    
    while(!pq.empty()) {
        /* Get and pop minimum element */
        Seq* top = pq.top();
        pq.pop();
        
        output << top->value << '\n';
        
        /* Since the minimum element is a sequence, if it has a next value,
           we can re-insert into the heap for the next iteration */
        if(next(top)) {
            pq.push(top);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0x17dc
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rax
movq %rax, %r14
subq %r13, %r14
sarq $0x3, %r14
cmpq $0x2, %r14
jl 0x1411
leaq -0x2(%r14), %r15
shrq %r15
movq (%r13,%r15,8), %rcx
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x172a
addq $-0x1, %r15
jb 0x13ee
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rax
cmpq %rax, %r13
je 0x1533
leaq 0xf(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0x38(%rsp), %r12
movq (%r13), %rsi
movq %rsi, 0x38(%rsp)
movq %rax, %rcx
subq %r13, %rcx
cmpq $0x9, %rcx
jl 0x1465
leaq -0x8(%rax), %rdx
movq -0x8(%rax), %rcx
movq %rsi, -0x8(%rax)
subq %r13, %rdx
sarq $0x3, %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x172a
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rsi
addq $-0x8, %rax
movq %rax, 0x18(%rsp)
movl (%rsi), %esi
movq %rbx, %rdi
callq 0x1170
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1110
movq 0x38(%rsp), %rsi
movq 0x8(%rsi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x28(%rsi,%rax)
jne 0x1520
leaq 0x8(%rsi), %rdi
callq 0x1080
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x14ce
movq 0x38(%rsp), %rax
movq %rax, (%rsi)
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x14de
movq %r15, %rdi
movq %r12, %rdx
callq 0x19f8
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movq -0x8(%rsi), %rcx
subq %rax, %rsi
sarq $0x3, %rsi
leaq -0x1(%rsi), %rdx
cmpq $0x2, %rsi
jl 0x151c
movl (%rcx), %esi
leaq -0x1(%rdx), %rdi
movq %rdi, %r8
shrq %r8
movq (%rax,%r8,8), %r9
cmpl %esi, (%r9)
jle 0x151c
movq %r9, (%rax,%rdx,8)
movq %r8, %rdx
cmpq $0x1, %rdi
ja 0x14fa
xorl %edx, %edx
movq %rcx, (%rax,%rdx,8)
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rax
cmpq %rax, %r13
jne 0x1429
testq %r13, %r13
je 0x1548
movq 0x20(%rsp), %rsi
subq %r13, %rsi
movq %r13, %rdi
callq 0x10f0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1558
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1572
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O3/nicluo[P]sorting-numbers/merge.cpp
// Function: main
int main(int argc, char *argv[]) {
    /* Must provide -o and -f */
    if (argc < 5 || strncmp(argv[1], "-o", 3) != 0 || strncmp(argv[3], "-f", 3) != 0) {
        printUsage(argv[0]);
        return 1;
    }
    
    char* outputFilename = argv[2];
    std::ofstream output(outputFilename);
    
    std::vector<Seq*> sequences = std::vector<Seq*>();
    
    for (int i = 4; i < argc; i++) {
        char* inputFilename = argv[i];
        Seq* seq = new Seq(inputFilename);
        if(next(seq)) {
            sequences.push_back(seq);
        }
    }
    
    merge(sequences, output);
    output.close();
    
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
cmpl $0x5, %edi
jl 0x15bd
movq 0x8(%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x15bd
cmpb $0x6f, 0x1(%rax)
jne 0x15bd
cmpb $0x0, 0x2(%rax)
jne 0x15bd
movq 0x18(%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x15bd
cmpb $0x66, 0x1(%rax)
jne 0x15bd
cmpb $0x0, 0x2(%rax)
je 0x15dc
movq (%rbx), %rdi
callq 0x12dc
movl $0x1, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %ebp
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %rdi
movl $0x10, %edx
callq 0x1100
movl %ebp, %r15d
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl $0x4, %r14d
movq (%rbx,%r14,8), %rbp
movl $0x210, %edi            # imm = 0x210
callq 0x10e0
movq %rax, %r12
movq %rax, %r13
addq $0x8, %r13
movq %r13, %rdi
movq %rbp, %rsi
movl $0x8, %edx
callq 0x1190
movq %r12, 0x20(%rsp)
movq 0x8(%r12), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x28(%r12,%rax)
jne 0x167d
movq %r13, %rdi
movq %r12, %rsi
callq 0x1080
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x1670
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x167d
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x19f8
incq %r14
cmpq %r14, %r15
jne 0x160b
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x139c
leaq 0x28(%rsp), %rdi
callq 0x1120
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x16b2
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
movq 0x2917(%rip), %rax      # 0x3fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x10b0
leaq 0x120(%rsp), %rdi
callq 0x1040
xorl %eax, %eax
jmp 0x15ca
jmp 0x16ff
movq %rax, %rbx
movl $0x210, %esi            # imm = 0x210
movq %r12, %rdi
callq 0x10f0
jmp 0x1702
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1718
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x10f0
leaq 0x28(%rsp), %rdi
callq 0x1130
movq %rbx, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O3/KokiKishimoto[P]cp_decomposition/./signal_operation.hpp
// Function: SignalOperation::qproduct(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
double qproduct(const std::vector<double>& a, const std::vector<double>& b, const std::vector<double>& c, std::vector<double>& out1, std::vector<double>& out2, std::vector<double>& out3){
		double score = 0.0;
		for(int i = 0; i < a.size(); i++){
			double a_ = quantize(a[i]);
			double b_ = quantize(b[i]);
			double c_ = quantize(c[i]);
			out1[i] = a_ * b_;
			out2[i] = b_ * c_;
			out3[i] = c_ * a_;
			score += c_ * out1[i];
		}
		return score;
	}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
subq %rax, %rsi
je 0x662d
movq 0x8(%rsp), %r10
sarq $0x3, %rsi
movq (%rdx), %rdx
movq (%rcx), %rcx
movq (%r8), %rdi
movq (%r9), %r8
movq (%r10), %r9
cmpq $0x1, %rsi
adcq $0x0, %rsi
xorpd %xmm1, %xmm1
xorl %r10d, %r10d
movsd 0xa9d(%rip), %xmm2      # 0x7030
movsd 0xa9d(%rip), %xmm3      # 0x7038
xorpd %xmm0, %xmm0
movsd (%rax,%r10,8), %xmm4
cmpltsd %xmm1, %xmm4
movapd %xmm4, %xmm5
andpd %xmm2, %xmm5
andnpd %xmm3, %xmm4
orpd %xmm5, %xmm4
movsd (%rdx,%r10,8), %xmm5
cmpltsd %xmm1, %xmm5
movapd %xmm5, %xmm6
andpd %xmm2, %xmm6
andnpd %xmm3, %xmm5
orpd %xmm6, %xmm5
movsd (%rcx,%r10,8), %xmm6
cmpltsd %xmm1, %xmm6
movapd %xmm6, %xmm7
andpd %xmm2, %xmm7
andnpd %xmm3, %xmm6
orpd %xmm7, %xmm6
movapd %xmm6, %xmm7
mulsd %xmm4, %xmm7
mulsd %xmm5, %xmm4
movsd %xmm4, (%rdi,%r10,8)
mulsd %xmm6, %xmm5
movsd %xmm5, (%r8,%r10,8)
movsd %xmm7, (%r9,%r10,8)
movsd (%rdi,%r10,8), %xmm4
mulsd %xmm6, %xmm4
addsd %xmm4, %xmm0
incq %r10
cmpq %r10, %rsi
jne 0x659f
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/blakewford[P]kab/main.cpp
// Function: toggle(unsigned long, bool)
void toggle(size_t ndx, bool on)
{
    response r = gFound.at(ndx);

    srand(time(nullptr));
    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    struct sockaddr_in target = buildServerType(inet_addr(r.ip), COMMAND_PORT);

    command toggle;
    initializeCommand(toggle);

    toggle.id = rand();
    memcpy(toggle.model, r.model, 32);
    toggle.value = on;

    ssize_t sent = sendto(sock, &toggle, sizeof(command), 0, (sockaddr*)&target, sizeof(target));
    close(sock);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movl %esi, %ebx
movq %rdi, %rax
movq 0x5ca9(%rip), %rcx      # 0x82f0
movq 0x5c9a(%rip), %rsi      # 0x82e8
subq %rsi, %rcx
sarq $0x3, %rcx
movabsq $-0x505050505050505, %rdx # imm = 0xFAFAFAFAFAFAFAFB
imulq %rcx, %rdx
cmpq %rdi, %rdx
jbe 0x2789
imulq $0x198, %rax, %rax      # imm = 0x198
addq %rax, %rsi
leaq 0xa0(%rsp), %r14
movl $0x198, %edx            # imm = 0x198
movq %r14, %rdi
callq 0x2190
xorl %r13d, %r13d
xorl %edi, %edi
callq 0x21d0
movl %eax, %edi
callq 0x21f0
movl $0x2, %edi
movl $0x2, %esi
movl $0x11, %edx
callq 0x2060
movl %eax, %ebp
leaq 0x222(%rsp), %rdi
callq 0x2230
shlq $0x20, %rax
orq $0x50000002, %rax       # imm = 0x50000002
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r13, 0x8(%r15)
xorps %xmm0, %xmm0
leaq 0x1c(%rsp), %r12
movups %xmm0, 0x6a(%r12)
movq %r13, 0x78(%r12)
movups %xmm0, 0x5a(%r12)
movups %xmm0, 0x4a(%r12)
movups %xmm0, 0x3a(%r12)
movups %xmm0, 0x2a(%r12)
movups %xmm0, 0x1a(%r12)
movups %xmm0, 0xa(%r12)
movl $0x50016, (%r12)        # imm = 0x50016
movl $0x55555555, 0x74(%r12) # imm = 0x55555555
movw $0x2, 0x8(%r12)
movb $0x2, 0x80(%r12)
callq 0x2080
movl %eax, 0x4(%r12)
movups 0xa(%r14), %xmm0
movups 0x1a(%r14), %xmm1
movups %xmm0, 0x10(%r12)
movups %xmm1, 0x20(%r12)
movb %bl, 0x81(%r12)
movl $0x82, %edx
movl %ebp, %edi
movq %r12, %rsi
xorl %ecx, %ecx
movq %r15, %r8
movl $0x10, %r9d
callq 0x2040
movl %ebp, %edi
callq 0x23c0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b74(%rip), %rdi      # 0x5304
movq %rax, %rsi
xorl %eax, %eax
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/blakewford[P]kab/main.cpp
// Function: quit(int)
void quit(int sock)
{
    gKeepGoing = false;
    pthread_join(gRecvP1, nullptr);
    pthread_join(gRecvP1, nullptr);

    printTargets(true);

    close(sock);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movb $0x0, 0x598b(%rip)      # 0x81f8
movq 0x5a64(%rip), %rdi      # 0x82d8
xorl %esi, %esi
callq 0x21c0
movq 0x5a56(%rip), %rdi      # 0x82d8
xorl %esi, %esi
callq 0x21c0
movl $0x1, %edi
callq 0x279a
movl %ebx, %edi
popq %rbx
jmp 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/blakewford[P]kab/main.cpp
// Function: recvBroadcast(void*)
void* recvBroadcast(void* arg)
{
    broadcastParams* params = (broadcastParams*)arg;

    struct sockaddr_in server = buildServerType(INADDR_BROADCAST, params->port);

    response target;
    socklen_t length;
    uint8_t buffer[RESPONSE_SIZE];

    while(gKeepGoing)
    {
        ssize_t recv = recvfrom(params->socket, buffer, RESPONSE_SIZE, 0, (sockaddr*)&server, &length);
        memcpy(&target, buffer, RESPONSE_SIZE);

        std::lock_guard<std::mutex> lock(gResponseMutex);

        bool found = false;
        auto iter = gFound.begin();
        while(iter != gFound.end())
        {
            if(!strcmp(iter->serial, target.serial))
            {
                found = true;
                break;
            }
            iter++;
        }
        if(!found)
        {
            gFound.push_back(target);
        }
    }

    return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movzwl 0x4(%rdi), %eax
rolw $0x8, %ax
shll $0x10, %eax
movabsq $-0xfffffffe, %rcx      # imm = 0xFFFFFFFF00000002
orq %rax, %rcx
movq %rcx, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
cmpb $0x1, 0x5901(%rip)      # 0x81f8
jne 0x29d1
movq %rdi, %rbx
leaq 0x62(%rsp), %r14
leaq 0x1b0(%rsp), %r15
leaq 0x599c(%rip), %r12      # 0x82b0
movl (%rbx), %edi
movl $0x198, %edx            # imm = 0x198
movq %r15, %rsi
xorl %ecx, %ecx
leaq 0x8(%rsp), %r8
leaq 0x4(%rsp), %r9
callq 0x2170
movl $0x198, %edx            # imm = 0x198
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x2190
movq %r12, %rdi
callq 0x22d0
testl %eax, %eax
jne 0x29e5
movq 0x5990(%rip), %rbp      # 0x82e8
movq 0x5991(%rip), %r13      # 0x82f0
cmpq %r13, %rbp
je 0x297d
leaq 0x4a(%rbp), %rdi
movq %r14, %rsi
callq 0x2270
testl %eax, %eax
je 0x29bc
addq $0x198, %rbp            # imm = 0x198
jmp 0x295f
cmpq 0x5974(%rip), %r13      # 0x82f8
je 0x29a8
movl $0x198, %edx            # imm = 0x198
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2190
addq $0x198, %r13            # imm = 0x198
movq %r13, 0x594a(%rip)      # 0x82f0
jmp 0x29bc
leaq 0x5939(%rip), %rdi      # 0x82e8
movq %r13, %rsi
leaq 0x18(%rsp), %rdx
callq 0x34d2
movq %r12, %rdi
callq 0x2160
cmpb $0x0, 0x582d(%rip)      # 0x81f8
jne 0x2914
xorl %eax, %eax
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x2130
movq %rax, %rbx
leaq 0x58ba(%rip), %rdi      # 0x82b0
callq 0x2160
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/blakewford[P]kab/main.cpp
// Function: discoverWemo()
void discoverWemo()
{
    int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if(sock < 0) return;

    int32_t broadcast = 1;
    int ret = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast));
    if(ret != 0) return;

    struct sockaddr_in server = buildServerType(inet_addr(SSDP), DISCOVER_WEMO);
    server.sin_port = htons(DISCOVER_WEMO);

    broadcastParams params1;
    params1.socket = sock;
    params1.port = DISCOVER_WEMO;

    pthread_t watchDog;
    pthread_create(&gRecvP1,  nullptr, recvBroadcast, &params1);
    pthread_create(&watchDog, nullptr, timeoutThread, &sock);

    const char* packet =
"M-SEARCH * HTTP/1.1\r\n"\
"HOST: 239.255.255.250:1900\r\n"\
"MAN: \"ssdp:discover\"\r\n"\
"MX: 10\r\n"\
//"ST: ssdp:all\r\n";
"ST: urn:Belkin:device:controllee:1\r\n\r\n";

    ssize_t sent = sendto(sock, packet, strlen(packet), 0, (sockaddr*)&server, sizeof(server));
    usleep(1000*1000*1);

    quit(sock);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x2, %edi
movl $0x2, %esi
movl $0x11, %edx
callq 0x2060
movl %eax, (%rsp)
testl %eax, %eax
js 0x2d4d
movl %eax, %ebx
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x6, %edx
movl $0x4, %r8d
callq 0x2370
testl %eax, %eax
jne 0x2d4d
leaq 0x239f(%rip), %rdi      # 0x505c
callq 0x2230
shlq $0x20, %rax
orq $0x6c070002, %rax       # imm = 0x6C070002
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movw $0x6c07, 0x2(%r14)      # imm = 0x6C07
leaq 0x10(%rsp), %rcx
movl %ebx, (%rcx)
movw $0x76c, 0x4(%rcx)       # imm = 0x76C
leaq 0x55e1(%rip), %rdi      # 0x82d8
leaq -0x445(%rip), %rdx      # 0x28b9
xorl %esi, %esi
callq 0x2390
leaq -0x471(%rip), %rdx      # 0x289b
leaq 0x8(%rsp), %rdi
movq %rsp, %rbx
xorl %esi, %esi
movq %rbx, %rcx
callq 0x2390
movl (%rbx), %edi
leaq 0x2345(%rip), %rsi      # 0x506c
movl $0x75, %edx
xorl %ecx, %ecx
movq %r14, %r8
movl $0x10, %r9d
callq 0x2040
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x2280
movl (%rbx), %edi
callq 0x2863
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/blakewford[P]kab/main.cpp
// Function: addCachedTarget(set_target&)
void addCachedTarget(set_target& t)
{
    response r;
    memset(&r, '\0', RESPONSE_SIZE);

    memcpy(r.name, t.get_name(), strlen(t.get_name()));
    memcpy(r.ip, t.get_ip(), strlen(t.get_ip()));
    memcpy(r.model, t.get_model(), strlen(t.get_model()));
    gFound.push_back(r);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x198, %edx            # imm = 0x198
xorl %esi, %esi
callq 0x2100
leaq 0x32(%rsp), %r14
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x20e0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2190
leaq 0x18a(%rsp), %r14
leaq 0x48(%rbx), %r15
movq %r15, %rdi
callq 0x20e0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2190
leaq 0x12(%rsp), %r14
addq $0x88, %rbx
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2190
movq 0x5347(%rip), %rbx      # 0x82f0
cmpq 0x5348(%rip), %rbx      # 0x82f8
je 0x2fd4
leaq 0x8(%rsp), %rsi
movl $0x198, %edx            # imm = 0x198
movq %rbx, %rdi
callq 0x2190
addq $0x198, %rbx            # imm = 0x198
movq %rbx, 0x531e(%rip)      # 0x82f0
jmp 0x2fe8
leaq 0x530d(%rip), %rdi      # 0x82e8
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq 0x34d2
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/blakewford[P]kab/main.cpp
// Function: loop()
void loop()
{
    int fd = open("/sys/class/gpio/export", O_WRONLY);
    if(fd < 0) return;

    size_t written = write(fd, "24", 2);
    close(fd);

    fd = open("/sys/class/gpio/gpio24/direction", O_WRONLY);
    if(fd < 0) return;

    if(write(fd, "in", 2) < 0) return;
    close(fd);

    char valueString[3];
    fd = open("/sys/class/gpio/gpio24/value", O_RDONLY);
    while(read(fd, valueString, 3) > 0)
    {
        close(fd);

        int32_t value = atoi(valueString);
        printf("%d\n", value);
        toggle(0, value ? true: false);
        usleep(1000*1000);
        fd = open("/sys/class/gpio/gpio24/value", O_RDONLY);
        if(fd < 0) return;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2277(%rip), %rdi      # 0x527a
movl $0x1, %esi
xorl %eax, %eax
callq 0x2150
testl %eax, %eax
js 0x30f0
movl %eax, %ebx
leaq 0x2271(%rip), %rsi      # 0x5291
movl $0x2, %edx
movl %eax, %edi
callq 0x20b0
movl %ebx, %edi
callq 0x23c0
leaq 0x225a(%rip), %rdi      # 0x5294
movl $0x1, %esi
xorl %eax, %eax
callq 0x2150
testl %eax, %eax
js 0x30f0
movl %eax, %ebx
leaq 0x225e(%rip), %rsi      # 0x52b5
movl $0x2, %edx
movl %eax, %edi
callq 0x20b0
testq %rax, %rax
js 0x30f0
movl %ebx, %edi
callq 0x23c0
leaq 0x223e(%rip), %rbx      # 0x52b8
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2150
movl %eax, %ebp
leaq 0x5(%rsp), %r14
leaq 0x21e2(%rip), %r15      # 0x5276
movl $0x3, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x22b0
testq %rax, %rax
jle 0x30f0
movl %ebp, %edi
callq 0x23c0
movq %r14, %rdi
callq 0x2310
movl %eax, %ebp
movq %r15, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x2030
xorl %esi, %esi
testl %ebp, %ebp
setne %sil
xorl %edi, %edi
callq 0x262a
movl $0xf4240, %edi          # imm = 0xF4240
callq 0x2280
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2150
movl %eax, %ebp
testl %eax, %eax
jns 0x3094
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/ska_flat_hash_map/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	ska::flat_hash_map<uint32_t, uint32_t, Hash32> h;
	h.max_load_factor(0.75f);
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
#ifndef UDB2_TEST_DEL
		z += ++h[get_key(n, x)];
#else
		auto p = h.insert(std::pair<uint32_t, uint32_t>(get_key(n, x), i));
		if (p.second == false) h.erase(p.first);
#endif
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movl %edi, %ebp
callq 0x17a2
movq %rax, 0x8(%rsp)
xorl %ebx, %ebx
movq %rbx, 0x10(%rsp)
movw $0x33f, 0x18(%rsp)      # imm = 0x33F
movq %rbx, 0x20(%rsp)
movl $0x3f400000, 0x1c(%rsp) # imm = 0x3F400000
testl %ebp, %ebp
je 0x16e1
movl %ebp, %r13d
shrl $0x2, %r13d
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movl %r14d, %eax
shll $0xf, %eax
notl %eax
addl %r14d, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %r14d
shrl $0x10, %r14d
xorl %eax, %r14d
movl %r14d, %eax
xorl %edx, %edx
divl %r13d
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
xorl %eax, %ecx
movl %ecx, (%rsp)
movl %ebx, 0x4(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x17c0
testb $0x1, %dl
jne 0x16d2
movb $-0x1, (%rax)
decq 0x20(%rsp)
movb 0xc(%rax), %cl
testb %cl, %cl
jle 0x16d2
decb %cl
movq 0x10(%rax), %rdx
movq %rdx, 0x4(%rax)
movb %cl, (%rax)
movb $-0x1, 0xc(%rax)
movb 0x18(%rax), %cl
addq $0xc, %rax
jmp 0x16b5
incl %ebx
cmpl %ebp, %ebx
jne 0x1632
movq 0x20(%rsp), %rbx
movq 0x38f8(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1a43(%rip), %rsi      # 0x3135
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x10f0
leaq 0x8(%rsp), %rdi
movl 0x18(%rdi), %ebx
callq 0x1732
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1732
movq %rbx, %rdi
callq 0x1110
nop
// File: /workspace/github_cpp_makefile_star2_O3/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>>>>::~sherwood_v3_table()
void clear()
    {
        for (EntryPointer it = entries, end = it + static_cast<ptrdiff_t>(num_slots_minus_one + max_lookups); it != end; ++it)
        {
            if (it->has_value())
                it->destroy_value();
        }
        num_elements = 0;
    }

// Assembly:
pushq %rbx
movq (%rdi), %rbx
movq 0x8(%rdi), %rax
movsbq 0x11(%rdi), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,4), %rdx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdx,%rcx,4), %rdx
cmpq %rdx, %rbx
je 0x1771
shlq $0x2, %rcx
leaq (%rcx,%rax,4), %rax
xorl %ecx, %ecx
cmpb $0x0, (%rbx,%rcx)
js 0x1768
movb $-0x1, (%rbx,%rcx)
addq $0xc, %rcx
cmpq %rcx, %rax
jne 0x175e
movq $0x0, 0x18(%rdi)
callq 0x17a2
cmpq %rbx, %rax
je 0x178c
movq %rbx, %rdi
popq %rbx
jmp 0x10c0
popq %rbx
retq
movq %rax, %rdi
callq 0x1796
// File: /workspace/github_cpp_makefile_star2_O3/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), %esi
movabsq $-0x61c8864680b583eb, %rax # imm = 0x9E3779B97F4A7C15
imulq %rsi, %rax
movb 0x10(%rdi), %cl
shrq %cl, %rax
movq (%rdi), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,4), %rdx
cmpb $0x0, (%rdx)
js 0x1804
xorl %ecx, %ecx
movq %rdx, %rax
cmpl 0x4(%rax), %esi
je 0x1813
leaq 0xc(%rax), %rdx
incb %cl
cmpb %cl, 0xc(%rax)
movq %rdx, %rax
jge 0x17ef
jmp 0x1806
xorl %ecx, %ecx
movsbl %cl, %esi
movq %r8, %rcx
callq 0x1818
jmp 0x1815
xorl %edx, %edx
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
callq 0x17a2
cmpq %r14, %rax
je 0x2104
movq %r14, %rdi
callq 0x10c0
callq 0x17a2
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movw $0x33f, 0x10(%rbx)      # imm = 0x33F
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %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 0x3b78
movslq %edx, %rcx
addq (%r14), %rcx
movabsq $0x100500000200, %rsi   # imm = 0x100500000200
movzbl (%rcx), %edi
cmpq $0x2c, %rdi
ja 0x3b78
btq %rdi, %rsi
jae 0x3b78
incl %edx
incq %rcx
cmpl %edx, %eax
jne 0x3b5e
jmp 0x3bc6
cmpl %eax, %edx
jge 0x3bc6
movslq %edx, %r13
movabsq $0xac1000000000, %r12   # imm = 0xAC1000000000
movq (%r14), %rax
movsbl (%rax,%r13), %r15d
movl %r15d, %edi
callq 0x21e0
testl %eax, %eax
jne 0x3bae
movzbl %r15b, %eax
cmpl $0x2f, %eax
ja 0x3bc6
movl %eax, %eax
btq %rax, %r12
jae 0x3bc6
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x2180
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0x3b89
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 0x3bf3
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0x4577
movq %rsi, %r14
movl %edx, %r13d
shlq $0x3, %r13
xorl %r15d, %r15d
leaq -0x29(%rbp), %r12
movq %r14, %rax
movl %r15d, %ecx
sarq %cl, %rax
movb %al, -0x29(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6694
addq $0x8, %r15
cmpq %r15, %r13
jne 0x4557
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
testq %rdi, %rdi
je 0x45a0
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x8(%rdi), %rax
testl %eax, %eax
jle 0x45e4
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
movl $0x2b, %edi
movb (%rdx,%rsi), %cl
addb $-0x2a, %cl
cmpb $0x6, %cl
jae 0x45d8
movzbl %cl, %r8d
btl %r8d, %edi
jb 0x45e7
incq %rsi
cmpq %rsi, %rax
jne 0x45c3
xorl %eax, %eax
jmp 0x45f7
xorl %eax, %eax
retq
shlb $0x3, %cl
movabsq $0x2f2b2d2b2b2a, %rax   # imm = 0x2F2B2D2B2B2A
shrq %cl, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45f9
testl %eax, %eax
js 0x492a
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x4a23
movq (%r15), %rax
cmpb $0x30, (%rax)
jne 0x49a5
movzbl 0x1(%rax), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x49a5
xorl %r12d, %r12d
cmpl $0x3, %r14d
jl 0x4a1d
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 0xc782(%rip), %xmm0     # 0x110f8
callq 0x21a0
movsd %xmm0, -0x40(%rbp)
movq (%r15), %rax
movsbl (%rax,%rbx), %edi
callq 0x4477
cvttsd2si -0x40(%rbp), %ecx
cwtl
imull %ecx, %eax
addl %eax, %r12d
incq %rbx
decl %r14d
cmpq %rbx, %r13
jne 0x4966
jmp 0x4a12
movq %r15, %rdi
callq 0x44c3
testb %al, %al
je 0x4a3d
xorl %r12d, %r12d
testl %r14d, %r14d
jle 0x4a1d
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 0xc71b(%rip), %xmm0     # 0x11100
callq 0x22f0
movsd %xmm0, -0x40(%rbp)
movq (%r15), %rax
movsbl (%rax,%r14), %edi
callq 0x4477
cvttsd2si -0x40(%rbp), %ecx
cwtl
imull %ecx, %eax
addl %eax, %r12d
incq %r14
decl %ebx
cmpq %r14, %r13
jne 0x49d6
movslq %r12d, %r12
movq -0x38(%rbp), %rbx
movl -0x2c(%rbp), %r13d
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x4523
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 0x4a2b
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa272
movslq %edx, %rcx
addq (%r15), %rcx
movzbl (%rcx), %esi
cmpl $0x20, %esi
je 0xa267
cmpl $0x9, %esi
jne 0xa272
incl %edx
incq %rcx
cmpl %edx, %eax
jne 0xa25a
movl %eax, %edx
movq %r15, %rdi
movl %edx, %esi
callq 0x3c1c
movq %rax, %r13
movq %rax, %rdi
callq 0x62c1
movq %rax, %r12
addq $0x20, %r13
movq %r13, %rdi
callq 0x62c1
movq %rax, %r13
cmpb $0x0, 0x40(%r12)
jne 0xa2a8
cmpb $0x0, 0x40(%r13)
je 0xa2c1
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %r14d, %r8d
callq 0x6f09
jmp 0xa373
leaq 0x7371(%rip), %rsi      # 0x11639
movq %r12, %rdi
callq 0x20a0
testl %eax, %eax
je 0xa2e7
leaq 0x6ee8(%rip), %rsi      # 0x111c3
movq %r12, %rdi
callq 0x20a0
testl %eax, %eax
jne 0xa362
leaq 0x6f10(%rip), %rsi      # 0x111fe
movq %r13, %rdi
callq 0x20a0
testl %eax, %eax
je 0xa30d
leaq 0x6f02(%rip), %rsi      # 0x11203
movq %r13, %rdi
callq 0x20a0
testl %eax, %eax
jne 0xa362
movq 0xacc4(%rip), %rdi      # 0x14fd8
leaq 0x7129(%rip), %rsi      # 0x11444
movl $0x33, %edx
callq 0x2210
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0xaca5(%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 0x6ac4
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_O3/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 0x6694
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 0xbb9d
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21d0
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movl $0x1, %edx
movl %r14d, %ecx
callq 0x48ee
movq -0x40(%rbp), %r12
movq -0x30(%rbp), %r15
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xbbcf
movb (%r12), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0xbbda
movq %rbx, %rdi
movq %r12, %rdx
callq 0x67cc
subq %r12, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
testq %r12, %r12
je 0xbc17
subq %r12, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x21d0
jmp 0xbc17
jmp 0xbc14
jmp 0xbc14
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbc2b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6948(%rip), %rsi      # 0x16038
leaq -0x210(%rbp), %rdi
movl $0x4, %edx
callq 0x2340
leaq -0x1a0(%rbp), %rdi
callq 0x2060
testb %al, %al
jne 0xf77e
movq 0x58c0(%rip), %rdi      # 0x14fd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq 0x58a5(%rip), %rdi      # 0x14fd8
callq 0x2040
movq %rax, %rdi
callq 0x2130
movq %rax, %rbx
leaq 0x2070(%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 0x6884(%rip), %ecx      # 0x16008
movq 0x6875(%rip), %rax      # 0x16000
subl %eax, %ecx
testl %ecx, %ecx
jle 0xf7c2
xorl %r14d, %r14d
leaq -0x210(%rbp), %rbx
movsbl (%rax,%r14), %esi
movq %rbx, %rdi
callq 0x2040
incq %r14
movl 0x6857(%rip), %ecx      # 0x16008
movq 0x6848(%rip), %rax      # 0x16000
subl %eax, %ecx
movslq %ecx, %rcx
cmpq %rcx, %r14
jl 0xf79b
leaq -0x210(%rbp), %rdi
callq 0x2260
movq 0x57fb(%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 0xf812
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x2280
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf885
movslq %edx, %rcx
addq (%r14), %rcx
movabsq $0x100100000200, %rsi   # imm = 0x100100000200
movzbl (%rcx), %edi
cmpq $0x2c, %rdi
ja 0xf885
btq %rdi, %rsi
jae 0xf885
incl %edx
incq %rcx
cmpl %edx, %eax
jne 0xf86b
jmp 0xf8df
cmpl %eax, %edx
jge 0xf8df
movslq %edx, %r13
movq (%r14), %rax
movsbl (%rax,%r13), %r15d
movzbl %r15b, %r12d
movl %r15d, %edi
callq 0x21e0
testl %eax, %eax
je 0xf8ac
cmpl $0x3a, %r12d
jne 0xf8b8
jmp 0xf8d8
cmpl $0x24, %r12d
je 0xf8b8
cmpl $0x5f, %r12d
jne 0xf8d2
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x2180
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0xf88c
jmp 0xf8df
cmpl $0x3a, %r12d
jne 0xf8df
movb $0x1, 0x6849(%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 0xf90c
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf986
movl %edi, %ebx
movq 0x66a2(%rip), %rsi      # 0x16008
leaq 0x6693(%rip), %rdi      # 0x16000
movl %ebx, %edx
leaq -0x9(%rbp), %rcx
callq 0xd2b8
addl %ebx, 0x6676(%rip)      # 0x15ff4
addl %ebx, 0x6674(%rip)      # 0x15ff8
jmp 0xf988
js 0xf98f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x5642(%rip), %rbx      # 0x14fd8
leaq 0x1e2b(%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_O3/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
movl $0x5, %ebp
leaq -0x95(%rip), %r14       # 0x128c
leaq 0x8(%rsp), %r15
vmovaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x13ae
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1462
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 0x1418
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
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x1418
movq %rbx, %rdi
callq 0x1140
callq 0x1040