LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: attractivechaos[P]udb2/phmap/./phmap.h
// Function: phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::iterator phmap::container_internal::raw_hash_set<phmap::container_internal::FlatHashMapPolicy<unsigned int, unsigned int>, Hash32, phmap::EqualTo<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>>::find<unsigned int>(unsigned int const&, unsigned long)
iterator find(const key_arg<K>& key, size_t hash) {
        auto seq = probe(hash);
        while (true) {
            Group g{ctrl_ + seq.offset()};
            for (int i : g.Match(H2(hash))) {
                if (PHMAP_PREDICT_TRUE(PolicyTraits::apply(
                                          EqualElement<K>{key, eq_ref()},
                                          PolicyTraits::element(slots_ + seq.offset(i)))))
                    return iterator_at(seq.offset(i));
            }
            if (PHMAP_PREDICT_TRUE(g.MatchEmpty())) 
                return end();
            seq.next();
        }
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq 0x80(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x2810
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2860
movq 0x10(%rsp), %rsi
addq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x2870
movq 0x80(%rsp), %rdi
callq 0x2a60
leaq 0x50(%rsp), %rdi
movzbl %al, %esi
callq 0x28a0
movl %eax, 0x44(%rsp)
leaq 0x44(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2a70
movl %eax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2a90
movl %eax, 0x3c(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x2ab0
testb $0x1, %al
jne 0x5153
jmp 0x5204
leaq 0x40(%rsp), %rdi
callq 0x2ad0
movq 0x18(%rsp), %rdi
movl %eax, 0x38(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x2b10
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movslq 0x38(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x2b40
movq 0x8(%rsp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
callq 0x2b30
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x2ae0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x51c5
jmp 0x51f3
movslq 0x38(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x2b40
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x2530
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
jmp 0x5251
jmp 0x51f5
leaq 0x40(%rsp), %rdi
callq 0x2b90
jmp 0x513b
leaq 0x50(%rsp), %rdi
callq 0x2bb0
movl %eax, 0x24(%rsp)
leaq 0x24(%rsp), %rdi
callq 0x2be0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5226
jmp 0x5242
movq 0x18(%rsp), %rdi
callq 0x5270
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
jmp 0x5251
leaq 0x68(%rsp), %rdi
callq 0x2c00
jmp 0x50ce
movq 0x98(%rsp), %rax
movq 0xa0(%rsp), %rdx
addq $0xa8, %rsp
retq
nopl (%rax)
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: vector_for_label_ascii(int)
double *vector_for_label_ascii(int label) {
	double *vec = new double[ASCII_LENGTH];
	unsigned char c = (unsigned char)label + 48;
	for(int i=0; i < ASCII_LENGTH; i++) {
		vec[i] = (double)(c & 1);
		c = c >> 1;
	}
	return vec;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x40, %edi
callq 0x2030
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
movzbl %al, %eax
addl $0x30, %eax
movb %al, 0x7(%rsp)
movl $0x0, (%rsp)
cmpl $0x8, (%rsp)
jge 0x2802
movzbl 0x7(%rsp), %eax
andl $0x1, %eax
cvtsi2sd %eax, %xmm0
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movzbl 0x7(%rsp), %eax
sarl %eax
movb %al, 0x7(%rsp)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x27cc
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: label_for_vector_ascii(double*)
int label_for_vector_ascii(double *vec) {
	unsigned char label = 0;
	for(int i=0; i < ASCII_LENGTH; i++) {
		label |= int(vec[i] + 0.5) << i;
	}
	return label - 48;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movb $0x0, -0x9(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x8, -0x10(%rsp)
jge 0x2864
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movsd 0x37cd(%rip), %xmm0     # 0x6008
addsd (%rax,%rcx,8), %xmm0
cvttsd2si %xmm0, %eax
movl -0x10(%rsp), %ecx
shll %cl, %eax
movl %eax, %ecx
movzbl -0x9(%rsp), %eax
orl %ecx, %eax
movb %al, -0x9(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x2822
movzbl -0x9(%rsp), %eax
subl $0x30, %eax
retq
nopl (%rax)
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: vector_for_label_packed(int)
double *vector_for_label_packed(int label) {
	double *vec = new double[PACKED_LENGTH];
	char c = (char)label;
	for(int i=0; i < PACKED_LENGTH; i++) {
		vec[i] = (double)(c & 1);
		c = c >> 1;
	}
	return vec;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x20, %edi
callq 0x2030
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
movb %al, 0x7(%rsp)
movl $0x0, (%rsp)
cmpl $0x4, (%rsp)
jge 0x28cc
movsbl 0x7(%rsp), %eax
andl $0x1, %eax
cvtsi2sd %eax, %xmm0
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movsbl 0x7(%rsp), %eax
sarl %eax
movb %al, 0x7(%rsp)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x2896
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: label_for_vector_packed(double*)
int label_for_vector_packed(double *vec) {
	int label = 0;
	for(int i=0; i < PACKED_LENGTH; i++) {
		label |= int(vec[i] + 0.5) << i;
	}
	return label;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x4, -0x10(%rsp)
jge 0x2932
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movsd 0x36fa(%rip), %xmm0     # 0x6008
addsd (%rax,%rcx,8), %xmm0
cvttsd2si %xmm0, %eax
movl -0x10(%rsp), %ecx
shll %cl, %eax
orl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x28f5
movl -0xc(%rsp), %eax
retq
nopw (%rax,%rax)
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: vector_for_label_full(int)
double *vector_for_label_full(int label) {
	double *vec = new double[FULL_LENGTH];
	for(int i=0; i < FULL_LENGTH; i++) {
		vec[i] = (i == label) ? 1.0 : 0.0;
	}
	return vec;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl $0x50, %edi
callq 0x2030
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0xa, 0x14(%rsp)
jge 0x29b5
movl 0x14(%rsp), %eax
movl 0x24(%rsp), %ecx
movsd 0x369a(%rip), %xmm0     # 0x6010
xorps %xmm1, %xmm1
movsd %xmm1, (%rsp)
cmpl %ecx, %eax
movsd %xmm0, 0x8(%rsp)
je 0x2993
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x295f
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: label_for_vector_full(double*)
int label_for_vector_full(double *vec) {
	double max = 0.0;
	int maxi = 0;
	for(int i=0; i < FULL_LENGTH; i++) {
		if(vec[i] > max) {
			max = vec[i];
			maxi = i;
		}
	}
	return maxi;
}

// Assembly:
movq %rdi, -0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
cmpl $0xa, -0x18(%rsp)
jge 0x2a28
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x10(%rsp), %xmm0
jbe 0x2a19
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x10(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x14(%rsp)
jmp 0x2a1b
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x29de
movl -0x14(%rsp), %eax
retq
nopl (%rax)
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: print_vec(double*, int)
void print_vec(double *vec, int len) {
	using namespace std;
	cout << "Vec: ";
	for(int i=0; i < len; i++) {
		cout << int(vec[i] + 0.5) << " ";
	}
	cout << endl;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x558c(%rip), %rdi      # 0x7fd0
leaq 0x35dd(%rip), %rsi      # 0x6028
callq 0x2150
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x2aa5
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd 0x3594(%rip), %xmm0     # 0x6008
addsd (%rax,%rcx,8), %xmm0
cvttsd2si %xmm0, %esi
movq 0x554c(%rip), %rdi      # 0x7fd0
callq 0x2260
movq %rax, %rdi
leaq 0x3647(%rip), %rsi      # 0x60da
callq 0x2150
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2a58
movq 0x5524(%rip), %rdi      # 0x7fd0
movq 0x5505(%rip), %rsi      # 0x7fb8
callq 0x2180
addq $0x18, %rsp
retq
nopl (%rax)
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::~DataSet()
DataSet::~DataSet() {
	for(int i=0; i < num_entries; i++) {
		delete[] image_data[i];
		delete[] label_data[i];
	}
	delete[] image_data;
	delete[] label_data;
	delete[] labels;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x30(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl (%rcx), %eax
jge 0x3395
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x335f
movq 0x28(%rsp), %rdi
callq 0x2210
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x3386
movq 0x20(%rsp), %rdi
callq 0x2210
jmp 0x3388
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x332b
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x33b3
movq 0x18(%rsp), %rdi
callq 0x2210
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x33d1
movq 0x10(%rsp), %rdi
callq 0x2210
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x33ef
movq 0x8(%rsp), %rdi
callq 0x2210
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::label_for_vector(double*)
int DataSet::label_for_vector(double *vec) {
	int label = -1;
	switch(label_data_length) {
		case ASCII_LENGTH:
			label = label_for_vector_ascii(vec);
			break;
		case PACKED_LENGTH:
			label = label_for_vector_packed(vec);
			break;
		case FULL_LENGTH:
			label = label_for_vector_full(vec);
			break;
	}
	return label;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movl 0x8(%rax), %eax
movl %eax, (%rsp)
subl $0x4, %eax
je 0x34dc
jmp 0x34b8
movl (%rsp), %eax
subl $0x8, %eax
je 0x34cc
jmp 0x34c2
movl (%rsp), %eax
subl $0xa, %eax
je 0x34ec
jmp 0x34fa
movq 0x8(%rsp), %rdi
callq 0x2810
movl %eax, 0x4(%rsp)
jmp 0x34fa
movq 0x8(%rsp), %rdi
callq 0x28e0
movl %eax, 0x4(%rsp)
jmp 0x34fa
movq 0x8(%rsp), %rdi
callq 0x29c0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::print_image(int, int, int)
void DataSet::print_image(int n, int width, int height) {
	using namespace std;
	
	double *img = this->image_vector(n);
	for(int y=0; y < height; y ++) {
		for(int x=0; x < width; x ++) {
			double pixel = img[y * height + x];
			if(pixel == 0.0) {
				cout << "  ";
			} else if(pixel < 0.9) {
				cout << "..";
			} else {
				cout << "##";
			}
		}
		cout << endl;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x3430
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x3619
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x35f6
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
imull 0x24(%rsp), %ecx
addl 0x10(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x35aa
jp 0x35aa
movq 0x4a34(%rip), %rdi      # 0x7fd0
leaq 0x2b36(%rip), %rsi      # 0x60d9
callq 0x2150
jmp 0x35e4
movsd 0x2a6e(%rip), %xmm0     # 0x6020
ucomisd 0x8(%rsp), %xmm0
jbe 0x35cf
movq 0x4a0f(%rip), %rdi      # 0x7fd0
leaq 0x2b14(%rip), %rsi      # 0x60dc
callq 0x2150
jmp 0x35e2
movq 0x49fa(%rip), %rdi      # 0x7fd0
leaq 0x2b02(%rip), %rsi      # 0x60df
callq 0x2150
jmp 0x35e4
jmp 0x35e6
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x3556
movq 0x49d3(%rip), %rdi      # 0x7fd0
movq 0x49b4(%rip), %rsi      # 0x7fb8
callq 0x2180
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3540
addq $0x38, %rsp
retq
nop
// File: ghulette[P]neural-net-openmp/dataset.cpp
// Function: DataSet::print_label(int)
void DataSet::print_label(int n) {
	using namespace std;
	
	double *label = this->label_vector(n);
	cout << "[" << label[0];
	for(int i=1; i < this->label_vector_length(); i++) {
		cout << ", " << label[i];
	}
	cout << "]" << endl;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl 0x2c(%rsp), %esi
callq 0x3450
movq %rax, 0x20(%rsp)
movq 0x4984(%rip), %rdi      # 0x7fd0
leaq 0x2a8f(%rip), %rsi      # 0x60e2
callq 0x2150
movq %rax, %rdi
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
callq 0x22d0
movl $0x1, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x3420
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x36c4
movq 0x493c(%rip), %rdi      # 0x7fd0
leaq 0x2a49(%rip), %rsi      # 0x60e4
callq 0x2150
movq %rax, %rdi
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x22d0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3671
movq 0x4905(%rip), %rdi      # 0x7fd0
leaq 0x2a15(%rip), %rsi      # 0x60e7
callq 0x2150
movq %rax, %rdi
movq 0x48d7(%rip), %rsi      # 0x7fb8
callq 0x2180
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ghulette[P]neural-net-openmp/neuralnet.cpp
// Function: NeuralNet::~NeuralNet()
NeuralNet::~NeuralNet() {
  delete[] hidden_weights;
  delete[] hidden_weights_buffer;
  delete[] hidden_weight_deltas;
  delete[] hidden_values;

  delete[] output_weights;
  delete[] output_weights_buffer;
  delete[] output_weight_deltas;
  delete[] output_values;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, %rax
je 0x49dc
movq 0x48(%rsp), %rdi
callq 0x2210
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x49fa
movq 0x38(%rsp), %rdi
callq 0x2210
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x4a18
movq 0x30(%rsp), %rdi
callq 0x2210
movq 0x40(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x4a36
movq 0x28(%rsp), %rdi
callq 0x2210
movq 0x40(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x4a54
movq 0x20(%rsp), %rdi
callq 0x2210
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x4a72
movq 0x18(%rsp), %rdi
callq 0x2210
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x4a90
movq 0x10(%rsp), %rdi
callq 0x2210
movq 0x40(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x4aae
movq 0x8(%rsp), %rdi
callq 0x2210
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ghulette[P]neural-net-openmp/neuralnet.cpp
// Function: NeuralNet::run(double*)
double *NeuralNet::run(double *input) {
  double *iv = input;
  double *hv = hidden_values;
  double *ov = output_values;
  
  // Propagate from input to hidden layer
  #pragma omp parallel for
  for(int i=0; i < num_hidden; i++) {
    double sum = 0.0;
    for(int j=0; j < num_inputs; j++) {
      sum += iv[j] * hidden_weights[i][j];
    }
    hv[i] = sigmoid(sum);
  }
  
  // Propagate from hidden to output layer
  #pragma omp parallel for
  for(int i=0; i < num_outputs; i++) {
    double sum = 0.0;
    for(int j=0; j < num_hidden; j++) {
      sum += hv[j] * output_weights[i][j];
    }
    ov[i] = sigmoid(sum);
  }
  
  return ov;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movq 0x28(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x48(%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq (%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x4b9e
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jge 0x4b74
movq (%rsp), %rax
movq 0x40(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x1c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4b1d
movsd 0x20(%rsp), %xmm0
callq 0x5010
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x4afb
movl $0x0, 0x18(%rsp)
movq (%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4c4a
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x4c20
movq (%rsp), %rax
movq 0x38(%rsp), %rcx
movslq 0xc(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x30(%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4bc8
movsd 0x10(%rsp), %xmm0
callq 0x5010
movq 0x30(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4ba6
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ghulette[P]neural-net-openmp/neuralnet.cpp
// Function: NeuralNet::mse(double*)
double NeuralNet::mse(double *desired_values) {
  double sum = 0.0;
  for(int i=0; i < num_outputs; i++) {
    double diff = desired_values[i] - output_values[i];
    sum += diff * diff;
  }
  return sum;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x30(%rsp), %rcx
movl -0x1c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4fd8
movq -0x30(%rsp), %rax
movq -0x10(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x48(%rax), %rax
movslq -0x1c(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x28(%rsp), %xmm0
movsd -0x28(%rsp), %xmm2
movsd -0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x4f75
movsd -0x18(%rsp), %xmm0
retq
nop
// File: lotka[P]prologplusplus/main.cpp
// Function: main
int main()
{
	cout << "Prolog++" << endl;
	cout << "~~~~~~~~~~~~~~~~~~~~~" << endl;
	cout << "Preloaded facts: " << endl << endl;
	consult_test("equal(X,X).");
	consult_test("basic(a,b,c).");
	consult_test("person(alice).");
	consult_test("person(bob).");
	cout << endl;

	while(not cin.eof())
	{
		string input;
		cout << "| ?- ";
		cin >> input;
		query_test(input);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movq 0xb5fa(%rip), %rdi      # 0xdfd0
leaq 0x663b(%rip), %rsi      # 0x9018
callq 0x2190
movq %rax, %rdi
movq 0xb5d4(%rip), %rsi      # 0xdfc0
callq 0x21c0
movq 0xb5d8(%rip), %rdi      # 0xdfd0
leaq 0x6622(%rip), %rsi      # 0x9021
callq 0x2190
movq %rax, %rdi
movq 0xb5b2(%rip), %rsi      # 0xdfc0
callq 0x21c0
movq 0xb5b6(%rip), %rdi      # 0xdfd0
leaq 0x6616(%rip), %rsi      # 0x9037
callq 0x2190
movq %rax, %rdi
movq 0xb590(%rip), %rsi      # 0xdfc0
callq 0x21c0
movq %rax, %rdi
movq 0xb581(%rip), %rsi      # 0xdfc0
callq 0x21c0
leaq 0x65fe(%rip), %rdi      # 0x9049
callq 0x2570
leaq 0x65fe(%rip), %rdi      # 0x9055
callq 0x2570
leaq 0x6600(%rip), %rdi      # 0x9063
callq 0x2570
leaq 0x6603(%rip), %rdi      # 0x9072
callq 0x2570
movq 0xb555(%rip), %rdi      # 0xdfd0
movq 0xb53e(%rip), %rsi      # 0xdfc0
callq 0x21c0
movq 0xb552(%rip), %rax      # 0xdfe0
movq (%rax), %rax
movq 0xb548(%rip), %rdi      # 0xdfe0
addq -0x18(%rax), %rdi
callq 0x2300
xorb $-0x1, %al
testb $0x1, %al
jne 0x2aac
jmp 0x2b3b
leaq -0x28(%rbp), %rdi
callq 0x2280
movq 0xb514(%rip), %rdi      # 0xdfd0
leaq 0x65bc(%rip), %rsi      # 0x907f
callq 0x2190
jmp 0x2aca
movq 0xb50f(%rip), %rdi      # 0xdfe0
leaq -0x28(%rbp), %rsi
callq 0x2250
jmp 0x2adc
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20a0
jmp 0x2aeb
leaq -0x58(%rbp), %rdi
callq 0x2670
jmp 0x2af6
leaq -0x58(%rbp), %rdi
callq 0x20f0
leaq -0x28(%rbp), %rdi
callq 0x20f0
jmp 0x2a87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x20f0
leaq -0x28(%rbp), %rdi
callq 0x20f0
jmp 0x2b44
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: lotka[P]prologplusplus/atom.cpp
// Function: Atom::Atom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Atom::Atom(string n)
{
	name = n;
	if('A' <= n[0] and n[0] <= 'Z')
	{
		free_variable = true;
	}
	else
	{
		free_variable = false;
	}
	if(n.size() == 1 and n[0] == '_')
	{
		cout << "UNDERSCORE DETECTED" << endl;
		is_under_score = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x2280
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3fa0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2030
jmp 0x3d58
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2330
movq %rax, -0x48(%rbp)
jmp 0x3d6b
movq -0x48(%rbp), %rax
movsbl (%rax), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x3dc4
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2330
movq %rax, -0x50(%rbp)
jmp 0x3d8e
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5a, %eax
jg 0x3dc4
movq -0x40(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0x3dcc
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2e70
movq -0x30(%rbp), %rdi
callq 0x20f0
jmp 0x3e33
movq -0x40(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x28(%rbp), %rdi
callq 0x2110
cmpq $0x1, %rax
jne 0x3e2d
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2330
movq %rax, -0x58(%rbp)
jmp 0x3dee
movq -0x58(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0x3e2d
movq 0xa1cf(%rip), %rdi      # 0xdfd0
leaq 0x52c1(%rip), %rsi      # 0x90c9
callq 0x2190
movq %rax, -0x60(%rbp)
jmp 0x3e13
movq -0x60(%rbp), %rdi
movq 0xa1a2(%rip), %rsi      # 0xdfc0
callq 0x21c0
jmp 0x3e25
movq -0x40(%rbp), %rax
movb $0x1, 0x21(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: lotka[P]prologplusplus/atom.cpp
// Function: Atom::unifyWith(Atom*)
bool Atom::unifyWith(Atom * a)
{
  if(a->free_variable)
  {
    if(not free_variable)
    {
      a->possibilties.push_back(this);
    }
    else
    {
      cout << "not sure what to do here" << endl;
    }
    return true;
  }
  else if(*a == *this)
  {
    return true;
  }
  else
  {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x3eaf
movq -0x28(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0x3e87
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x3fc0
jmp 0x3ea9
movq 0xa142(%rip), %rdi      # 0xdfd0
leaq 0x5248(%rip), %rsi      # 0x90dd
callq 0x2190
movq %rax, %rdi
movq 0xa11c(%rip), %rsi      # 0xdfc0
callq 0x21c0
movb $0x1, -0x1(%rbp)
jmp 0x3ecc
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x3ee0
testb $0x1, %al
jne 0x3ec2
jmp 0x3ec8
movb $0x1, -0x1(%rbp)
jmp 0x3ecc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lotka[P]prologplusplus/atom.cpp
// Function: Atom::operator==(Atom&)
bool Atom::operator == (Atom &b)
{
  if(b.free_variable or free_variable)
  {
    return true;
  }
  if(this->name == b.name)
  {
    return true;
  }
  else
  {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0x3f0c
movq -0x20(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x3f12
movb $0x1, -0x1(%rbp)
jmp 0x3f2f
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ff0
testb $0x1, %al
jne 0x3f25
jmp 0x3f2b
movb $0x1, -0x1(%rbp)
jmp 0x3f2f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lotka[P]prologplusplus/parser.cpp
// Function: cropString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
string cropString(string &input_string, int n)
{
	string crop;
	int i = 0;
	for(i = 0; i < input_string.size(); ++i)
	{
		if(i == n)
		{
			break;
		}
		else
		{
			crop.push_back(input_string[i]);
		}
	}
	input_string.erase(0,i+1);
	return crop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x2280
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2110
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x4a47
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x49fc
jmp 0x4a47
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2330
movq %rax, -0x50(%rbp)
jmp 0x4a0f
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rax
movsbl (%rax), %esi
callq 0x2160
jmp 0x4a21
jmp 0x4a3a
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x20f0
jmp 0x4a7b
jmp 0x4a3c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x49d5
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
incl %eax
movslq %eax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x2050
jmp 0x4a5e
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x4a71
movq -0x40(%rbp), %rdi
callq 0x20f0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: lotka[P]prologplusplus/parser.cpp
// Function: cropString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
string cropString(string &input_string, char delimiter)
{
	string crop;
	int i = 0;
	for(i = 0;i < input_string.size(); ++i)
	{
		if(input_string[i] == delimiter)
		{
			break;
		}
		else
		{
			crop.push_back(input_string[i]);
		}
	}
	input_string.erase(0,i+1);
	return crop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x2280
movl $0x0, -0x18(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2110
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x4b56
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x2330
movq %rax, -0x48(%rbp)
jmp 0x4af7
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4b1f
jmp 0x4b56
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20f0
jmp 0x4b8a
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x2330
movq %rax, -0x50(%rbp)
jmp 0x4b32
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rax
movsbl (%rax), %esi
callq 0x2160
jmp 0x4b44
jmp 0x4b46
jmp 0x4b48
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4ac7
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
incl %eax
movslq %eax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x2050
jmp 0x4b6d
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x4b80
movq -0x38(%rbp), %rdi
callq 0x20f0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: lotka[P]prologplusplus/parser.cpp
// Function: countChar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
int countChar(string s, char c)
{
	int count = 0;
	for(int i = 0; i < s.size(); ++i)
	{
		if(s[i]==c)
		{
			++count;
		}
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2110
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x4c0f
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x2330
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4c02
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4c04
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4bc4
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotka[P]prologplusplus/parser.cpp
// Function: strip_ws(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string strip_ws(string s)
{
	string new_s;
	for(int i = 0; i < s.size(); ++i)
	{
		if(s[i]!=' ')
		{
			new_s.push_back(s[i]);
		}
	}
	return new_s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2280
movl $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x2110
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x4d89
movq -0x40(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x2330
movq %rax, -0x50(%rbp)
jmp 0x4d2f
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x4d79
movq -0x40(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x2330
movq %rax, -0x58(%rbp)
jmp 0x4d4e
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rax
movsbl (%rax), %esi
callq 0x2160
jmp 0x4d60
jmp 0x4d79
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20f0
jmp 0x4da6
jmp 0x4d7b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4cff
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4d9c
movq -0x38(%rbp), %rdi
callq 0x20f0
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22d0
nop
// File: lotka[P]prologplusplus/predicate.cpp
// Function: Predicate::unifyWith(PredicateRef*)
bool Predicate::unifyWith(PredicateRef * ref)
{
	if(ref->name == name and ref->airty == airty)
	{
		for(int i = 0; i < airty; ++i)
		{
			if(not args[i]->unifyWith(ref->args[i]))
			{
				return false;
			}
		}
	}
	else
	{
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3ff0
testb $0x1, %al
jne 0x60a7
jmp 0x6118
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x38(%rax), %eax
cmpl 0x20(%rcx), %eax
jne 0x6118
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x6116
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2d40
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2d40
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x3e40
testb $0x1, %al
jne 0x6109
movb $0x0, -0x1(%rbp)
jmp 0x6122
jmp 0x610b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x60be
jmp 0x611e
movb $0x0, -0x1(%rbp)
jmp 0x6122
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_compilation_timeout.cpp
// Function: compilation_timeout_check::continue_compilation(exprtk::compilation_check::compilation_context&)
bool continue_compilation(compilation_context& context) override
   {
      if (++iterations_ >= max_iters_per_check)
      {
         if (std::chrono::steady_clock::now() >= timeout_tp_)
         {
            context.error_message = "Compilation has timed-out";
            return false;
         }

         iterations_ = 0;
      }

      return true;
   }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x8(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x8(%rcx)
cmpq $0x2710, %rax           # imm = 0x2710
jb 0x126e81
callq 0x111630
movq (%rsp), %rsi
movq %rax, 0x8(%rsp)
addq $0x10, %rsi
leaq 0x8(%rsp), %rdi
callq 0x126f60
testb $0x1, %al
jne 0x126e5d
jmp 0x126e75
movq 0x10(%rsp), %rdi
leaq 0x321945(%rip), %rsi    # 0x4487ae
callq 0x1112f0
movb $0x0, 0x27(%rsp)
jmp 0x126e86
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::concestor(summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static node *concestor(node *a, node *b)
    {
	int da = depth_of(a);
	int db = depth_of(b);

	// Make sure b is the deeper of the two
	if (da > db) {
	    std::swap(da, db);
	    std::swap(a, b);
	}

	// Climb up b until we find an ancestor of the same depth as a
	while (da < db) {
	    b = b->parent;
	    db--;
	}

	// Climb both simultaneously until we meet
	while (a != b) {
	    a = a->parent;
	    b = b->parent;
	}

	return a;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3e20
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
callq 0x3e20
movl %eax, (%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jle 0x3afe
leaq 0x4(%rsp), %rdi
movq %rsp, %rsi
callq 0x3320
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3e70
jmp 0x3b00
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0x3b22
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movl (%rsp), %eax
addl $-0x1, %eax
movl %eax, (%rsp)
jmp 0x3b00
jmp 0x3b24
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x3b4e
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x3b24
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::sum_tree(aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary> const&, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static summary_type sum_tree(const aggregator_type& ag, node *n)
    {
	if (!n)
	    return ag.nothing();

	if (!(n->flags & node::SUM_VALID)) {
	    n->sum =
		ag.combine(
		    ag.combine(sum_tree(ag, n->left), ag.summarize(n->value)),
		    sum_tree(ag, n->right));
	    n->flags |= node::SUM_VALID;
	}

	return n->sum;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x3d29
movq 0x38(%rsp), %rdi
callq 0x3900
movl %eax, 0x44(%rsp)
jmp 0x3de8
movq 0x30(%rsp), %rax
movl 0x2c(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x3ddc
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rsi
callq 0x3d00
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3950
movq 0x8(%rsp), %rdi
movl %eax, 0x20(%rsp)
leaq 0x24(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x3920
movl %eax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x3d00
movq 0x10(%rsp), %rdi
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
callq 0x3920
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl %ecx, 0x28(%rax)
movq 0x30(%rsp), %rax
movl 0x2c(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x2c(%rax)
movq 0x30(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::depth_of(summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static int depth_of(node *n)
    {
	int r = 0;

	while (!is_header(n)) {
	    r++;
	    n = n->parent;
	}

	return r;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x38e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x3e43
jmp 0x3e5e
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x3e31
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/libcuckoo/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;
	cuckoohash_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		h.upsert(get_key(n, x), [&z](uint32_t &v) { z += ++v; }); // FIXME: not sure if this is correct...
		++z;
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0xb8, %rsp
movl %edi, 0xb4(%rsp)
movl %esi, 0xb0(%rsp)
movl $0x0, 0xa4(%rsp)
leaq 0x55(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x2b80
movq 0x30(%rsp), %r8
leaq 0x58(%rsp), %rdi
movl $0x40000, %esi          # imm = 0x40000
leaq 0x57(%rsp), %rdx
leaq 0x56(%rsp), %rcx
callq 0x2b90
jmp 0x27cf
leaq 0x55(%rsp), %rdi
callq 0x2da0
movl $0x0, 0xac(%rsp)
movl 0xb0(%rsp), %eax
movl %eax, 0xa8(%rsp)
movl 0xac(%rsp), %eax
cmpl 0xb4(%rsp), %eax
jae 0x28c5
movl 0xa8(%rsp), %edi
callq 0x2420
movl %eax, 0x2c(%rsp)
jmp 0x2818
movl 0x2c(%rsp), %eax
movl %eax, 0xa8(%rsp)
movl 0xb4(%rsp), %edi
movl 0xa8(%rsp), %esi
callq 0x2490
movl %eax, 0x28(%rsp)
jmp 0x283c
movl 0x28(%rsp), %eax
movl %eax, 0x40(%rsp)
leaq 0xa4(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdx
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2940
jmp 0x2867
movl 0xa4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa4(%rsp)
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x27f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x55(%rsp), %rdi
callq 0x2da0
jmp 0x2934
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2ea0
jmp 0x2934
movq 0x1370c(%rip), %rax     # 0x15fd8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2db0
movq %rax, 0x20(%rsp)
jmp 0x28e5
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rdi
movl 0xa4(%rsp), %ecx
leaq 0xb7e8(%rip), %rsi      # 0xe0e5
xorl %eax, %eax
callq 0x21d0
leaq 0x58(%rsp), %rdi
callq 0x2db0
movq %rax, 0x10(%rsp)
jmp 0x2915
movq 0x10(%rsp), %rax
movl %eax, 0xc(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2ea0
movl 0xc(%rsp), %eax
addq $0xb8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x2240
nop
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: bool cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::upsert<unsigned int, test_int(unsigned int, unsigned int)::$_0>(unsigned int&&, test_int(unsigned int, unsigned int)::$_0)
bool upsert(K &&key, F fn, Args &&... val) {
    return uprase_fn(std::forward<K>(key),
                     [&fn](mapped_type &v) {
                       fn(v);
                       return false;
                     },
                     std::forward<Args>(val)...);
  }

// Assembly:
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdx
callq 0x2980
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: bool cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::uprase_fn<unsigned int, bool cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::upsert<unsigned int, test_int(unsigned int, unsigned int)::$_0>(unsigned int&&, test_int(unsigned int, unsigned int)::$_0)::'lambda'(unsigned int&)>(unsigned int&&, test_int(unsigned int, unsigned int)::$_0)
bool uprase_fn(K &&key, F fn, Args &&... val) {
    hash_value hv = hashed_key(key);
    auto b = snapshot_and_lock_two<normal_mode>(hv);
    table_position pos = cuckoo_insert_loop<normal_mode>(hv, b, key);
    if (pos.status == ok) {
      add_to_bucket(pos.index, pos.slot, hv.partial, std::forward<K>(key),
                    std::forward<Args>(val)...);
    } else {
      if (fn(buckets_[pos.index].mapped(pos.slot))) {
        del_from_bucket(pos.index, pos.slot);
      }
    }
    return pos.status == ok;
  }

// Assembly:
subq $0xb8, %rsp
movq %rdx, 0xb0(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0xa0(%rsp), %rsi
callq 0x4a60
movq 0x20(%rsp), %rsi
movq %rax, 0x90(%rsp)
movb %dl, 0x98(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x90(%rsp), %rdx
callq 0x4ac0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %r8
movups 0x90(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0xa0(%rsp), %r9
movq 0x40(%rsp), %rdx
movl 0x48(%rsp), %ecx
leaq 0x58(%rsp), %rdi
callq 0x4ba0
jmp 0x2a18
cmpl $0x0, 0x68(%rsp)
jne 0x2a67
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movzbl 0x98(%rsp), %ecx
movq 0xa0(%rsp), %r8
callq 0x4d20
jmp 0x2a45
jmp 0x2ad3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4e70
jmp 0x2af7
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x58(%rsp), %rsi
callq 0x4db0
movq %rax, 0x18(%rsp)
jmp 0x2a81
movq 0x18(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x4dd0
movq %rax, 0x10(%rsp)
jmp 0x2a97
movq 0x10(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
callq 0x2b10
movb %al, 0xf(%rsp)
jmp 0x2aaf
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2ab9
jmp 0x2ad1
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x4e00
jmp 0x2acf
jmp 0x2ad1
jmp 0x2ad3
cmpl $0x0, 0x68(%rsp)
sete %al
movb %al, 0xe(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4e70
movb 0xe(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/libcuckoo/./cuckoohash_map.hh
// Function: cuckoohash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, unsigned int>>, 4ul>::size() const
size_type size() const {
    if (all_locks_.size() == 0) {
      return 0;
    }
    counter_type s = 0;
    for (spinlock &lock : get_current_locks()) {
      s += lock.elem_counter();
    }
    assert(s >= 0);
    return static_cast<size_type>(s);
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x20, %rdi
callq 0xd520
cmpq $0x0, %rax
jne 0x2de0
movq $0x0, 0x40(%rsp)
jmp 0x2e90
movq 0x8(%rsp), %rdi
movq $0x0, 0x30(%rsp)
callq 0x5170
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x9440
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x9470
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x94a0
testb $0x1, %al
jne 0x2e2b
jmp 0x2e5d
leaq 0x20(%rsp), %rdi
callq 0x94e0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xce20
movq (%rax), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x94f0
jmp 0x2e16
cmpq $0x0, 0x30(%rsp)
jl 0x2e67
jmp 0x2e86
leaq 0xcc04(%rip), %rdi      # 0xfa72
leaq 0xb439(%rip), %rsi      # 0xe2ae
movl $0x157, %edx            # imm = 0x157
leaq 0xcbf8(%rip), %rcx      # 0xfa79
callq 0x2110
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)