LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/margual56[P]Markdown-CLI/src/Component.cpp
// Function: Component::setText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Component::setText(std::string text){
    if(this->children.size() == 0)      // If no components were added before, 
        this->content = {text};         // just set the text (keep the reference NULL, the default)
    else                                // Otherwise,
        this->content = {text, this->children.back()}; // set the reference to the last component added
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
je 0x4a7c
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x4f68
movq 0x58(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%r14)
jmp 0x4aa5
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x4f68
movq $0x0, 0x20(%r14)
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x4370
movq 0x20(%r14), %rax
movq %rax, 0x40(%rbx)
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x4acd
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x42b0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/margual56[P]Markdown-CLI/src/HTML.cpp
// Function: HTML::HTML()
HTML::HTML():Component("html"){
    // Add the head and the body to the list of components
    this->head = new Component("head");
    this->head->setText("<link rel=\"stylesheet\" href=\"default.css\">");
    this->children.push_back(this->head);

    this->body = new Component("body");
    this->children.push_back(this->body);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq -0x90(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x10f73(%rip), %rsi     # 0x16036
leaq 0x10f70(%rip), %rdx     # 0x1603a
leaq -0xa0(%rbp), %r14
movq %r14, %rdi
callq 0x5002
movq %rbx, %rdi
movq %r14, %rsi
callq 0x483c
movq -0xa0(%rbp), %rdi
cmpq %r15, %rdi
je 0x50ff
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x42b0
movl $0x68, %edi
callq 0x42a0
movq %rax, %r15
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x10f1f(%rip), %rsi     # 0x1603b
leaq 0x10f1c(%rip), %rdx     # 0x1603f
leaq -0x80(%rbp), %rdi
callq 0x5002
leaq -0x80(%rbp), %rsi
movq %r15, %rdi
callq 0x483c
movq %r15, 0x68(%rbx)
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x5151
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x42b0
movq 0x68(%rbx), %r14
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x10edc(%rip), %rsi     # 0x16040
leaq 0x10eff(%rip), %rdx     # 0x1606a
leaq -0x60(%rbp), %rdi
callq 0x5002
leaq -0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x4a36
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x5195
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x42b0
movl $0x18, %edi
callq 0x42a0
leaq 0x50(%rbx), %r14
movq 0x68(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x4060
incq 0x60(%rbx)
movl $0x68, %edi
callq 0x42a0
movq %rax, %r15
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x10e94(%rip), %rsi     # 0x1606b
leaq 0x10e91(%rip), %rdx     # 0x1606f
leaq -0x40(%rbp), %rdi
callq 0x5002
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x483c
movq %r15, 0x70(%rbx)
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x520c
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x42b0
movl $0x18, %edi
callq 0x42a0
movq 0x70(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x4060
incq 0x60(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x5285
movq -0x30(%rbp), %rsi
jmp 0x5278
jmp 0x5282
movq %rax, %r14
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x52b7
movq -0x50(%rbp), %rsi
incq %rsi
jmp 0x528d
jmp 0x52b4
movq %rax, %r14
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x5285
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x42b0
jmp 0x5285
movq %rax, %r14
movl $0x68, %esi
movq %r15, %rdi
callq 0x42b0
jmp 0x52b7
movq %rax, %r14
movq -0xa0(%rbp), %rdi
cmpq %r15, %rdi
je 0x52bf
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x42b0
jmp 0x52bf
movq %rax, %r14
movq %rbx, %rdi
callq 0x5944
movq %r14, %rdi
callq 0x44a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/include/ef.gy/exponential.h
// Function: efgy::math::exponentiate::integral<efgy::math::numeric::fractional<long long>, 5l>::raise(efgy::math::numeric::fractional<long long> const&)
constexpr static Q raise(const Q &base) {
    return (exponent % 2 == 0)
               ? integral<Q, (exponent >> 1)>::raise(base * base)
               : (base *
                  integral<Q, ((exponent - 1) >> 1)>::raise(base * base));
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
imulq %rax, %rax
imulq %rcx, %rcx
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
movq %r14, %rdi
callq 0x14406
movq (%r14), %rax
movq 0x8(%r14), %rcx
imulq %rax, %rax
imulq %rcx, %rcx
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x14406
movq (%r14), %rax
movq 0x8(%r14), %rcx
imulq (%rbx), %rax
imulq 0x8(%rbx), %rcx
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x14406
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/KokiKishimoto[P]cp_decomposition/cp.cpp
// Function: ArgPos(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, char**)
int ArgPos(std::string str, int argc, char **argv) {
	int a;
	for (a = 1; a < argc; a++){
		if (str == argv[a]) {
			if (a == argc - 1) {
				std::cout << "Argument missing for" << str << std::endl;
				exit(1);
			}
			return a;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $0x2, %esi
jl 0x25a4
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, %r12d
movl $0x1, %r15d
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x259b
incq %r15
decq %r12
cmpq $0x1, %r12
jne 0x257d
jmp 0x25a4
cmpl $0x2, %r12d
je 0x25af
movl %r15d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x7a1a(%rip), %rdi      # 0x9fd0
leaq 0x4abf(%rip), %rsi      # 0x707c
callq 0x2240
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2220
movq %rax, %rdi
callq 0x2100
movl $0x1, %edi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/KokiKishimoto[P]cp_decomposition/./data.hpp
// Function: Data::addEntity(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int addEntity(std::string entity) {
		if (entity_dict.find(entity) == entity_dict.end()) {
			int id = entity_counter;
			entity_dict[entity] = entity_counter;
			entity_dict_rev[entity_counter] = entity;
			++entity_counter;
			return id;
		} else {
			return entity_dict[entity];
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
movq %r15, %rdi
callq 0x3f4c
leaq 0x10(%r14), %rcx
cmpq %rcx, %rax
je 0x3d7f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e6c
movl (%rax), %ebp
jmp 0x3da9
movl (%r14), %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e6c
movl %ebp, (%rax)
leaq 0x68(%r14), %rdi
movq %r14, %rsi
callq 0x3ee8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
incl (%r14)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/KokiKishimoto[P]cp_decomposition/./data.hpp
// Function: Data::addRelation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int addRelation(std::string relation) {
		if (relation_dict.find(relation) == relation_dict.end()) {
			int id = relation_counter;
			relation_dict[relation] = relation_counter;
			relation_dict_rev[relation_counter] = relation;
			++relation_counter;
			return id;
		} else {
			return relation_dict[relation];
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %r15
movq %r15, %rdi
callq 0x3f4c
leaq 0x40(%r14), %rcx
cmpq %rcx, %rax
je 0x3de8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e6c
movl (%rax), %ebp
jmp 0x3e1b
leaq 0x4(%r14), %r12
movl 0x4(%r14), %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e6c
movl %ebp, (%rax)
leaq 0x98(%r14), %rdi
movq %r12, %rsi
callq 0x3ee8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
incl 0x4(%r14)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/KokiKishimoto[P]cp_decomposition/cp.cpp
// Function: CP::initializeModel(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, int, std::uniform_real_distribution<double>&)
void initializeModel(std::vector< std::vector<double> >& Vec, const int counter, std::uniform_real_distribution<>& dist){
		for (int i = 0; i < counter; i++) {
			Vec[i].resize(vecDim);
			for (int j = 0; j < vecDim; j++) {
				Vec[i][j] = dist(rnd);
			}
		}
	}

// Assembly:
testl %edx, %edx
jle 0x48a6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x208(%rdi), %r12
movl %edx, %eax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
leaq (%rax,%rax,2), %r13
leaq (,%r13,8), %rdi
addq (%r14), %rdi
movslq 0x200(%r15), %rsi
callq 0x48a8
cmpl $0x0, 0x200(%r15)
jle 0x4889
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x4b2b
movsd (%rbx), %xmm1
movsd 0x8(%rbx), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movq (%r14), %rax
movq (%rax,%r13,8), %rax
movsd %xmm2, (%rax,%rbp,8)
incq %rbp
movslq 0x200(%r15), %rax
cmpq %rax, %rbp
jl 0x4851
movq 0x10(%rsp), %rax
incq %rax
cmpq 0x8(%rsp), %rax
jne 0x4825
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x676a
movl 0x4(%r12), %edx
movl 0x8(%r12), %ecx
movl 0x139c(%r14), %esi
imull %eax, %esi
movl 0x13a0(%r14), %edi
imull %edx, %edi
addl %ecx, %edi
addl %esi, %edi
movslq %edi, %rsi
movq 0x10(%r15), %r8
movq %rbp, %rdi
testq %r8, %r8
je 0x5707
movq %rbp, %rdi
xorl %r9d, %r9d
cmpq %rsi, 0x20(%r8)
setl %r9b
cmovgeq %r8, %rdi
movq 0x10(%r8,%r9,8), %r8
testq %r8, %r8
jne 0x56ee
movq %rbp, %r8
cmpq %rbp, %rdi
je 0x571a
cmpq %rsi, 0x20(%rdi)
cmovgq %rbp, %rdi
movq %rdi, %r8
cmpq %rbp, %r8
jne 0x56ac
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x676a
movl (%r12), %edx
movl 0x8(%r12), %ecx
movl 0x139c(%r14), %esi
imull %edx, %esi
movl 0x13a0(%r14), %edi
imull %eax, %edi
addl %ecx, %esi
addl %edi, %esi
movslq %esi, %rsi
movq 0x10(%r15), %r8
movq %rbp, %rdi
testq %r8, %r8
je 0x57f4
movq %rbp, %rdi
xorl %r9d, %r9d
cmpq %rsi, 0x20(%r8)
setl %r9b
cmovgeq %r8, %rdi
movq 0x10(%r8,%r9,8), %r8
testq %r8, %r8
jne 0x57db
movq %rbp, %r8
cmpq %rbp, %rdi
je 0x5807
cmpq %rsi, 0x20(%rdi)
cmovgq %rbp, %rdi
movq %rdi, %r8
cmpq %rbp, %r8
jne 0x579a
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_O1/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 0x66dd
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 0x669f
movq %rbx, %rdi
callq 0x66ea
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/lagoproject[P]arti/analysis/primaries.cc
// Function: Usage(char*, int)
void Usage(char *prog, int iverbose=0) {
  cout << endl << "primaries.cc, from ARTI     version " << VERSION << endl<< endl;
  cout << "  Read primary files and produce primary spectrum with and without geomagnetic field" << endl;
  cout << "  Usage: " << prog << " [flags] raw_file" << endl;
  cout << "    If 'raw_file' does not exits, switch to STDIN and use raw_file as" << endl;
  cout << "    basename for output file." << endl;
  cout << "    flags:"<<endl;
  cout << "      -m <n>          : Energy distribution of primaries per type, with <n> bins per decade."<<endl;
  cout << "      -n <a> <t>      : Normalize energy distribution in particles/(m2 s bin), <a>=detector area (m2), <t> = flux time (s)." <<endl;
  cout << "      -g <file> <col> : Include geomagentic effects. Read  rigidities from column <R> of <file>. Default R= " << cGeoCdef <<endl;
  cout << "                        3=R_U, 4=R_C 5=R_L"<<endl;
  cout << "      -v              : Enable verbose output (each -v increases verbosity level)"<< endl;
  cout << "      -?              : prints help and exits"<<endl << endl;
  if (iverbose) {
    // verbose help
  }
  exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x49b2(%rip), %rbx      # 0x5fc8
movq %rbx, %rdi
callq 0x1070
leaq 0x1b12(%rip), %rsi      # 0x3137
movq %rax, %rdi
callq 0x10f0
leaq 0x1b28(%rip), %rsi      # 0x315c
movq %rax, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1070
leaq 0x1b0e(%rip), %rsi      # 0x3161
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq 0x1b4c(%rip), %rsi      # 0x31b6
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x10f0
leaq 0x1b3c(%rip), %rsi      # 0x31c0
movq %rax, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq 0x1b37(%rip), %rsi      # 0x31d2
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq 0x1b66(%rip), %rsi      # 0x3218
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq 0x1b6d(%rip), %rsi      # 0x3236
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq 0x1b61(%rip), %rsi      # 0x3241
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq 0x1ba7(%rip), %rsi      # 0x329e
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq 0x1c0c(%rip), %rsi      # 0x331a
movq %rbx, %rdi
callq 0x10f0
movl 0x4a1c(%rip), %esi      # 0x6138
movq %rax, %rdi
callq 0x11b0
movq %rax, %rdi
callq 0x1070
leaq 0x1c54(%rip), %rsi      # 0x3387
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq 0x1c68(%rip), %rsi      # 0x33b2
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
leaq 0x1ca3(%rip), %rsi      # 0x3404
movq %rbx, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1070
movl $0x1, %edi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O1/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 0x13a5
movq %rdi, %rsi
addq $0x8, %rdi
callq 0x1090
testl %ebx, %ebx
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15f0
movl %edi, %ebp
movq 0x8(%rbx), %rdi
leaq 0xa65(%rip), %rsi       # 0x202e
movl $0x3, %edx
callq 0x1070
testl %eax, %eax
jne 0x15f0
movq 0x18(%rbx), %rdi
leaq 0xa4f(%rip), %rsi       # 0x2031
movl $0x3, %edx
callq 0x1070
testl %eax, %eax
je 0x160f
movq (%rbx), %rdi
callq 0x12ec
movl $0x1, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %rdi
movl $0x10, %edx
callq 0x1110
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl %ebp, %r15d
movl $0x4, %r14d
movq (%rbx,%r14,8), %rbp
movl $0x210, %edi            # imm = 0x210
callq 0x10f0
movq %rax, %r12
movq %rax, %r13
addq $0x8, %r13
movq %r13, %rdi
movq %rbp, %rsi
movl $0x8, %edx
callq 0x11a0
movq %r12, 0x20(%rsp)
movq 0x8(%r12), %rax
movq -0x18(%rax), %rax
movl 0x28(%r12,%rax), %ebp
testl %ebp, %ebp
jne 0x16b3
movq %r13, %rdi
movq %r12, %rsi
callq 0x1090
testl %ebp, %ebp
jne 0x16b3
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x16a6
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x16b3
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1a66
incq %r14
cmpq %r14, %r15
jne 0x163c
movq %rsp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x13ac
leaq 0x28(%rsp), %rdi
callq 0x1130
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x16e8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x28e1(%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 0x10c0
leaq 0x120(%rsp), %rdi
callq 0x1040
xorl %eax, %eax
jmp 0x15fd
jmp 0x1735
movq %rax, %rbx
movl $0x210, %esi            # imm = 0x210
movq %r12, %rdi
callq 0x1100
jmp 0x1738
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x174e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
leaq 0x28(%rsp), %rdi
callq 0x1140
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O1/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 0x65f7
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 0xad3(%rip), %xmm2      # 0x7030
movsd 0xad3(%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 0x6569
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH06_Functions/examples/refret-ex.cc
// Function: main
int main() {
    int ia[10];  // array of ten uninitialized ints

    for (int i = 0; i != 10; ++i)
        get(ia, i) = i;  // call get to assign values to the elements

	for (auto i : ia)    // print the elements
		cout << i << " ";
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
movl %eax, -0x40(%rbp,%rax,4)
incq %rax
cmpq $0xa, %rax
jne 0x11f8
xorl %r15d, %r15d
movq 0x2dc9(%rip), %rbx      # 0x3fd8
leaq 0xdee(%rip), %r14       # 0x2004
movl -0x40(%rbp,%r15), %esi
movq %rbx, %rdi
callq 0x1090
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
addq $0x4, %r15
cmpq $0x28, %r15
jne 0x1216
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/blakewford[P]kab/main.cpp
// Function: buildQuery()
void buildQuery()
{
    memset(query, '\0', sizeof(query));

    time_t now = time(nullptr);
    now += 20637;
    now = bswap_32(now) >> 16;

    query[24] = 0xE2;
    query[25] = 0x07;
    query[26] = 0x0C;
    query[27] = 0x09;
    query[28] = now >> 8;
    query[29] = now & 0x00FF;
}

// Assembly:
pushq %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x5d13(%rip)     # 0x82a0
movaps %xmm0, 0x5cfc(%rip)     # 0x8290
movaps %xmm0, 0x5ce5(%rip)     # 0x8280
movaps %xmm0, 0x5cce(%rip)     # 0x8270
movaps %xmm0, 0x5cb7(%rip)     # 0x8260
movaps %xmm0, 0x5ca0(%rip)     # 0x8250
movaps %xmm0, 0x5c89(%rip)     # 0x8240
movaps %xmm0, 0x5c72(%rip)     # 0x8230
xorl %edi, %edi
callq 0x21d0
addl $0x509d, %eax           # imm = 0x509D
bswapl %eax
movl %eax, %ecx
shrl $0x10, %ecx
movl $0x90c07e2, 0x5c6d(%rip) # imm = 0x90C07E2
shrl $0x18, %eax
movb %al, 0x5c68(%rip)       # 0x824c
movb %cl, 0x5c63(%rip)       # 0x824d
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/blakewford[P]kab/main.cpp
// Function: initializeCommand(command&)
void initializeCommand(command& c)
{
    memset(&c, '\0', sizeof(command));

    c.cmd     = MODIFY_SWITCH;
    c.counter = 0x55555555;
    c.type    = 2;
    c.op      = 2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x82, %edx
xorl %esi, %esi
callq 0x2100
movl $0x50016, (%rbx)        # imm = 0x50016
movl $0x55555555, 0x74(%rbx) # imm = 0x55555555
movw $0x2, 0x8(%rbx)
movb $0x2, 0x80(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movl %esi, %ebx
movq %rdi, %rax
movq 0x5cbd(%rip), %rcx      # 0x82f0
movq 0x5cae(%rip), %rsi      # 0x82e8
subq %rsi, %rcx
sarq $0x3, %rcx
movabsq $-0x505050505050505, %rdx # imm = 0xFAFAFAFAFAFAFAFB
imulq %rcx, %rdx
cmpq %rdi, %rdx
jbe 0x274f
imulq $0x198, %rax, %rax      # imm = 0x198
addq %rax, %rsi
leaq 0x98(%rsp), %r14
movl $0x198, %edx            # imm = 0x198
movq %r14, %rdi
callq 0x2190
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 0x21a(%rsp), %rdi
callq 0x2230
shlq $0x20, %rax
orq $0x50000002, %rax       # imm = 0x50000002
movq %rsp, %r15
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
leaq 0x14(%rsp), %r12
movl $0x82, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2100
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 $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bae(%rip), %rdi      # 0x5304
movq %rax, %rsi
xorl %eax, %eax
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x59c5(%rip)      # 0x81f8
movq 0x5a9e(%rip), %rdi      # 0x82d8
xorl %esi, %esi
callq 0x21c0
movq 0x5a90(%rip), %rdi      # 0x82d8
xorl %esi, %esi
callq 0x21c0
movl $0x1, %edi
callq 0x2760
movl %ebx, %edi
popq %rbx
jmp 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x593b(%rip)      # 0x81f8
jne 0x2997
movq %rdi, %rbx
leaq 0x62(%rsp), %r14
leaq 0x1b0(%rsp), %r15
leaq 0x59d6(%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 0x29ab
movq 0x59ca(%rip), %rbp      # 0x82e8
movq 0x59cb(%rip), %r13      # 0x82f0
cmpq %r13, %rbp
je 0x2943
leaq 0x4a(%rbp), %rdi
movq %r14, %rsi
callq 0x2270
testl %eax, %eax
je 0x2982
addq $0x198, %rbp            # imm = 0x198
jmp 0x2925
cmpq 0x59ae(%rip), %r13      # 0x82f8
je 0x296e
movl $0x198, %edx            # imm = 0x198
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2190
addq $0x198, %r13            # imm = 0x198
movq %r13, 0x5984(%rip)      # 0x82f0
jmp 0x2982
leaq 0x5973(%rip), %rdi      # 0x82e8
movq %r13, %rsi
leaq 0x18(%rsp), %rdx
callq 0x34b2
movq %r12, %rdi
callq 0x2160
cmpb $0x0, 0x5867(%rip)      # 0x81f8
jne 0x28da
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 0x58f4(%rip), %rdi      # 0x82b0
callq 0x2160
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d12
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 0x2d12
leaq 0x23dc(%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
movq %rsp, %rbx
movl (%rbx), %eax
leaq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movw $0x76c, 0x4(%rcx)       # imm = 0x76C
leaq 0x5619(%rip), %rdi      # 0x82d8
leaq -0x447(%rip), %rdx      # 0x287f
xorl %esi, %esi
callq 0x2390
leaq -0x473(%rip), %rdx      # 0x2861
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x2390
movl (%rbx), %edi
leaq 0x2380(%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 0x2829
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5382(%rip), %rbx      # 0x82f0
cmpq 0x5383(%rip), %rbx      # 0x82f8
je 0x2f99
leaq 0x8(%rsp), %rsi
movl $0x198, %edx            # imm = 0x198
movq %rbx, %rdi
callq 0x2190
addq $0x198, %rbx            # imm = 0x198
movq %rbx, 0x5359(%rip)      # 0x82f0
jmp 0x2fad
leaq 0x5348(%rip), %rdi      # 0x82e8
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq 0x34b2
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22b2(%rip), %rdi      # 0x527a
movl $0x1, %esi
xorl %eax, %eax
callq 0x2150
testl %eax, %eax
js 0x30b5
movl %eax, %ebx
leaq 0x22ac(%rip), %rsi      # 0x5291
movl $0x2, %edx
movl %eax, %edi
callq 0x20b0
movl %ebx, %edi
callq 0x23c0
leaq 0x2295(%rip), %rdi      # 0x5294
movl $0x1, %esi
xorl %eax, %eax
callq 0x2150
testl %eax, %eax
js 0x30b5
movl %eax, %ebx
leaq 0x2299(%rip), %rsi      # 0x52b5
movl $0x2, %edx
movl %eax, %edi
callq 0x20b0
testq %rax, %rax
js 0x30b5
movl %ebx, %edi
callq 0x23c0
leaq 0x2279(%rip), %rbx      # 0x52b8
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2150
movl %eax, %ebp
leaq 0x5(%rsp), %r14
leaq 0x221d(%rip), %r15      # 0x5276
movl $0x3, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x22b0
testq %rax, %rax
jle 0x30b5
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 0x2618
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 0x3059
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebp
movl %edi, %ebx
callq 0x17c4
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
movq %r12, 0x10(%rsp)
movw $0x33f, 0x18(%rsp)      # imm = 0x33F
movq %r12, 0x20(%rsp)
movl $0x3f400000, 0x1c(%rsp) # imm = 0x3F400000
testl %ebx, %ebx
je 0x1719
movl %ebx, %r13d
shrl $0x2, %r13d
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movl %ebp, %eax
shll $0xf, %eax
notl %eax
addl %ebp, %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, %ebp
shrl $0x10, %ebp
xorl %eax, %ebp
movl %ebp, %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 %r12d, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x17e2
testb $0x1, %dl
jne 0x170d
movb $-0x1, (%rax)
decq 0x20(%rsp)
movb 0xc(%rax), %cl
testb %cl, %cl
jle 0x170d
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 0x16f0
incl %r12d
cmpl %ebx, %r12d
jne 0x1672
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rbx
movq %rbx, %rdx
callq 0x1428
movl (%rbx), %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 0x1754
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1793
shlq $0x2, %rcx
leaq (%rcx,%rax,4), %rax
xorl %ecx, %ecx
cmpb $0x0, (%rbx,%rcx)
js 0x178a
movb $-0x1, (%rbx,%rcx)
addq $0xc, %rcx
cmpq %rcx, %rax
jne 0x1780
movq $0x0, 0x18(%rdi)
callq 0x17c4
cmpq %rbx, %rax
je 0x17ae
movq %rbx, %rdi
popq %rbx
jmp 0x10c0
popq %rbx
retq
movq %rax, %rdi
callq 0x17b8
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1826
xorl %ecx, %ecx
movq %rdx, %rax
cmpl 0x4(%rax), %esi
je 0x1835
leaq 0xc(%rax), %rdx
incb %cl
cmpb %cl, 0xc(%rax)
movq %rdx, %rax
jge 0x1811
jmp 0x1828
xorl %ecx, %ecx
movsbl %cl, %esi
movq %r8, %rcx
callq 0x183a
jmp 0x1837
xorl %edx, %edx
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17c4
cmpq %r14, %rax
je 0x213a
movq %r14, %rdi
callq 0x10c0
callq 0x17c4
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_O1/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
movl %eax, %edx
cmpl 0x8(%r14), %edx
jge 0x3bc8
movslq %edx, %r13
movabsq $0xac1000000000, %r12   # imm = 0xAC1000000000
movq (%r14), %rax
movsbl (%rax,%r13), %r15d
movl %r15d, %edi
callq 0x21e0
testl %eax, %eax
jne 0x3bb0
movzbl %r15b, %eax
cmpl $0x2f, %eax
ja 0x3bc8
movl %eax, %eax
btq %rax, %r12
jae 0x3bc8
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x2180
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0x3b8b
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 0x3bf5
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/lindorx[P]train/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 0x4588
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 0x67f0
addq $0x8, %r15
cmpq %r15, %r13
jne 0x4568
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 0x45b1
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45f5
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 0x45e9
movzbl %cl, %r8d
btl %r8d, %edi
jb 0x45f8
incq %rsi
cmpq %rsi, %rax
jne 0x45d4
xorl %eax, %eax
jmp 0x4608
xorl %eax, %eax
retq
shlb $0x3, %cl
movabsq $0x2f2b2d2b2b2a, %rax   # imm = 0x2F2B2D2B2B2A
shrq %cl, %rax
popq %rbp
retq