LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::binary_search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
int db::binary_search(string key, vector<string> & fence_pointer)
{
	int len = fence_pointer.size();
	if(len == 0){return -1;}
	if(len == 1){return 0;}
	int start = 0;
	int end = len - 1;
	int mid;

	//for (int i=0 ; i<len ; i++){
	//	cout << fence_pointer[i] << endl;;
	//}

	if(key.compare(fence_pointer[start]) < 0){ return -1;}
	if(key.compare(fence_pointer[end]) > 0){ return -1;}

	while(end - start > 1){
		mid = (start + end)/2;
		if(key.compare(fence_pointer[mid]) < 0){
			end = mid;
		} 
		else if(key.compare(fence_pointer[mid]) == 0){
			return mid;
		}
		else{
			start = mid;
		}
	}
	return start;
}

// Assembly:
subq $0x38, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8020
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0xe559
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xe668
cmpl $0x1, 0x14(%rsp)
jne 0xe56d
movl $0x0, 0x34(%rsp)
jmp 0xe668
movl $0x0, 0x10(%rsp)
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x8040
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x6070
cmpl $0x0, %eax
jge 0xe5ad
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xe668
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x8040
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x6070
cmpl $0x0, %eax
jle 0xe5da
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xe668
jmp 0xe5dc
movl 0xc(%rsp), %eax
subl 0x10(%rsp), %eax
cmpl $0x1, %eax
jle 0xe660
movl 0x10(%rsp), %eax
addl 0xc(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0x8040
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x6070
cmpl $0x0, %eax
jge 0xe627
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xe65b
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0x8040
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x6070
cmpl $0x0, %eax
jne 0xe651
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xe668
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0xe65b
jmp 0xe5dc
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./LegacyBF.h
// Function: LegacyBF::AddHash(unsigned int, char*, unsigned int, unsigned int)
inline void LegacyBF::AddHash(uint32_t h, char* data,
                                            uint32_t num_lines,
                                            uint32_t total_bits) {
#ifdef NDEBUG
  static_cast<void>(total_bits);
#endif
  assert(num_lines > 0 && total_bits > 0);

  LegacyBloomImpl::AddHash(h, num_lines, num_probes_, data,
                           6);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x1c(%rsp)
movb %al, 0x17(%rsp)
jbe 0x10d1e
cmpl $0x0, 0x18(%rsp)
seta %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x10d28
jmp 0x10d2a
jmp 0x10d49
leaq 0x53700(%rip), %rdi     # 0x64431
leaq 0x53411(%rip), %rsi     # 0x64149
movl $0xc4, %edx
leaq 0x5370d(%rip), %rcx     # 0x64451
callq 0x6360
movq 0x8(%rsp), %rax
movl 0x2c(%rsp), %edi
movl 0x1c(%rsp), %esi
movl 0x4(%rax), %edx
movq 0x20(%rsp), %rcx
movl $0x6, %r8d
callq 0x12d80
addq $0x38, %rsp
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: LegacyLocalityBloomImpl<false>::EstimatedFpRate(unsigned long, unsigned long, int)
static double EstimatedFpRate(size_t keys, size_t bytes, int num_probes) {
    double bits_per_key = 8.0 * bytes / keys;
    double filter_rate = BloomMath::CacheLocalFpRate(bits_per_key, num_probes,
                                                     /*cache line bits*/ 512);
    if (!ExtraRotates) {
      // Good estimate of impact of flaw in index computation.
      // Adds roughly 0.002 around 50 bits/key and 0.001 around 100 bits/key.
      // The + 22 shifts it nicely to fit for lower bits/key.
      filter_rate += 0.1 / (bits_per_key * 0.75 + 22);
    }     // Always uses 32-bit hash
    double fingerprint_rate = BloomMath::FingerprintFpRate(keys, 32);
    return BloomMath::IndependentProbabilitySum(filter_rate, fingerprint_rate);
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movaps 0x53377(%rip), %xmm3    # 0x64120
movq 0x28(%rsp), %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x53375(%rip), %xmm2    # 0x64130
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x53306(%rip), %xmm1    # 0x640d8
mulsd %xmm1, %xmm0
movq 0x30(%rsp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movl 0x24(%rsp), %edi
movl $0x200, %esi            # imm = 0x200
callq 0x172c0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm1
movsd 0x532a7(%rip), %xmm0    # 0x640c8
mulsd %xmm0, %xmm1
movsd 0x532a3(%rip), %xmm0    # 0x640d0
addsd %xmm0, %xmm1
movsd 0x53287(%rip), %xmm0    # 0x640c0
divsd %xmm1, %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x20, %esi
callq 0x17360
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x17450
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: BU-DiSC[P]BF-Shared-Hashing/./FastLocalBF.h
// Function: FastLocalBF::CalculateSpace(int)
uint32_t CalculateSpace(const int num_entry)  {
    uint32_t num_cache_lines = 0;
    if (millibits_per_key_ > 0 && num_entry > 0) {
      num_cache_lines = static_cast<uint32_t>(
          (int64_t{num_entry} * millibits_per_key_ + 511999) / 512000);
    }
    return num_cache_lines * 64 + /*metadata*/ 5;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x0, (%rax)
jle 0x1188c
cmpl $0x0, -0xc(%rsp)
jle 0x1188c
movq -0x18(%rsp), %rcx
movslq -0xc(%rsp), %rax
movslq (%rcx), %rcx
imulq %rcx, %rax
addq $0x7cfff, %rax          # imm = 0x7CFFF
movl $0x7d000, %ecx          # imm = 0x7D000
cqto
idivq %rcx
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
shll $0x6, %eax
addl $0x5, %eax
retq
nopw (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./FastLocalBF.h
// Function: FastLocalBF::Finish()
void Finish()  {
    uint32_t len_with_metadata =
        CalculateSpace(static_cast<uint32_t>(hash_entries_.size()));
    space_ = len_with_metadata;
    char* data = new char[len_with_metadata];
    data_ = data;
    memset(data, 0, len_with_metadata);

    assert(data);
    assert(len_with_metadata >= 5);

    uint32_t len = len_with_metadata - 5;
    if (len > 0) {
      AddAllEntries(data, len);
    }

    // See BloomFilterPolicy::GetBloomBitsReader re: metadata
    // -1 = Marker for newer Bloom implementations
    data[len] = static_cast<char>(-1);
    // 0 = Marker for this sub-implementation
    data[len + 1] = static_cast<char>(0);
    // num_probes (and 0 in upper bits for 64-byte block size)
    data[len + 2] = static_cast<char>(num_probes_);
    // rest of metadata stays zero

    hash_entries_.clear();
    assert(hash_entries_.empty());

  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x20, %rdi
callq 0x14280
movq (%rsp), %rdi
movl %eax, %esi
callq 0x11840
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x1c(%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x18(%rax)
movl 0x1c(%rsp), %eax
movl %eax, %edi
callq 0x6040
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x62e0
cmpq $0x0, 0x10(%rsp)
je 0x11d13
jmp 0x11d32
leaq 0x5242a(%rip), %rdi     # 0x64144
leaq 0x5278d(%rip), %rsi     # 0x644ae
movl $0x2b, %edx
leaq 0x527e5(%rip), %rcx     # 0x64512
callq 0x6360
cmpl $0x5, 0x1c(%rsp)
jb 0x11d3b
jmp 0x11d5a
leaq 0x527eb(%rip), %rdi     # 0x6452d
leaq 0x52765(%rip), %rsi     # 0x644ae
movl $0x2c, %edx
leaq 0x527bd(%rip), %rcx     # 0x64512
callq 0x6360
movl 0x1c(%rsp), %eax
subl $0x5, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jbe 0x11d7e
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x14960
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movb $-0x1, (%rax,%rcx)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movl 0x4(%rdi), %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
addq $0x20, %rdi
callq 0x14c10
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x14c50
testb $0x1, %al
jne 0x11dd3
jmp 0x11dd5
jmp 0x11df4
leaq 0x52768(%rip), %rdi     # 0x64544
leaq 0x526cb(%rip), %rsi     # 0x644ae
movl $0x3d, %edx
leaq 0x52723(%rip), %rcx     # 0x64512
callq 0x6360
addq $0x28, %rsp
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::read_index_size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline int db::read_index_size( string filename ){
	//int flags = O_RDWR | O_DIRECT | O_SYNC;
	int flags = O_RDWR;
	mode_t mode=S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;//644

	int fd = open(filename.c_str(), flags, mode );
	if (fd <= 0) {
		cout << "Cannot open partiton file " << filename << endl;
    	printf("Error %s\n", strerror(errno));
		return 0;
	}

	char* buf;
	posix_memalign((void**)&buf,getpagesize(),DB_PAGE_SIZE);

	memset(buf, 0, DB_PAGE_SIZE);
	read( fd, buf, DB_PAGE_SIZE );
	
	int size;
	int key_size;
	memcpy(&size, buf, sizeof(unsigned int));	
	index_size = size;
	memcpy(&key_size, buf+sizeof(unsigned int), sizeof(unsigned int));	
	free( buf );
	if(fd > 0)
		close( fd );	
	return size;
}

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rax, 0x48(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x2, 0x3c(%rsp)
movl $0x1a4, 0x38(%rsp)      # imm = 0x1A4
callq 0x6250
movq %rax, %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movb $0x0, %al
callq 0x63e0
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
jg 0x12725
movq 0x6d8ed(%rip), %rdi     # 0x7ffc0
leaq 0x51e8a(%rip), %rsi     # 0x64564
callq 0x6500
movq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x6490
movq %rax, %rdi
movq 0x6d8b2(%rip), %rsi     # 0x7ffa8
callq 0x6540
callq 0x6090
movl (%rax), %edi
callq 0x61e0
movq %rax, %rsi
leaq 0x51e49(%rip), %rdi     # 0x6455a
movb $0x0, %al
callq 0x60a0
movl $0x0, 0x54(%rsp)
jmp 0x127a8
callq 0x6890
movslq %eax, %rsi
leaq 0x28(%rsp), %rdi
movl $0x1000, %edx           # imm = 0x1000
callq 0x62c0
movq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x62e0
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6730
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x24(%rsp)
movl 0x24(%rsp), %ecx
movl %ecx, 0x134(%rax)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x65c0
cmpl $0x0, 0x34(%rsp)
jle 0x127a0
movl 0x34(%rsp), %edi
callq 0x6910
movl 0x24(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::read_bf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char*, int)
inline void db::read_bf(string filename, char* bf_buffer, int size){
	//int flags = O_RDWR | O_DIRECT;
	int flags = O_RDWR;
	mode_t mode=S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;//644

	
	int fd_ = open(filename.c_str(), flags, mode );
	if (fd_ <= 0) {
		cout << "Cannot open partiton file " << filename << endl;
    	printf("Error %s\n", strerror(errno));
	}
	
	char* buffer_;	
	posix_memalign((void**)&buffer_,DB_PAGE_SIZE,DB_PAGE_SIZE);
	memset(buffer_, 0, DB_PAGE_SIZE);

	for(int i = 0; i < size; i++){
		if ( i%DB_PAGE_SIZE == 0){
			memset(buffer_, 0, DB_PAGE_SIZE);
			read( fd_, buffer_, DB_PAGE_SIZE );
		}
		memcpy(bf_buffer+i, buffer_+(i%DB_PAGE_SIZE), sizeof(char));
	}
	//cout << "string " << blo_bf.size() << endl;
	//for(int i = 0; i < blo_bf.size(); i++){
	//	cout << hex << (unsigned int)blo_bf[i] << endl;
	//}

	if(fd_ > 0)
		close( fd_ );	
}

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rax, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movl $0x2, 0x38(%rsp)
movl $0x1a4, 0x34(%rsp)      # imm = 0x1A4
callq 0x6250
movq %rax, %rdi
movl 0x38(%rsp), %esi
movl 0x34(%rsp), %edx
movb $0x0, %al
callq 0x63e0
movl %eax, 0x30(%rsp)
cmpl $0x0, 0x30(%rsp)
jg 0x12ae7
movq 0x6d51e(%rip), %rdi     # 0x7ffc0
leaq 0x51abb(%rip), %rsi     # 0x64564
callq 0x6500
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x6490
movq %rax, %rdi
movq 0x6d4e3(%rip), %rsi     # 0x7ffa8
callq 0x6540
callq 0x6090
movl (%rax), %edi
callq 0x61e0
movq %rax, %rsi
leaq 0x51a7a(%rip), %rdi     # 0x6455a
movb $0x0, %al
callq 0x60a0
leaq 0x28(%rsp), %rdi
movl $0x1000, %edx           # imm = 0x1000
movq %rdx, %rsi
callq 0x62c0
movq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x62e0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x12b99
movl 0x24(%rsp), %eax
movl $0x1000, %ecx           # imm = 0x1000
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x12b51
movq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x62e0
movl 0x30(%rsp), %edi
movq 0x28(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x6730
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movslq 0x24(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
movl $0x1000, %esi           # imm = 0x1000
cltd
idivl %esi
movq (%rsp), %rax
movl %edx, %esi
movq 0x8(%rsp), %rdx
movslq %esi, %rsi
movb (%rdx,%rsi), %dl
movb %dl, (%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x12b12
cmpl $0x0, 0x30(%rsp)
jle 0x12ba9
movl 0x30(%rsp), %edi
callq 0x6910
addq $0x58, %rsp
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: LegacyLocalityBloomImpl<false>::AddHash(unsigned int, unsigned int, int, char*, int)
static inline void AddHash(uint32_t h, uint32_t num_lines, int num_probes,
                             char *data, int log2_cache_line_bytes) {
    const int log2_cache_line_bits = log2_cache_line_bytes + 3;

    char *data_at_offset =
        data + (GetLine(h, num_lines) << log2_cache_line_bytes);
    const uint32_t delta = (h >> 17) | (h << 15);
    for (int i = 0; i < num_probes; ++i) {
      // Mask to bit-within-cache-line address
      const uint32_t bitpos = h & ((1 << log2_cache_line_bits) - 1);
      data_at_offset[bitpos / 8] |= (1 << (bitpos % 8));
      if (ExtraRotates) {
        h = (h >> log2_cache_line_bits) | (h << (32 - log2_cache_line_bits));
      }
      h += delta;
    }
  }

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq %rcx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
addl $0x3, %eax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %edi
movl 0x40(%rsp), %esi
callq 0x12e60
movl %eax, %edx
movq 0x8(%rsp), %rax
movl 0x2c(%rsp), %ecx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl 0x44(%rsp), %eax
shrl $0x11, %eax
movl 0x44(%rsp), %ecx
shll $0xf, %ecx
orl %ecx, %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x12e53
movl 0x44(%rsp), %eax
movl 0x28(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movl 0x1c(%rsp), %eax
addl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x12df1
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: FastLocalBloomImpl::ChooseNumProbes(int)
static inline int ChooseNumProbes(int millibits_per_key) {
    // Since this implementation can (with AVX2) make up to 8 probes
    // for the same cost, we pick the most accurate num_probes, based
    // on actual tests of the implementation. Note that for higher
    // bits/key, the best choice for cache-local Bloom can be notably
    // smaller than standard bloom, e.g. 9 instead of 11 @ 16 b/k.
    if (millibits_per_key <= 2080) {
      return 1;
    } else if (millibits_per_key <= 3580) {
      return 2;
    } else if (millibits_per_key <= 5100) {
      return 3;
    } else if (millibits_per_key <= 6640) {
      return 4;
    } else if (millibits_per_key <= 8300) {
      return 5;
    } else if (millibits_per_key <= 10070) {
      return 6;
    } else if (millibits_per_key <= 11720) {
      return 7;
    } else if (millibits_per_key <= 14001) {
      // Would be something like <= 13800 but sacrificing *slightly* for
      // more settings using <= 8 probes.
      return 8;
    } else if (millibits_per_key <= 16050) {
      return 9;
    } else if (millibits_per_key <= 18300) {
      return 10;
    } else if (millibits_per_key <= 22001) {
      return 11;
    } else if (millibits_per_key <= 25501) {
      return 12;
    } else if (millibits_per_key > 50000) {
      // Top out at 24 probes (three sets of 8)
      return 24;
    } else {
      // Roughly optimal choices for remaining range
      // e.g.
      // 28000 -> 12, 28001 -> 13
      // 50000 -> 23, 50001 -> 24
      return (millibits_per_key - 1) / 2000 - 1;
    }
  }

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x820, -0x8(%rsp)      # imm = 0x820
jg 0x1318b
movl $0x1, -0x4(%rsp)
jmp 0x132a3
cmpl $0xdfc, -0x8(%rsp)      # imm = 0xDFC
jg 0x131a2
movl $0x2, -0x4(%rsp)
jmp 0x132a3
cmpl $0x13ec, -0x8(%rsp)     # imm = 0x13EC
jg 0x131b9
movl $0x3, -0x4(%rsp)
jmp 0x132a3
cmpl $0x19f0, -0x8(%rsp)     # imm = 0x19F0
jg 0x131d0
movl $0x4, -0x4(%rsp)
jmp 0x132a3
cmpl $0x206c, -0x8(%rsp)     # imm = 0x206C
jg 0x131e7
movl $0x5, -0x4(%rsp)
jmp 0x132a3
cmpl $0x2756, -0x8(%rsp)     # imm = 0x2756
jg 0x131fe
movl $0x6, -0x4(%rsp)
jmp 0x132a3
cmpl $0x2dc8, -0x8(%rsp)     # imm = 0x2DC8
jg 0x13215
movl $0x7, -0x4(%rsp)
jmp 0x132a3
cmpl $0x36b1, -0x8(%rsp)     # imm = 0x36B1
jg 0x13229
movl $0x8, -0x4(%rsp)
jmp 0x132a3
cmpl $0x3eb2, -0x8(%rsp)     # imm = 0x3EB2
jg 0x1323d
movl $0x9, -0x4(%rsp)
jmp 0x132a3
cmpl $0x477c, -0x8(%rsp)     # imm = 0x477C
jg 0x13251
movl $0xa, -0x4(%rsp)
jmp 0x132a3
cmpl $0x55f1, -0x8(%rsp)     # imm = 0x55F1
jg 0x13265
movl $0xb, -0x4(%rsp)
jmp 0x132a3
cmpl $0x639d, -0x8(%rsp)     # imm = 0x639D
jg 0x13279
movl $0xc, -0x4(%rsp)
jmp 0x132a3
cmpl $0xc350, -0x8(%rsp)     # imm = 0xC350
jle 0x1328d
movl $0x18, -0x4(%rsp)
jmp 0x132a3
movl -0x8(%rsp), %eax
subl $0x1, %eax
movl $0x7d0, %ecx            # imm = 0x7D0
cltd
idivl %ecx
subl $0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: LegacyNoLocalityBloomImpl::ChooseNumProbes(int)
static inline int ChooseNumProbes(int bits_per_key) {
    // We intentionally round down to reduce probing cost a little bit
    int num_probes = static_cast<int>(bits_per_key * 0.69);  // 0.69 =~ ln(2)
    if (num_probes < 1) num_probes = 1;
    if (num_probes > 30) num_probes = 30;
    return num_probes;
  }

// Assembly:
movl %edi, -0x4(%rsp)
cvtsi2sdl -0x4(%rsp), %xmm0
movsd 0x5044e(%rip), %xmm1    # 0x64100
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x8(%rsp)
cmpl $0x1, -0x8(%rsp)
jge 0x13ccd
movl $0x1, -0x8(%rsp)
cmpl $0x1e, -0x8(%rsp)
jle 0x13cdc
movl $0x1e, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: FastLocalBloomImpl::PrepareHash(unsigned int, unsigned int, char const*, unsigned int*)
static inline void PrepareHash(uint32_t h1, uint32_t len_bytes,
                                 const char *data,
                                 uint32_t /*out*/ *byte_offset) {
    uint32_t bytes_to_cache_line = fastrange32(len_bytes >> 6,h1) << 6;
    PREFETCH(data + bytes_to_cache_line, 0 /* rw */, 1 /* locality */);
    PREFETCH(data + bytes_to_cache_line + 63, 0 /* rw */, 1 /* locality */);
    *byte_offset = bytes_to_cache_line;
  }

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl 0x20(%rsp), %edi
shrl $0x6, %edi
movl 0x24(%rsp), %esi
callq 0x14f00
shll $0x6, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
addq %rcx, %rax
prefetcht2 (%rax)
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
addq %rcx, %rax
addq $0x3f, %rax
prefetcht2 (%rax)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nop
// File: BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: FastLocalBloomImpl::AddHashPrepared(unsigned int, int, char*)
static inline void AddHashPrepared(uint32_t h2, int num_probes,
                                     char *data_at_cache_line) {
    uint32_t h = h2;
    for (int i = 0; i < num_probes; ++i, h *= uint32_t{0x9e3779b9}) {
      // 9-bit address within 512 bit cache line
      int bitpos = h >> (32 - 9);
      data_at_cache_line[bitpos >> 3] |= (uint8_t{1} << (bitpos & 7));
    }
  }

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x8(%rsp), %eax
jge 0x14e31
movl -0x14(%rsp), %eax
shrl $0x17, %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
imull $0x9e3779b9, -0x14(%rsp), %eax # imm = 0x9E3779B9
movl %eax, -0x14(%rsp)
jmp 0x14ddd
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::QueryFilter(int, int, std::vector<unsigned long, std::allocator<unsigned long>>*, char**)
inline bool db::QueryFilter( int i, int bf_no, vector<uint64_t>* hash_digests, char** bf_list)
{
	bool result = true;
	int tmp_filter_size = filter_size;
	int tmp_num_lines = num_lines;
/*	
	if(i == num_levels - 1 && bf_no == num_sstPerLevel[i]-1){
		tmp_filter_size = last_filter_size;
	}
*/	
	if(i == num_levels - 1 && bf_no == num_sstPerLevel[i]-1){
		tmp_num_lines = last_num_lines;
	}


	if(fastlocal_bf){
		for(int blo = 0; blo < num_filter_units; blo++){
			if(!FastLocalBF::MayMatch(hash_digests->at(blo), tmp_filter_size, num_probes, bf_list[blo])) return false;
		}
	}else{
		for(int blo = 0; blo < num_filter_units; blo++){
			if(!LegacyBF::MayMatch(hash_digests->at(blo), tmp_num_lines, num_probes, bf_list[blo])) return false;
		}
	}
	

	return result;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movl %edx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movb $0x1, 0x2f(%rsp)
movl 0x120(%rcx), %eax
movl %eax, 0x28(%rsp)
movl 0x128(%rcx), %eax
movl %eax, 0x24(%rsp)
movl 0x44(%rsp), %eax
movl 0xdc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x150ec
movq 0x10(%rsp), %rdi
movl 0x40(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0xe8, %rdi
movslq 0x44(%rsp), %rsi
callq 0x113c0
movq %rax, %rcx
movl 0xc(%rsp), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x150ec
movq 0x10(%rsp), %rax
movl 0x12c(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x10c(%rax)
je 0x15169
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x110(%rcx), %eax
jge 0x15167
movq 0x38(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x11c50
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rdi
movl 0x28(%rsp), %esi
movl 0x130(%rax), %edx
movq 0x30(%rsp), %rax
movslq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
callq 0x157b0
testb $0x1, %al
jne 0x15158
movb $0x0, 0x57(%rsp)
jmp 0x151df
jmp 0x1515a
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x15102
jmp 0x151d5
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x110(%rcx), %eax
jge 0x151d3
movq 0x38(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x11c50
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rdi
movl 0x24(%rsp), %esi
movl 0x130(%rax), %edx
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
callq 0x15810
testb $0x1, %al
jne 0x151c4
movb $0x0, 0x57(%rsp)
jmp 0x151df
jmp 0x151c6
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x15171
jmp 0x151d5
movb 0x2f(%rsp), %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::GetFromIndex(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline int db::GetFromIndex( int l, int bf_no, string key )
{
	char** index = blk_fp_prime[l][bf_no];

	int index_pos = binary_search(key, index, blk_size_prime[l][bf_no]);
	//cout << key << " " << l << " " << index_pos << endl;
	return index_pos;
}

// Assembly:
subq $0x78, %rsp
movq %rcx, 0x8(%rsp)
movl %esi, %eax
movq 0x8(%rsp), %rsi
movq %rdi, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
movl %edx, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x160(%rax), %rax
movslq 0x6c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x68(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x58(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6260
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x168(%rdi), %rax
movslq 0x6c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x68(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
callq 0x15a50
movl %eax, 0x20(%rsp)
jmp 0x1527b
leaq 0x30(%rsp), %rdi
callq 0x6340
movl 0x20(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x6340
movq 0x28(%rsp), %rdi
callq 0x6850
nopl (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./FastLocalBF.h
// Function: FastLocalBF::MayMatch(unsigned long, int, int, char const*)
static bool MayMatch(uint64_t h, int len_bytes, int  num_probes, const char* data) {
    
    uint32_t byte_offset;
    FastLocalBloomImpl::PrepareHash(Lower32of64(h), len_bytes, data,
                                    /*out*/ &byte_offset);
    //if(h%10 == 0) cout << byte_offset << endl;
    return FastLocalBloomImpl::HashMayMatchPrepared(Upper32of64(h), num_probes,
                                                    data + byte_offset);
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x14d70
movl %eax, %edi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0x14d10
movq 0x20(%rsp), %rdi
callq 0x14db0
movl %eax, %edi
movl 0x18(%rsp), %esi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %eax
addq %rax, %rdx
callq 0x15880
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./LegacyBF.h
// Function: LegacyBF::MayMatch(unsigned long, int, int, char*)
static bool MayMatch(uint64_t hash_digest, int num_lines, int num_probes, char* data) {  // originally BloomHash is used, to make it compatible with sharing hashing, change it with GetSliceHash64
    uint32_t hash = Lower32of64(hash_digest);
    //std::cout << Lower32of64(hash_digest) << std::endl;
    //std::cout << hash << std::endl;
    uint32_t byte_offset;
    LegacyBloomImpl::PrepareHashMayMatch(
        hash, num_lines, data, /*out*/ &byte_offset, 6);
    return LegacyBloomImpl::HashMayMatchPrepared(
        hash, num_probes, data + byte_offset, 6);
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x14d70
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movl $0x6, %r8d
callq 0x15910
movl 0xc(%rsp), %edi
movl 0x18(%rsp), %esi
movq 0x10(%rsp), %rdx
movl 0x8(%rsp), %eax
addq %rax, %rdx
movl $0x6, %ecx
callq 0x15990
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: LegacyLocalityBloomImpl<false>::PrepareHashMayMatch(unsigned int, unsigned int, char const*, unsigned int*, int)
static inline void PrepareHashMayMatch(uint32_t h, uint32_t num_lines,
                                         const char *data,
                                         uint32_t /*out*/ *byte_offset,
                                         int log2_cache_line_bytes) {
    uint32_t b = GetLine(h, num_lines) << log2_cache_line_bytes;
    PREFETCH(data + b, 0 /* rw */, 1 /* locality */);
    PREFETCH(data + b + ((1 << log2_cache_line_bytes) - 1), 0 /* rw */,
             1 /* locality */);
    *byte_offset = b;
  }

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x12e60
movl 0xc(%rsp), %ecx
shll %cl, %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rsp), %ecx
addq %rcx, %rax
prefetcht2 (%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rsp), %ecx
addq %rcx, %rax
movl 0xc(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
prefetcht2 (%rax)
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: LegacyLocalityBloomImpl<false>::HashMayMatchPrepared(unsigned int, int, char const*, int)
static inline bool HashMayMatchPrepared(uint32_t h, int num_probes,
                                          const char *data_at_offset,
                                          int log2_cache_line_bytes) {
    const int log2_cache_line_bits = log2_cache_line_bytes + 3;

    const uint32_t delta = (h >> 17) | (h << 15);
    for (int i = 0; i < num_probes; ++i) {
      // Mask to bit-within-cache-line address
      const uint32_t bitpos = h & ((1 << log2_cache_line_bits) - 1);
      if (((data_at_offset[bitpos / 8]) & (1 << (bitpos % 8))) == 0) {
        return false;
      }
      if (ExtraRotates) {
        h = (h >> log2_cache_line_bits) | (h << (32 - log2_cache_line_bits));
      }
      h += delta;
    }
    return true;
  }

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
addl $0x3, %eax
movl %eax, -0x20(%rsp)
movl -0x8(%rsp), %eax
shrl $0x11, %eax
movl -0x8(%rsp), %ecx
shll $0xf, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rsp)
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x15a35
movl -0x8(%rsp), %eax
movl -0x20(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x2c(%rsp)
movq -0x18(%rsp), %rax
movl -0x2c(%rsp), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
movl -0x2c(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x15a1c
movb $0x0, -0x1(%rsp)
jmp 0x15a3a
movl -0x24(%rsp), %eax
addl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x159c8
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/db.cpp
// Function: db::binary_search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char**, int)
inline int db::binary_search(string key, char** indexes, int size)
{
	int len = size;
	if(len == 0){return -1;}
	if(len == 1){return 0;}
	int start = 0;
	int end = len - 1;
	int mid;

	//for (int i=0 ; i<len ; i++){
	//	cout << fence_pointer[i] << endl;;
	//}

	if(strcmp(key.c_str(), indexes[start]) < 0){ return -1;}
	if(strcmp(key.c_str(), indexes[end]) > 0){ return -1;}

	while(end - start > 1){
		mid = (start + end)/2;
		if(strcmp(key.c_str(), indexes[mid])< 0){
			end = mid;
		} 
		else if(strcmp(key.c_str(), indexes[mid])  == 0){
			return mid;
		}
		else{
			start = mid;
		}
	}
	return start;
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
jne 0x15a88
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x15baf
cmpl $0x1, 0x20(%rsp)
jne 0x15a9c
movl $0x0, 0x44(%rsp)
jmp 0x15baf
movq 0x8(%rsp), %rdi
movl $0x0, 0x1c(%rsp)
movl 0x20(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x18(%rsp)
callq 0x6250
movq %rax, %rdi
movq 0x28(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6710
cmpl $0x0, %eax
jge 0x15ae1
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x15baf
movq 0x8(%rsp), %rdi
callq 0x6250
movq %rax, %rdi
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6710
cmpl $0x0, %eax
jle 0x15b13
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x15baf
jmp 0x15b15
movl 0x18(%rsp), %eax
subl 0x1c(%rsp), %eax
cmpl $0x1, %eax
jle 0x15ba7
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x14(%rsp)
callq 0x6250
movq %rax, %rdi
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6710
cmpl $0x0, %eax
jge 0x15b69
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
jmp 0x15ba2
movq 0x8(%rsp), %rdi
callq 0x6250
movq %rax, %rdi
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6710
cmpl $0x0, %eax
jne 0x15b98
movl 0x14(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x15baf
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x15ba2
jmp 0x15b15
movl 0x1c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: BloomMath::CacheLocalFpRate(double, int, int)
static double CacheLocalFpRate(double bits_per_key, int num_probes,
                                 int cache_line_bits) {
    double keys_per_cache_line = cache_line_bits / bits_per_key;
    // A reasonable estimate is the average of the FP rates for one standard
    // deviation above and below the mean bucket occupancy. See
    // https://github.com/facebook/rocksdb/wiki/RocksDB-Bloom-Filter#the-math
    double keys_stddev = std::sqrt(keys_per_cache_line);
    double crowded_fp = StandardFpRate(
        cache_line_bits / (keys_per_cache_line + keys_stddev), num_probes);
    double uncrowded_fp = StandardFpRate(
        cache_line_bits / (keys_per_cache_line - keys_stddev), num_probes);
    return (crowded_fp + uncrowded_fp) / 2;
  }

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movl %edi, 0x2c(%rsp)
movl %esi, 0x28(%rsp)
cvtsi2sdl 0x28(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x6410
movsd %xmm0, 0x18(%rsp)
cvtsi2sdl 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addsd 0x18(%rsp), %xmm1
divsd %xmm1, %xmm0
movl 0x2c(%rsp), %edi
callq 0x174a0
movsd %xmm0, 0x10(%rsp)
cvtsi2sdl 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
subsd 0x18(%rsp), %xmm1
divsd %xmm1, %xmm0
movl 0x2c(%rsp), %edi
callq 0x174a0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd 0x4cdb5(%rip), %xmm1    # 0x64108
divsd %xmm1, %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/./bloom_impl.h
// Function: BloomMath::FingerprintFpRate(unsigned long, int)
static double FingerprintFpRate(size_t num_keys, int fingerprint_bits) {
    double inv_fingerprint_space = std::pow(0.5, fingerprint_bits);
    // Base estimate assumes each key maps to a unique fingerprint.
    // Could be > 1 in extreme cases.
    double base_estimate = num_keys * inv_fingerprint_space;
    // To account for potential overlap, we choose between two formulas
    if (base_estimate > 0.0001) {
      // A very good formula assuming we don't construct a floating point
      // number extremely close to 1. Always produces a probability < 1.
      return 1.0 - std::exp(-base_estimate);
    } else {
      // A very good formula when base_estimate is far below 1. (Subtract
      // away the integral-approximated sum that some key has same hash as
      // one coming before it in a list.)
      return base_estimate - (base_estimate * base_estimate * 0.5);
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %edi
movsd 0x4cd6f(%rip), %xmm0    # 0x640e8
callq 0x174e0
movsd %xmm0, 0x8(%rsp)
movaps 0x4cd95(%rip), %xmm1    # 0x64120
movq 0x18(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4cd93(%rip), %xmm1    # 0x64130
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd 0x4cd4c(%rip), %xmm1    # 0x64110
ucomisd %xmm1, %xmm0
jbe 0x17402
movsd (%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x6870
movaps %xmm0, %xmm1
movsd 0x4cd02(%rip), %xmm0    # 0x640f8
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x1743e
movsd (%rsp), %xmm1
movsd (%rsp), %xmm0
mulsd (%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x4ccb8(%rip), %xmm2    # 0x640e8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/BF_bit.cpp
// Function: BFHash::prepareHashFuncs(HashType)
void BFHash:: prepareHashFuncs(HashType ht){
   ht_ = ht;
   filter_unit_hash_funcs_ = vector<HashType> (num_filter_units_,  ht);
   hash_digests_ = new vector<uint64_t> (num_filter_units_, 0);
   filter_unit_seeds_ = vector<uint32_t> (1, 0xbc9f1d34);
   uint32_t last_seed = 0xbc9f1d34;
   for(int i = 1; i < num_filter_units_; i++){
      last_seed = (last_seed << 17 | last_seed >> 15) + last_seed;
      filter_unit_seeds_.push_back(last_seed);
   }
}

// Assembly:
subq $0xb8, %rsp
movl %edi, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
movl %eax, 0x62751(%rip)     # 0x804dc
movslq 0x6273e(%rip), %rax     # 0x804d0
movq %rax, 0x38(%rsp)
leaq 0x97(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x1e9b0
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rcx
leaq 0x98(%rsp), %rdi
leaq 0xb4(%rsp), %rdx
callq 0x1e9c0
jmp 0x1ddca
leaq 0x62797(%rip), %rdi     # 0x80568
leaq 0x98(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x1ea40
movq 0x10(%rsp), %rdi
callq 0x1e950
leaq 0x97(%rsp), %rdi
callq 0x1ea80
movl $0x18, %edi
callq 0x6510
movq %rax, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movb $0x1, 0x76(%rsp)
movslq 0x626b6(%rip), %rax     # 0x804d0
movq %rax, 0x28(%rsp)
movq $0x0, 0x78(%rsp)
leaq 0x77(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x11120
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rcx
leaq 0x78(%rsp), %rdx
callq 0x11130
jmp 0x1de52
movq 0x18(%rsp), %rax
movb $0x0, 0x76(%rsp)
movq %rax, 0x62735(%rip)     # 0x80598
leaq 0x77(%rsp), %rdi
callq 0x88d0
movl $0xbc9f1d34, 0x54(%rsp) # imm = 0xBC9F1D34
leaq 0x53(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x13d90
movq 0x8(%rsp), %rcx
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
leaq 0x54(%rsp), %rdx
callq 0x1ea90
jmp 0x1de9f
leaq 0x626da(%rip), %rdi     # 0x80580
leaq 0x58(%rsp), %rsi
callq 0x1eb10
leaq 0x58(%rsp), %rdi
callq 0x13cf0
leaq 0x53(%rsp), %rdi
callq 0x13f50
movl $0xbc9f1d34, 0x4c(%rsp) # imm = 0xBC9F1D34
movl $0x1, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x625f2(%rip), %eax     # 0x804d0
jge 0x1df90
movl 0x4c(%rsp), %eax
shll $0x11, %eax
movl 0x4c(%rsp), %ecx
shrl $0xf, %ecx
orl %ecx, %eax
addl 0x4c(%rsp), %eax
movl %eax, 0x4c(%rsp)
leaq 0x6267d(%rip), %rdi     # 0x80580
leaq 0x4c(%rsp), %rsi
callq 0x1eb50
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x1ded4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x97(%rsp), %rdi
callq 0x1ea80
jmp 0x1df98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x77(%rsp), %rdi
callq 0x88d0
testb $0x1, 0x76(%rsp)
jne 0x1df64
jmp 0x1df6e
movq 0x18(%rsp), %rdi
callq 0x64c0
jmp 0x1df98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x53(%rsp), %rdi
callq 0x13f50
jmp 0x1df98
addq $0xb8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/BF_bit.cpp
// Function: get_index(unsigned long, int, int, int*)
void get_index( uint64_t hash_digest, int BF_index, int BF_size, int *index )
{

  uint64_t m_int_hash = hash_digest;
  index[0] = m_int_hash % BF_size;
  // get BF indices
  uint64_t delta = (m_int_hash << 17 | m_int_hash >> 15);
  for( uint32_t n=1 ; n<BF_index ; n++ ){
    m_int_hash = m_int_hash + delta; 
    index[n] =  m_int_hash % BF_size;
  }

  return;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movslq -0x10(%rsp), %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x20(%rsp), %rax
shlq $0x11, %rax
movq -0x20(%rsp), %rcx
shrq $0xf, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rsp)
movl $0x1, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jae 0x1e8d7
movq -0x20(%rsp), %rax
addq -0x28(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movslq -0x10(%rsp), %rcx
xorl %edx, %edx
divq %rcx
movq -0x18(%rsp), %rax
movl -0x2c(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x1e896
retq
nopl (%rax,%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/md5.cpp
// Function: MD5::finalize()
MD5& MD5::finalize()
{
  static unsigned char padding[64] = {
    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  };
 
  if (!finalized) {
    // Save number of bits
    unsigned char bits[8];
    encode(bits, count, 8);
 
    // pad out to 56 mod 64.
    size_type index = count[0] / 8 % 64;
    size_type padLen = (index < 56) ? (56 - index) : (120 - index);
    update(padding, padLen);
 
    // Append length (before padding)
    update(bits, 8);
 
    // Store state in digest
    encode(digest, state, 16);
 
    // Zeroize sensitive information.
    memset(buffer, 0, sizeof buffer);
    memset(count, 0, sizeof count);
 
    finalized=true;
  }
 
  return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, (%rax)
jne 0x4afb6
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
addq $0x44, %rsi
movl $0x8, %edx
callq 0x4b060
movq 0x8(%rsp), %rax
movl 0x44(%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, 0x14(%rsp)
cmpl $0x38, 0x14(%rsp)
jae 0x4af2c
movl $0x38, %eax
subl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x4af39
movl $0x78, %eax
subl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edx
leaq 0x355bf(%rip), %rsi     # 0x80510
callq 0x4bbd0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl $0x8, %edx
callq 0x4bbd0
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x5c, %rdi
addq $0x4c, %rsi
movl $0x10, %edx
callq 0x4b060
movq 0x8(%rsp), %rdi
addq $0x1, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x62e0
movq 0x8(%rsp), %rdi
addq $0x44, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x62e0
movq 0x8(%rsp), %rax
movb $0x1, (%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
// File: BU-DiSC[P]BF-Shared-Hashing/hash/md5.cpp
// Function: MD5::encode(unsigned char*, unsigned int const*, unsigned int)
void MD5::encode(uint1 output[], const uint4 input[], size_type len)
{
  for (size_type i = 0, j = 0; j < len; i++, j += 4) {
    output[j] = input[i] & 0xff;
    output[j+1] = (input[i] >> 8) & 0xff;
    output[j+2] = (input[i] >> 16) & 0xff;
    output[j+3] = (input[i] >> 24) & 0xff;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x14(%rsp), %eax
jae 0x4b13b
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
movl (%rax,%rcx,4), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rsp), %rax
movl -0x18(%rsp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
movl -0x1c(%rsp), %eax
addl $0x4, %eax
movl %eax, -0x1c(%rsp)
jmp 0x4b07e
retq
nopl (%rax)
// File: BU-DiSC[P]BF-Shared-Hashing/hash/md5.cpp
// Function: MD5::update(unsigned char const*, unsigned int)
void MD5::update(const unsigned char input[], size_type length)
{
  // compute number of bytes mod 64
  size_type index = count[0] / 8 % blocksize;
 
  // Update number of bits
  if ((count[0] += (length << 3)) < (length << 3))
    count[1]++;
  count[1] += (length >> 29);
 
  // number of bytes we need to fill in buffer
  size_type firstpart = 64 - index;
 
  size_type i;
 
  // transform as many times as possible.
  if (length >= firstpart)
  {
    // fill buffer first, transform
    memcpy(&buffer[index], input, firstpart);
    transform(buffer);
 
    // transform chunks of blocksize (64 bytes)
    for (i = firstpart; i + blocksize <= length; i += blocksize)
      transform(&input[i]);
 
    index = 0;
  }
  else
    i = 0;
 
  // buffer remaining input
  memcpy(&buffer[index], &input[i], length-i);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x44(%rcx), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
shll $0x3, %eax
addl 0x44(%rcx), %eax
movl %eax, 0x44(%rcx)
movl 0x14(%rsp), %ecx
shll $0x3, %ecx
cmpl %ecx, %eax
jae 0x4bc1d
movq (%rsp), %rax
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
movq (%rsp), %rax
movl 0x14(%rsp), %ecx
shrl $0x1d, %ecx
addl 0x48(%rax), %ecx
movl %ecx, 0x48(%rax)
movl $0x40, %eax
subl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
cmpl 0xc(%rsp), %eax
jb 0x4bcb5
movq (%rsp), %rdi
addq $0x1, %rdi
movl 0x10(%rsp), %eax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0x6440
movq (%rsp), %rdi
movq %rdi, %rsi
addq $0x1, %rsi
callq 0x4b140
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
addl $0x40, %eax
cmpl 0x14(%rsp), %eax
ja 0x4bcab
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x8(%rsp), %eax
addq %rax, %rsi
callq 0x4b140
movl 0x8(%rsp), %eax
addl $0x40, %eax
movl %eax, 0x8(%rsp)
jmp 0x4bc7c
movl $0x0, 0x10(%rsp)
jmp 0x4bcbd
movl $0x0, 0x8(%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
movl 0x10(%rsp), %eax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movl 0x8(%rsp), %eax
addq %rax, %rsi
movl 0x14(%rsp), %eax
subl 0x8(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x6440
addq $0x28, %rsp
retq
nop