LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/tunstall/tunstall.hpp
// Function: Tunstall::getProbabilities(unsigned char*, int)
void Tunstall::getProbabilities(unsigned char *data, int size) {

//#define DEBUG_ENTROPY
#ifdef DEBUG_ENTROPY
	double e = 0;
#endif
	probabilities.clear();

	std::vector<int> probs(256, 0);
	for(int i = 0; i < size; i++)
		probs[data[i]]++;
//	int max = 0;
	for(size_t i = 0; i < probs.size(); i++) {
		if(probs[i] > 0) {
//			max = i;
			//TODO scaling probabilities to MAX would result in better accuracy (compression)?


#ifdef DEBUG_ENTROPY
			double p = probs[i]/(double)size;
			e -= p * log2(p);
			cout << (char)(i + 65) << " P: " << p << endl;
#endif
			probabilities.push_back(Symbol(i, probs[i]*255/size));
		}
	}

	std::sort(probabilities.begin(), probabilities.end(),
			  [](const Symbol &a, const Symbol &b)->bool { return a.probability > b.probability; });
#ifdef DEBUG_ENTROPY
	cout << "Entropy: " << e << " theorical compression: " << e*size/8 << endl;
#endif
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movl %edx, 0x94(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x10, %rdi
callq 0x5f00
movl $0x0, 0x74(%rsp)
leaq 0x73(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x5f20
movq 0x30(%rsp), %rcx
leaq 0x78(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
leaq 0x74(%rsp), %rdx
callq 0x5f30
jmp 0x2446
leaq 0x73(%rsp), %rdi
callq 0x5fb0
movl $0x0, 0x60(%rsp)
movl 0x60(%rsp), %eax
cmpl 0x94(%rsp), %eax
jge 0x24b3
movq 0x98(%rsp), %rax
movslq 0x60(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
leaq 0x78(%rsp), %rdi
callq 0x5fc0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x2458
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x73(%rsp), %rdi
callq 0x5fb0
jmp 0x25cf
movq $0x0, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5fe0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x2585
movq 0x58(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x5fc0
cmpl $0x0, (%rax)
jle 0x2570
movq 0x28(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x18(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5fc0
movl (%rax), %ecx
movl %ecx, %eax
shll $0x8, %eax
subl %ecx, %eax
movl 0x94(%rsp), %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x18(%rsp), %rax
movzbl %cl, %edx
movzbl %al, %esi
leaq 0x56(%rsp), %rdi
callq 0x6030
jmp 0x2543
movq 0x10(%rsp), %rdi
leaq 0x56(%rsp), %rsi
callq 0x6000
jmp 0x2554
jmp 0x2570
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x60c0
jmp 0x25cf
jmp 0x2572
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x24bc
movq 0x28(%rsp), %rdi
addq $0x10, %rdi
movq %rdi, 0x8(%rsp)
callq 0x6060
movq 0x8(%rsp), %rdi
movq %rax, 0x48(%rsp)
callq 0x6090
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x25e0
jmp 0x25bd
leaq 0x78(%rsp), %rdi
callq 0x60c0
addq $0xa8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x2280
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/tunstall/tunstall.hpp
// Function: Tunstall::setProbabilities(float*, int)
void Tunstall::setProbabilities(float *probs, int n_symbols) {
	probabilities.clear();
	for(int i = 0; i < n_symbols; i++) {
		if(probs[i] <= 0) continue;
		probabilities.push_back(Symbol(i, probs[i]*255));
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
callq 0x5f00
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x26c7
movq 0x28(%rsp), %rax
movslq 0x20(%rsp), %rcx
xorps %xmm0, %xmm0
ucomiss (%rax,%rcx,4), %xmm0
jb 0x266c
jmp 0x26ba
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movslq 0x20(%rsp), %rdx
movb %dl, %cl
movq 0x28(%rsp), %rax
movss (%rax,%rdx,4), %xmm0
movss 0xb971(%rip), %xmm1     # 0xe004
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
leaq 0x1e(%rsp), %rdi
movzbl %cl, %esi
movzbl %al, %edx
callq 0x6030
movq 0x8(%rsp), %rdi
leaq 0x1e(%rsp), %rsi
callq 0x6000
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x264d
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/tunstall/tunstall.hpp
// Function: Tunstall::decompress(unsigned char*, int, unsigned char*, int)
void Tunstall::decompress(unsigned char *data, int input_size, unsigned char *output, int output_size) {
	unsigned char *end_output = output + output_size;
	unsigned char *end_data = data + input_size -1;
	if(probabilities.size() == 1) {
		memset(output, probabilities[0].symbol, output_size);
		return;
	}
	//index.push_back(index.back() + lengths.back()); //TODO WHY?
	while(data < end_data) {
		int symbol = *data++;
		int start = index[symbol];
		int length = lengths[symbol];
		//int length = index[symbol+1] - start;
		memcpy(output, &table[start], length);
		output += length;
	}
	//last symbol might override so we check.
	int symbol = *data;
	int start = index[symbol];
	int length = (*end_output - *output);
	//cout << (end_output - output) << endl;
	//cout << (*end_output - *output) << endl;
	memcpy(output, &table[start], length);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movl %r8d, 0x54(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x58(%rsp), %rax
movslq 0x54(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x48(%rsp)
movq 0x68(%rsp), %rax
movslq 0x64(%rsp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x40(%rsp)
addq $0x10, %rdi
callq 0x6120
cmpq $0x1, %rax
jne 0x42f3
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6320
movq 0x18(%rsp), %rdi
movzbl (%rax), %eax
movslq 0x54(%rsp), %rdx
movzbl %al, %esi
callq 0x20a0
jmp 0x4401
jmp 0x42f5
movq 0x68(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x4397
movq 0x20(%rsp), %rdi
movq 0x68(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rsp)
movzbl (%rax), %eax
movl %eax, 0x3c(%rsp)
addq $0x28, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x5fc0
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x38(%rsp)
addq $0x40, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x5fc0
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x58, %rdi
movslq 0x38(%rsp), %rsi
callq 0x6340
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movslq 0x34(%rsp), %rdx
callq 0x2100
movl 0x34(%rsp), %ecx
movq 0x58(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x58(%rsp)
jmp 0x42f5
movq 0x20(%rsp), %rdi
movq 0x68(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x30(%rsp)
addq $0x28, %rdi
movslq 0x30(%rsp), %rsi
callq 0x5fc0
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax), %eax
movq 0x58(%rsp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x58, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x6340
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movslq 0x28(%rsp), %rdx
callq 0x2100
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/tunstall/tunstall.hpp
// Function: Tunstall::decompress(unsigned char*, unsigned char*, int)
int Tunstall::decompress(unsigned char *data, unsigned char *output, int output_size) {
	unsigned char *end_output = output + output_size;
	unsigned char *start = data;
	if(probabilities.size() == 1) {
		memset(output, probabilities[0].symbol, output_size);
		return 0;
	}
	exit(0);
	while(1) {
		int symbol = *data++;
		assert(symbol < (int)index.size());
		int start = index[symbol];
		int length = lengths[symbol];
		if(output + length >= end_output) {
			length = (end_output - output);
			memcpy(output, &table[start], length);
			break;
		} else {
			memcpy(output, &table[start], length);
			output += length;
		}
	}
	return data - start;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x10, %rdi
callq 0x6120
cmpq $0x1, %rax
jne 0x4494
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6320
movq 0x8(%rsp), %rdi
movzbl (%rax), %eax
movslq 0x2c(%rsp), %rdx
movzbl %al, %esi
callq 0x20a0
xorl %eax, %eax
addq $0x48, %rsp
retq
xorl %edi, %edi
callq 0x2180
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/tunstall/tunstall.hpp
// Function: Tunstall::entropy()
float Tunstall::entropy() {
	float e = 0;
	for(size_t i = 0; i < probabilities.size(); i++) {
		float p = probabilities[i].probability/255.0f;
		e += p*log(p)/log(2);
	}
	return -e;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x3c(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x10, %rdi
callq 0x6120
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x4588
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
movq 0x30(%rsp), %rsi
callq 0x6320
movzbl 0x1(%rax), %eax
cvtsi2ss %eax, %xmm0
movss 0x9af3(%rip), %xmm1     # 0xe004
divss %xmm1, %xmm0
movss %xmm0, 0x2c(%rsp)
movss 0x2c(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x2c(%rsp), %xmm0
callq 0x6a60
movaps %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x2, %edi
callq 0x6a80
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movss 0x3c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x3c(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x44c5
movss 0x3c(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/tunstall/readfile.hpp
// Function: readchar2buf(char const*, unsigned char*&, unsigned int*)
int readchar2buf(const char* path, unsigned char*& buf, unsigned int* length)
{
	ifstream inFile;
	inFile.open(path, ios::in|ios::binary|ios::ate);
	if (!inFile.is_open()) return 0;

	inFile.seekg(0, ios::end);
	unsigned int size = inFile.tellg();
	inFile.seekg(0, ios::beg);

	buf = new unsigned char[size+1];
	inFile.read((char*)buf, size);
	buf[size] = '\0';
	*length = strlen((char*)buf);

	return 1;
}

// Assembly:
subq $0x288, %rsp            # imm = 0x288
movq %rdi, 0x278(%rsp)
movq %rsi, 0x270(%rsp)
movq %rdx, 0x268(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2170
movq 0x278(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x6aa0
movl %eax, 0x34(%rsp)
jmp 0x45eb
movl 0x34(%rsp), %edi
movl $0x2, %esi
callq 0x6aa0
movl %eax, 0x24(%rsp)
jmp 0x45ff
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x20c0
jmp 0x4614
leaq 0x60(%rsp), %rdi
callq 0x2230
movb %al, 0x23(%rsp)
jmp 0x4624
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x4663
jmp 0x462e
movl $0x0, 0x284(%rsp)
movl $0x1, 0x50(%rsp)
jmp 0x474d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2040
jmp 0x4766
xorl %eax, %eax
movl %eax, %esi
leaq 0x60(%rsp), %rdi
movl $0x2, %edx
callq 0x21d0
jmp 0x4678
leaq 0x60(%rsp), %rdi
callq 0x2270
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
jmp 0x468e
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6ac0
movq %rax, 0x8(%rsp)
jmp 0x46b3
movq 0x8(%rsp), %rax
movl %eax, 0x4c(%rsp)
xorl %edx, %edx
movl %edx, %esi
leaq 0x60(%rsp), %rdi
callq 0x21d0
jmp 0x46cc
movl 0x4c(%rsp), %eax
incl %eax
movl %eax, %edi
callq 0x2030
movq %rax, (%rsp)
jmp 0x46df
movq (%rsp), %rcx
movq 0x270(%rsp), %rax
movq %rcx, (%rax)
movq 0x270(%rsp), %rax
movq (%rax), %rsi
movl 0x4c(%rsp), %eax
movl %eax, %edx
leaq 0x60(%rsp), %rdi
callq 0x21a0
jmp 0x470b
movq 0x270(%rsp), %rax
movq (%rax), %rax
movl 0x4c(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movq 0x270(%rsp), %rax
movq (%rax), %rdi
callq 0x2080
movl %eax, %ecx
movq 0x268(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x284(%rsp)
movl $0x1, 0x50(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2040
movl 0x284(%rsp), %eax
addq $0x288, %rsp            # imm = 0x288
retq
movq 0x58(%rsp), %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/tunstall/readfile.hpp
// Function: readint2buf(char const*, unsigned char*&, unsigned int*)
int readint2buf(const char* path, unsigned char*& buf, unsigned int* length)
{
	int tmp;
	unsigned int cnt = 0;
	ifstream inFile;

	inFile.open(path);
	if (!inFile.is_open()) return 0;

	*length = 0;
	while (inFile >> tmp) (*length) = (*length)+1;
	inFile.seekg(0, ios::beg);

	buf = new unsigned char[(*length)+1];
	while (inFile >> tmp) buf[cnt++] = tmp;
	buf[cnt] = '\0';

	return 1;
}

// Assembly:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x268(%rsp)
movq %rsi, 0x260(%rsp)
movq %rdx, 0x258(%rsp)
movl $0x0, 0x250(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x2170
movq 0x30(%rsp), %rdi
movq 0x268(%rsp), %rsi
movl $0x8, %edx
callq 0x20c0
jmp 0x47c2
leaq 0x48(%rsp), %rdi
callq 0x2230
movb %al, 0x2f(%rsp)
jmp 0x47d2
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x4811
jmp 0x47dc
movl $0x0, 0x274(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0x4943
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2040
jmp 0x495c
movq 0x258(%rsp), %rax
movl $0x0, (%rax)
leaq 0x48(%rsp), %rdi
leaq 0x254(%rsp), %rsi
callq 0x20b0
movq %rax, 0x20(%rsp)
jmp 0x4838
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2190
movb %al, 0x1f(%rsp)
jmp 0x4852
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x485c
jmp 0x4875
movq 0x258(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq 0x258(%rsp), %rax
movl %ecx, (%rax)
jmp 0x481f
xorl %edx, %edx
movl %edx, %esi
leaq 0x48(%rsp), %rdi
callq 0x21d0
jmp 0x4885
movq 0x258(%rsp), %rax
movl (%rax), %eax
incl %eax
movl %eax, %edi
callq 0x2030
movq %rax, 0x10(%rsp)
jmp 0x489f
movq 0x10(%rsp), %rcx
movq 0x260(%rsp), %rax
movq %rcx, (%rax)
leaq 0x48(%rsp), %rdi
leaq 0x254(%rsp), %rsi
callq 0x20b0
movq %rax, 0x8(%rsp)
jmp 0x48c8
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2190
movb %al, 0x7(%rsp)
jmp 0x48e2
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x48ec
jmp 0x491a
movl 0x254(%rsp), %eax
movb %al, %dl
movq 0x260(%rsp), %rax
movq (%rax), %rax
movl 0x250(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x250(%rsp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0x48af
movq 0x260(%rsp), %rax
movq (%rax), %rax
movl 0x250(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movl $0x1, 0x274(%rsp)
movl $0x1, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2040
movl 0x274(%rsp), %eax
addq $0x278, %rsp            # imm = 0x278
retq
movq 0x40(%rsp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/tunstall/tunstall.hpp
// Function: Tunstall::wordCode(unsigned char*, int, int&, int&)
void wordCode(unsigned char *w, int length, int &low, int &high) {
		int n_symbols = (int)probabilities.size();

		//counting in base n_symbols
		int c = 0;
		for(int i = 0; i < length && i < lookup_size; i++) {
			c *= n_symbols;
			c += remap[w[i]];
		}
		low = high = c;
		high++;
		for(int i = length; i < lookup_size; i++) {
			low *= n_symbols;
			high *= n_symbols;
		}
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0x6120
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %ecx
xorl %eax, %eax
cmpl 0x34(%rsp), %ecx
movb %al, 0x7(%rsp)
jge 0x69a6
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x70(%rcx), %eax
setl %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x69b0
jmp 0x69f6
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
imull 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
addq $0x90, %rdi
movq 0x38(%rsp), %rax
movslq 0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %esi
callq 0x6340
movzbl (%rax), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6983
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x34(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x70(%rcx), %eax
jge 0x6a53
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rax
imull (%rax), %ecx
movl %ecx, (%rax)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
imull (%rax), %ecx
movl %ecx, (%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x6a1c
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/double_free.cpp
// Function: DF_01::otherx()
void otherx() {
  FoobarClass otherxClassObject("One");

  /* FLAW: There is no copy constructor in the class - this will cause a double
   * free in the destructor */
  FoobarClass otherxClassObjectCopy(otherxClassObject);

  otherxClassObjectCopy.printData();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xe45(%rip), %rsi       # 0x2004
leaq -0x8(%rbp), %rdi
callq 0x1270
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x12e0
jmp 0x11db
leaq -0x10(%rbp), %rdi
callq 0x1310
leaq -0x8(%rbp), %rdi
callq 0x1310
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1310
leaq -0x8(%rbp), %rdi
callq 0x1310
movq -0x18(%rbp), %rdi
callq 0x10a0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/double_free.cpp
// Function: main
int main(int argc, char *argv[]) {
  /* seed randomness */
  srand((unsigned)time(NULL));
  printf("Calling otherx()...");
  otherx();
  printf("Finished otherx()");
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
movl %eax, %edi
callq 0x1080
leaq 0xdbb(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1040
callq 0x11b0
leaq 0xdbc(%rip), %rdi       # 0x201c
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/double_free.cpp
// Function: DF_01::FoobarClass::FoobarClass(char const*)
FoobarClass(const char *data) {
    if (data) {
      this->data = new char[strlen(data) + 1];
      strcpy(this->data, data);
    } else {
      this->data = new char[1];
      *(this->data) = '\0';
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12bc
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1070
jmp 0x12d6
movl $0x1, %edi
callq 0x1030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wjmelements[P]evm/tst/scanstack.c
// Function: main
int main() {
    assert(scanstackEmpty());
    scanstackPush(DUP3);
    assert(!scanstackEmpty());
    assert(DUP3 == scanstackPop());
    assert(scanstackEmpty());
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x2280
cmpl $0x0, %eax
je 0x218b
jmp 0x21aa
leaq 0x1e8e(%rip), %rdi      # 0x4020
leaq 0x1e6b(%rip), %rsi      # 0x4004
movl $0x5, %edx
leaq 0x1e6f(%rip), %rcx      # 0x4014
callq 0x2030
movl $0x82, %edi
callq 0x2250
callq 0x2280
cmpl $0x0, %eax
jne 0x21c0
jmp 0x21df
leaq 0x1e58(%rip), %rdi      # 0x401f
leaq 0x1e36(%rip), %rsi      # 0x4004
movl $0x7, %edx
leaq 0x1e3a(%rip), %rcx      # 0x4014
callq 0x2030
callq 0x22a0
movzbl %al, %ecx
movl $0x82, %eax
cmpl %ecx, %eax
jne 0x21f2
jmp 0x2211
leaq 0x1e38(%rip), %rdi      # 0x4031
leaq 0x1e04(%rip), %rsi      # 0x4004
movl $0x8, %edx
leaq 0x1e08(%rip), %rcx      # 0x4014
callq 0x2030
callq 0x2280
cmpl $0x0, %eax
je 0x221d
jmp 0x223c
leaq 0x1dfc(%rip), %rdi      # 0x4020
leaq 0x1dd9(%rip), %rsi      # 0x4004
movl $0x9, %edx
leaq 0x1ddd(%rip), %rcx      # 0x4014
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/sigkill_parent_process.c
// Function: main
int main() {
  check(pipe(pipe_fds) == 0);

  pid_t child_pid = fork();
  check(child_pid != -1);
  if (child_pid == 0) {
    check(close(pipe_fds[0]) == 0);
    parent_main();
    abort();
  }

  check(close(pipe_fds[1]) == 0);

  pid_t serv_pid;
  check(read(pipe_fds[0], &serv_pid, sizeof serv_pid) == sizeof serv_pid);

  check(kill(child_pid, SIGKILL) == 0);

  int wait_status;
  check(wait(&wait_status) == child_pid);
  check(WIFSIGNALED(wait_status));
  check(WTERMSIG(wait_status) == SIGKILL);

  while (true) {
    if (kill(serv_pid, 0) == -1) {
      check(errno == ESRCH);
      break;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x5dee(%rip), %rdi      # 0x7124
callq 0x10f0
cmpl $0x0, %eax
jne 0x1342
jmp 0x135a
leaq 0x2cbb(%rip), %rdi      # 0x4004
leaq 0x2cc8(%rip), %rsi      # 0x4018
movl $0x10, %edx
callq 0x1510
callq 0x1210
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
je 0x136a
jmp 0x1382
leaq 0x2cc6(%rip), %rdi      # 0x4037
leaq 0x2ca0(%rip), %rsi      # 0x4018
movl $0x13, %edx
callq 0x1510
cmpl $0x0, -0x8(%rbp)
jne 0x13bc
movl 0x5d96(%rip), %edi      # 0x7124
callq 0x10d0
cmpl $0x0, %eax
jne 0x139a
jmp 0x13b2
leaq 0x2ca6(%rip), %rdi      # 0x4047
leaq 0x2c70(%rip), %rsi      # 0x4018
movl $0x15, %edx
callq 0x1510
callq 0x1550
callq 0x1040
movl 0x5d66(%rip), %edi      # 0x7128
callq 0x10d0
cmpl $0x0, %eax
jne 0x13ce
jmp 0x13e6
leaq 0x2c8a(%rip), %rdi      # 0x405f
leaq 0x2c3c(%rip), %rsi      # 0x4018
movl $0x1a, %edx
callq 0x1510
movl 0x5d38(%rip), %edi      # 0x7124
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x1100
cmpq $0x4, %rax
jne 0x1402
jmp 0x141a
leaq 0x2c6e(%rip), %rdi      # 0x4077
leaq 0x2c08(%rip), %rsi      # 0x4018
movl $0x1d, %edx
callq 0x1510
movl -0x8(%rbp), %edi
movl $0x9, %esi
callq 0x1160
cmpl $0x0, %eax
jne 0x142e
jmp 0x1446
leaq 0x2c83(%rip), %rdi      # 0x40b8
leaq 0x2bdc(%rip), %rsi      # 0x4018
movl $0x1f, %edx
callq 0x1510
leaq -0x10(%rbp), %rdi
callq 0x1200
cmpl -0x8(%rbp), %eax
jne 0x1456
jmp 0x146e
leaq 0x2c79(%rip), %rdi      # 0x40d6
leaq 0x2bb4(%rip), %rsi      # 0x4018
movl $0x22, %edx
callq 0x1510
movl -0x10(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x1483
jmp 0x149b
leaq 0x2c6c(%rip), %rdi      # 0x40f6
leaq 0x2b87(%rip), %rsi      # 0x4018
movl $0x23, %edx
callq 0x1510
movl -0x10(%rbp), %eax
andl $0x7f, %eax
cmpl $0x9, %eax
jne 0x14a8
jmp 0x14c0
leaq 0x2c60(%rip), %rdi      # 0x410f
leaq 0x2b62(%rip), %rsi      # 0x4018
movl $0x24, %edx
callq 0x1510
jmp 0x14c2
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0x1160
cmpl $-0x1, %eax
jne 0x14f7
callq 0x1050
cmpl $0x3, (%rax)
jne 0x14dd
jmp 0x14f5
leaq 0x2c4c(%rip), %rdi      # 0x4130
leaq 0x2b2d(%rip), %rsi      # 0x4018
movl $0x28, %edx
callq 0x1510
jmp 0x14f9
jmp 0x14c2
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/sigkill_parent_process.c
// Function: parent_main
static void parent_main(void) {
  libforks_ServerConn conn;
  check(libforks_start(&conn) == libforks_OK);

  pid_t serv_pid = libforks_get_server_pid(conn);
  check(write(pipe_fds[1], &serv_pid, sizeof serv_pid) == sizeof serv_pid);

  sleep(999);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
callq 0x1bd0
cmpl $0x0, %eax
jne 0x1568
jmp 0x1580
leaq 0x2bec(%rip), %rdi      # 0x415b
leaq 0x2aa2(%rip), %rsi      # 0x4018
movl $0x7, %edx
callq 0x1510
movq -0x8(%rbp), %rdi
callq 0x2380
movl %eax, -0xc(%rbp)
movl 0x5b96(%rip), %edi      # 0x7128
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x1080
cmpq $0x4, %rax
jne 0x15a8
jmp 0x15c0
leaq 0x2bd1(%rip), %rdi      # 0x4180
leaq 0x2a62(%rip), %rsi      # 0x4018
movl $0xa, %edx
callq 0x1510
movl $0x3e7, %edi            # imm = 0x3E7
callq 0x11f0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.1/shm.c
// Function: main
int main ()
{
  int segment_id;
  char* shared_memory;
  struct shmid_ds shmbuffer;
  int segment_size;
  const int shared_segment_size = 0x6400;

  /* Allocate a shared memory segment. */
  segment_id = shmget ( IPC_PRIVATE, shared_segment_size,
                        IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
  /* Attach the shared memory segment. */
  shared_memory = (char*) shmat (segment_id, 0, 0);
  printf ("shared memory attached at address %p\n", shared_memory);
  /* Determine the segment’s size. */
  shmctl (segment_id, IPC_STAT, &shmbuffer);
  segment_size = shmbuffer.shm_segsz;
  printf ("segment size: %d\n", segment_size);
  /* Write a string to the shared memory segment. */
  sprintf (shared_memory, "Hello, world.");
  /* Detach the shared memory segment. */
  shmdt (shared_memory);

  /* Reattach the shared memory segment, at a different address. */
  shared_memory = (char*) shmat (segment_id, (void*) 0x5000000, 0);
  printf ("shared memory reattached at address %p\n", shared_memory);
  /* Print out the string from shared memory. */
  printf ("%s\n", shared_memory);
  /* Detach the shared memory segment. */
  shmdt (shared_memory);

  /* Deallocate the shared memory segment. */
  shmctl (segment_id, IPC_RMID, 0);

  return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl $0x6400, -0x88(%rbp)    # imm = 0x6400
xorl %edi, %edi
movl $0x6400, %esi           # imm = 0x6400
movl $0x780, %edx            # imm = 0x780
callq 0x1070
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1060
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xe27(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl -0x8(%rbp), %edi
movl $0x2, %esi
leaq -0x80(%rbp), %rdx
callq 0x1050
movq -0x50(%rbp), %rax
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %esi
leaq 0xe1e(%rip), %rdi       # 0x202a
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rdi
leaq 0xe1e(%rip), %rsi       # 0x203c
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rdi
callq 0x1030
movl -0x8(%rbp), %edi
movl $0x5000000, %esi        # imm = 0x5000000
xorl %edx, %edx
callq 0x1060
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0xdfe(%rip), %rdi       # 0x204a
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rsi
leaq 0xe14(%rip), %rdi       # 0x2072
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x1030
movl -0x8(%rbp), %edi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1050
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/veltzer[P]xmeltdown/src/xmeltdown.c
// Function: calc_xloc
int calc_xloc(int width) {
	int xloc;
	/* give values near edges a better chance */
	xloc=rnd(DisplayWidth(dpy, screen)+MIN_WIDTH)-MIN_WIDTH;
	if ((xloc+width) > DisplayWidth(dpy, screen))
		xloc=DisplayWidth(dpy, screen)-width;
	else if (xloc < 0)
		xloc=0;
	return xloc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x1130
movq 0x2709(%rip), %rcx      # 0x40c0
movq 0xe8(%rcx), %rcx
movslq 0x2703(%rip), %rdx      # 0x40c8
shlq $0x7, %rdx
addq %rdx, %rcx
movl 0x18(%rcx), %ecx
addl $0x1e, %ecx
movslq %ecx, %rcx
cqto
idivq %rcx
subq $0x1e, %rdx
movl %edx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl -0x4(%rbp), %eax
movq 0x26d0(%rip), %rcx      # 0x40c0
movq 0xe8(%rcx), %rcx
movslq 0x26ca(%rip), %rdx      # 0x40c8
shlq $0x7, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jle 0x1a31
movq 0x26af(%rip), %rax      # 0x40c0
movq 0xe8(%rax), %rax
movslq 0x26a9(%rip), %rcx      # 0x40c8
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
subl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x1a40
cmpl $0x0, -0x8(%rbp)
jge 0x1a3e
movl $0x0, -0x8(%rbp)
jmp 0x1a40
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_05/strncpy.c
// Function: main
int main(void)
{
  char s[100] = "This is the first string";
  char *t = "Test is the second string, that is cool";
  size_t nr_chars = 26;

  strcpy_ptr(s, t, nr_chars);

  puts(s);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0xea3(%rip), %rsi       # 0x2010
movl $0x64, %edx
callq 0x1040
leaq 0xef6(%rip), %rax       # 0x2074
movq %rax, -0x78(%rbp)
movq $0x1a, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x11b0
leaq -0x70(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c++/buffon.cxx
// Function: buffon_laplace_simulate(double, double, double, int)
int
buffon_laplace_simulate(double a, double b, double l, int trial_num)
{
    double angle;
    int hits;
    int trial;
    double x1;
    double x2;
    double y1;
    double y2;

    hits = 0;

    for (trial = 1; trial <= trial_num; ++trial) {
        //
        // Randomly choose the location of the eye of the needle in
        // [0,0]x[A,B],
        // and the angle the needle makes.
        //
        x1 = a * (double) rand() / (double) RAND_MAX;
        y1 = b * (double) rand() / (double) RAND_MAX;
        angle = 2.0 * PI * (double) rand() / (double) RAND_MAX;
        //
        // Compute the location of the point of the needle.
        //
        x2 = x1 + l * cos(angle);
        y2 = y1 + l * sin(angle);
        //
        // Count the end locations that lie outside the cell.
        //
        if (x2 <= 0.0 || a <= x2 || y2 <= 0.0 || b <= y2) {
            ++hits;
        }
    }
    return hits;
}

// Assembly:
subq $0x88, %rsp
movsd %xmm0, 0x80(%rsp)
movsd %xmm1, 0x78(%rsp)
movsd %xmm2, 0x70(%rsp)
movl %edi, 0x6c(%rsp)
movl $0x0, 0x5c(%rsp)
movl $0x1, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jg 0x1414
movsd 0x80(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x1040
movsd 0x8(%rsp), %xmm0
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
movsd 0xd30(%rip), %xmm1      # 0x2008
divsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x1040
movsd 0x10(%rsp), %xmm0
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
movsd 0xcff(%rip), %xmm1      # 0x2008
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
callq 0x1040
cvtsi2sd %eax, %xmm1
movsd 0xcec(%rip), %xmm0      # 0x2010
mulsd %xmm1, %xmm0
movsd 0xcd8(%rip), %xmm1      # 0x2008
divsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x1100
movsd 0x18(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x20(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x60(%rsp), %xmm0
callq 0x1030
movsd 0x28(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x30(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x48(%rsp), %xmm0
jae 0x13f7
movsd 0x80(%rsp), %xmm1
movsd 0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x13f7
xorps %xmm0, %xmm0
ucomisd 0x38(%rsp), %xmm0
jae 0x13f7
movsd 0x78(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x1402
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x1404
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x12a0
movl 0x5c(%rsp), %eax
addq $0x88, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DAMASKER/datander.c
// Function: Clean_Exit
void Clean_Exit(int val)
{ char *command;

  command = CommandBuffer("",SORT_PATH);
  sprintf(command,"rm -r %s",SORT_PATH);
  if (system(command) != 0)
    { fprintf(stderr,"%s: Command Failed:\n%*s      %s\n",
                     Prog_Name,(int) strlen(Prog_Name),"",command);
      exit (1);
    }
  exit (val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x2bfe6(%rip), %rsi     # 0x2e418
leaq 0x27e56(%rip), %rdi     # 0x2a28f
callq 0x24d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x2bfcb(%rip), %rdx     # 0x2e418
leaq 0x26c74(%rip), %rsi     # 0x290c8
movb $0x0, %al
callq 0x22c0
movq -0x10(%rbp), %rdi
callq 0x2110
cmpl $0x0, %eax
je 0x24c1
movq 0x2bb88(%rip), %rax     # 0x2dff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x2c032(%rip), %rax     # 0x2e4b0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x2c024(%rip), %rax     # 0x2e4b0
movq (%rax), %rdi
callq 0x2100
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl %eax, %ecx
movq -0x10(%rbp), %r9
leaq 0x27058(%rip), %rsi     # 0x29501
leaq 0x27ddf(%rip), %r8      # 0x2a28f
movb $0x0, %al
callq 0x21e0
movl $0x1, %edi
callq 0x22d0
movl -0x4(%rbp), %edi
callq 0x22d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DAMASKER/datander.c
// Function: CommandBuffer
static char *CommandBuffer(char *bname, char *spath)
{ static char *cat = NULL;
  static int   max = -1;
  int len;

  len = 2*(strlen(bname) + strlen(spath)) + 200;
  if (len > max)
    { max = ((int) (1.2*len)) + 100;
      if ((cat = (char *) realloc(cat,max+1)) == NULL)
        { fprintf(stderr,"%s: Out of memory (Making path name)\n",Prog_Name);
          Clean_Exit(1);
        }
    }
  return (cat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2100
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2100
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
shlq %rax
addq $0xc8, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x2bc9b(%rip), %eax     # 0x2e1b0
jle 0x2588
cvtsi2sdl -0x14(%rbp), %xmm1
movsd 0x26ae4(%rip), %xmm0    # 0x29008
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x64, %eax
movl %eax, 0x2bc7b(%rip)     # 0x2e1b0
movq 0x2beec(%rip), %rdi     # 0x2e428
movl 0x2bc6e(%rip), %eax     # 0x2e1b0
addl $0x1, %eax
movslq %eax, %rsi
callq 0x2260
movq %rax, 0x2bed4(%rip)     # 0x2e428
cmpq $0x0, %rax
jne 0x2586
movq 0x2ba97(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x2bf45(%rip), %rax     # 0x2e4b0
movq (%rax), %rdx
leaq 0x26fd0(%rip), %rsi     # 0x29545
movb $0x0, %al
callq 0x21e0
movl $0x1, %edi
callq 0x2420
jmp 0x2588
movq 0x2be99(%rip), %rax     # 0x2e428
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DAMASKER/datander.c
// Function: read_DB
static int read_DB(DAZZ_DB *block, char *name, int kmer)
{ int i, isdam;

  isdam = Open_DB(name,block);
  if (isdam < 0)
    Clean_Exit(1);

  Trim_DB(block);

  if (block->cutoff < kmer)
    { for (i = 0; i < block->nreads; i++)
        if (block->reads[i].rlen < kmer)
          { fprintf(stderr,"%s: Block %s contains reads < %dbp long !  Run DBsplit.\n",
                           Prog_Name,name,kmer);
            Clean_Exit(1);
          }
    }

  Load_All_Reads(block,0);

  return (isdam);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1ef30
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x3523
movl $0x1, %edi
callq 0x2420
movq -0x8(%rbp), %rdi
callq 0x1fb60
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x35a9
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x35a7
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x359a
movq 0x2aa8b(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x2af39(%rip), %rax     # 0x2e4b0
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq 0x26076(%rip), %rsi     # 0x295ff
movb $0x0, %al
callq 0x21e0
movl $0x1, %edi
callq 0x2420
jmp 0x359c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x353f
jmp 0x35a9
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x21150
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DAMASKER/tandem.c
// Function: Set_Filter_Params
int Set_Filter_Params(int kmer, int binshift, int hitmin, int nthreads)
{ if (kmer <= 1)
    return (1);

  Kmer     = kmer;
  Binshift = binshift;
  Hitmin   = hitmin;

  Kshift = 2*Kmer;
  if (Kmer == 32)
    Kmask = 0xffffffffffffffffllu;
  else
    Kmask = (0x1llu << Kshift) - 1;

  NTHREADS = 1;
  NSHIFT   = 0;
  while (2*NTHREADS <= nthreads)
    { NTHREADS *= 2;
      NSHIFT   += 1;
    }

  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x1, -0x8(%rbp)
jg 0x35e2
movl $0x1, -0x4(%rbp)
jmp 0x3683
movl -0x8(%rbp), %eax
movl %eax, 0x2ae45(%rip)     # 0x2e430
movl -0xc(%rbp), %eax
movl %eax, 0x2ae40(%rip)     # 0x2e434
movl -0x10(%rbp), %eax
movl %eax, 0x2ae3b(%rip)     # 0x2e438
movl 0x2ae2d(%rip), %eax     # 0x2e430
shll %eax
movl %eax, 0x2ae31(%rip)     # 0x2e43c
cmpl $0x20, 0x2ae1e(%rip)    # 0x2e430
jne 0x3621
movq $-0x1, 0x2ae21(%rip) # 0x2e440
jmp 0x363c
movl 0x2ae15(%rip), %eax     # 0x2e43c
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, 0x2ae04(%rip)     # 0x2e440
movl $0x1, 0x2ae02(%rip)     # 0x2e448
movl $0x0, 0x2adfc(%rip)     # 0x2e44c
movl 0x2adf2(%rip), %eax     # 0x2e448
shll %eax
cmpl -0x14(%rbp), %eax
jg 0x367c
movl 0x2ade5(%rip), %eax     # 0x2e448
shll %eax
movl %eax, 0x2addd(%rip)     # 0x2e448
movl 0x2addb(%rip), %eax     # 0x2e44c
addl $0x1, %eax
movl %eax, 0x2add2(%rip)     # 0x2e44c
jmp 0x3650
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DAMASKER/tandem.c
// Function: Diagonal_Span
void Diagonal_Span(Path *path, int *mind, int *maxd)
{ uint16 *points;
  int     i, tlen;
  int     dd, low, hgh;

  points = path->trace;
  tlen   = path->tlen;

  dd = path->abpos - path->bbpos;
  low = hgh = dd;

  dd = path->aepos - path->bepos;
  if (dd < low)
    low = dd;
  else if (dd > hgh)
    hgh = dd;

  dd = (path->abpos/MR_tspace)*MR_tspace - path->bbpos;
  tlen -= 2;
  for (i = 1; i < tlen; i += 2)
    { dd += MR_tspace - points[i];
      if (dd < low)
        low = dd;
      else if (dd > hgh)
        hgh = dd;
    }

  *mind = (low >> Binshift)-1;
  *maxd = (hgh >> Binshift)+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x14(%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x1c(%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x36f0
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x3700
movl -0x2c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jle 0x36fe
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x3700
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
cltd
idivl 0x2ad42(%rip)           # 0x2e450
imull 0x2ad3b(%rip), %eax     # 0x2e450
movq -0x8(%rbp), %rcx
subl 0x14(%rcx), %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x28(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x377e
movl 0x2ad13(%rip), %eax     # 0x2e450
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
subl %ecx, %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x3761
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x3771
movl -0x2c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jle 0x376f
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x3771
jmp 0x3773
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x24(%rbp)
jmp 0x372f
movl -0x30(%rbp), %eax
movl 0x2acad(%rip), %ecx     # 0x2e434
sarl %cl, %eax
movl %eax, %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
movl 0x2ac97(%rip), %ecx     # 0x2e434
sarl %cl, %eax
movl %eax, %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DAMASKER/tandem.c
// Function: count_thread
static void *count_thread(void *arg)
{ Merge_Arg  *data  = (Merge_Arg *) arg;
  int64      *kptr  = data->kptr;
  KmerPos    *asort = MG_alist;
  int         aend  = data->aend;

  uint64 ca, da;
  int    ia;
  int    ar, nr;
  int    ap, np;

  ia = data->abeg;
  da = asort[ia].code;
  while (ia < aend)
    { ca = da;
      ar = asort[ia].read;
      ap = asort[ia].rpos;
      kptr[ap & BMASK] += 1;
      while ((da = asort[++ia].code) == ca)
        { np = asort[ia].rpos;
          if ((nr = asort[ia].read) == ar)
            asort[ia].code = np - ap;
          else
            { asort[ia].code = 0;
              ar = nr;
            }
          ap = np;
          kptr[ap & BMASK] += 1;
        }
      asort[ia].code = 0;
    }
            
  return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x29785(%rip), %rax     # 0x2e458
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4e2a
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movslq -0x48(%rbp), %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x3c(%rbp)
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x4e0f
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x44(%rbp)
cmpl -0x40(%rbp), %eax
jne 0x4dcd
movl -0x4c(%rbp), %eax
subl -0x48(%rbp), %eax
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x4de9
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movl -0x44(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movslq -0x48(%rbp), %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x4d59
movq -0x20(%rbp), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
jmp 0x4d00
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/examples/bot.c
// Function: main
int main(int argc, char **argv)
{
    xmpp_ctx_t *ctx;
    xmpp_conn_t *conn;
    xmpp_log_t *log;
    char *jid, *pass;

    /* take a jid and password on the command line */
    if (argc != 3) {
	fprintf(stderr, "Usage: bot <jid> <pass>\n\n");
	return 1;
    }
    
    jid = argv[1];
    pass = argv[2];

    /* init library */
    xmpp_initialize();

    /* create a context */
    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
    ctx = xmpp_ctx_new(NULL, log);

    /* create a connection */
    conn = xmpp_conn_new(ctx);

    /* setup authentication information */
    xmpp_conn_set_jid(conn, jid);
    xmpp_conn_set_pass(conn, pass);

    /* initiate connection */
    xmpp_connect_client(conn, NULL, 0, conn_handler, ctx);

    /* enter the event loop - 
       our connect handler will trigger an exit */
    xmpp_run(ctx);

    /* release our connection and context */
    xmpp_conn_release(conn);
    xmpp_ctx_free(ctx);

    /* final shutdown of the library */
    xmpp_shutdown();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x2960
movq 0x156a5(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x10786(%rip), %rsi     # 0x130d3
movb $0x0, %al
callq 0x20d0
movl $0x1, -0x4(%rbp)
jmp 0x2a01
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x5e20
xorl %edi, %edi
callq 0x5ed0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x63b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x48f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x52d0
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5350
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
leaq -0x1a5(%rip), %rcx      # 0x2830
callq 0x53d0
movq -0x18(%rbp), %rdi
callq 0x6ea0
movq -0x20(%rbp), %rdi
callq 0x4ee0
movq -0x18(%rbp), %rdi
callq 0x6470
callq 0x5e30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)