LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/skaringa[P]DistanceCalculation/Sample.cpp
// Function: compareDistanceCalculators(Point&, Point&, std::__cxx11::list<DistanceCalculator*, std::allocator<DistanceCalculator*>>&)
static void compareDistanceCalculators(Point & p1, Point & p2, list<DistanceCalculator*> & calcs) 
{
	cout << "Distance " << p1.name() << " - " << p2.name() << ": " << endl;

	list<DistanceCalculator*>::const_iterator ical;
	for (ical = calcs.begin(); ical != calcs.end(); ++ical) {
		DistanceCalculator::use(*ical);
		cout << setw(12) << (*ical)->name() << ": ";
		cout << setw(8) << setprecision(6) << fixed << p1.distance(p2) << " km" << endl;
	}	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq 0x333e(%rip), %r12      # 0x5fd0
leaq 0x1562(%rip), %rsi      # 0x41fb
movq %r12, %rdi
callq 0x2180
movq %rax, %rbx
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2150
leaq 0x1546(%rip), %rsi      # 0x4205
movq %rax, %rdi
callq 0x2180
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2150
leaq 0x1524(%rip), %rsi      # 0x4209
movq %rax, %rdi
callq 0x2180
leaq 0x1518(%rip), %rbp      # 0x420c
movq %r13, %rbx
movq %rax, %rdi
callq 0x20c0
movq (%rbx), %rbx
cmpq %r13, %rbx
je 0x2da3
movq 0x10(%rbx), %rdi
callq 0x23c4
movq (%r12), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%r12,%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x2180
movq %rax, %rdi
leaq 0x14c5(%rip), %rsi      # 0x4209
callq 0x2180
movq (%r12), %rax
movq -0x18(%rax), %rcx
movq $0x8, 0x10(%r12,%rcx)
movq -0x18(%rax), %rcx
movq $0x6, 0x8(%r12,%rcx)
movq -0x18(%rax), %rax
movl 0x18(%r12,%rax), %ecx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl %edx, %ecx
orl $0x4, %ecx
movl %ecx, 0x18(%r12,%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
movq %r12, %rdi
callq 0x2220
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2180
jmp 0x2cf7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/skaringa[P]DistanceCalculation/./SimpleDistanceCalculator.h
// Function: SimpleDistanceCalculator::distance(Point const&, Point const&) const
virtual double distance(const Point & from, const Point & to) const {
		double lat1 = (from.lat() + to.lat()) / 2 * DEG_TO_RAD;
		double dx = 111.3 * cos(lat1) * (from.lon() - to.lon());
		double dy = 111.3 * (from.lat() - to.lat());
		return sqrt(dx * dx + dy * dy);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
addsd 0x8(%rsp), %xmm0
mulsd 0x1223(%rip), %xmm0     # 0x4100
mulsd 0x1223(%rip), %xmm0     # 0x4108
callq 0x2250
mulsd 0x1206(%rip), %xmm0     # 0x40f8
movsd %xmm0, 0x10(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x10(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x11a8(%rip), %xmm1     # 0x40f8
mulsd %xmm1, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/skaringa[P]DistanceCalculation/./SphereDistanceCalculator.h
// Function: SphereDistanceCalculator::distance(Point const&, Point const&) const
virtual double distance(const Point & from, const Point & to) const {
		double lat1 = from.lat() * DEG_TO_RAD;
		double lon1 = from.lon() * DEG_TO_RAD;
		double lat2 = to.lat() * DEG_TO_RAD;
		double lon2 = to.lon() * DEG_TO_RAD;
		return 6378.388 * acos(sin(lat1) * sin(lat2) 
			+ cos(lat1) * cos(lat2) * cos(lon2 - lon1));
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
mulsd 0x1174(%rip), %xmm0     # 0x4108
movsd %xmm0, (%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
mulsd 0x115e(%rip), %xmm0     # 0x4108
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
mulsd 0x1147(%rip), %xmm0     # 0x4108
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
mulsd 0x1130(%rip), %xmm0     # 0x4108
subsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd (%rsp), %xmm0
callq 0x2050
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2050
movsd %xmm0, 0x18(%rsp)
movsd (%rsp), %xmm0
callq 0x2250
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2250
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x2250
mulsd (%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm0
callq 0x2170
mulsd 0x10ba(%rip), %xmm0     # 0x4110
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/skaringa[P]DistanceCalculation/./SphereDistanceHaversineCalculator.h
// Function: SphereDistanceHaversineCalculator::distance(Point const&, Point const&) const
virtual double distance(const Point & from, const Point & to) const {

		double lat1 = from.lat() * DEG_TO_RAD;
		double lon1 = from.lon() * DEG_TO_RAD;
		double lat2 = to.lat() * DEG_TO_RAD;
		double lon2 = to.lon() * DEG_TO_RAD;
        double dLat = lat2-lat1;
        double dLon = lon2-lon1;
        double a = pow(sin(dLat/2.0), 2) +
            pow(sin(dLon/2.0), 2) * cos(lat1) * cos(lat2); 
        double c = 2.0 * atan2(sqrt(a),sqrt(1.0-a));
        
		return 6378.388 * c;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
mulsd 0x1084(%rip), %xmm0     # 0x4108
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
mulsd 0x106d(%rip), %xmm0     # 0x4108
movsd %xmm0, 0x18(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
mulsd 0x1056(%rip), %xmm0     # 0x4108
movsd %xmm0, 0x20(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
mulsd 0x103f(%rip), %xmm0     # 0x4108
subsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
mulsd 0x1017(%rip), %xmm0     # 0x4100
callq 0x2050
mulsd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0xffa(%rip), %xmm0      # 0x4100
callq 0x2050
mulsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2250
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x2250
movapd %xmm0, %xmm1
mulsd 0x8(%rsp), %xmm1
addsd 0x18(%rsp), %xmm1
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm1
jb 0x3157
sqrtsd %xmm1, %xmm2
jmp 0x3174
movapd %xmm1, %xmm0
movsd %xmm1, 0x8(%rsp)
callq 0x2120
xorpd %xmm3, %xmm3
movsd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0xf9c(%rip), %xmm0      # 0x4118
subsd %xmm1, %xmm0
ucomisd %xmm3, %xmm0
jb 0x318c
sqrtsd %xmm0, %xmm1
jmp 0x31a1
movsd %xmm2, 0x8(%rsp)
callq 0x2120
movsd 0x8(%rsp), %xmm2
movapd %xmm0, %xmm1
movapd %xmm2, %xmm0
callq 0x2040
addsd %xmm0, %xmm0
mulsd 0xf5a(%rip), %xmm0      # 0x4110
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./util/config.h
// Function: Hash<char [32]>* getInstance<char [32]>(int)
Hash<Key_t>* getInstance(const int index_type){
    const size_t initialTableSize = 1024*16;
    if(index_type == TYPE_EXTENDIBLE_HASH)
	return new ExtendibleHash<Key_t>(initialTableSize/Segment<Key_t>::kNumSlot);
    else if(index_type == TYPE_LINEAR_HASH)
	return new LinearProbingHash<Key_t>(initialTableSize);
    else if(index_type == TYPE_CUCKOO_HASH)
	return new CuckooHash<Key_t>(initialTableSize);
    else
	fprintf(stderr, "unkown index type %d\n", index_type);
    return nullptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
je 0x7334
movl %edi, %edx
cmpl $0x1, %edi
je 0x7350
testl %edx, %edx
jne 0x7373
pushq $0x10
popq %r14
movq %r14, %rdi
callq 0x21e0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x74f8
jmp 0x7368
movl $0xe0, %edi
callq 0x21e0
movq %rax, %rbx
movl $0x4000, %esi           # imm = 0x4000
movq %rax, %rdi
callq 0x76ba
jmp 0x7368
pushq $0x50
popq %rdi
callq 0x21e0
movq %rax, %rbx
movl $0x4000, %esi           # imm = 0x4000
movq %rax, %rdi
callq 0x75d4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xcc4e(%rip), %rax      # 0x13fc8
movq (%rax), %rdi
leaq 0x500a(%rip), %rsi      # 0xc38e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2270
jmp 0x7368
movq %rax, %r14
pushq $0x50
jmp 0x73a5
movq %rax, %r14
movl $0xe0, %esi
jmp 0x73a6
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x21f0
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./util/pair.h
// Function: void gen_input<char [32]>(Pair<char [32]>*, int)
void gen_input(Pair<Key_t>* arr, int num){
    if constexpr(sizeof(Key_t) > 8){
	char s[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
	for(int i=0; i<num; i++){
	    int j;
	    for(j=0; j<sizeof(Key_t)-1; j++)
		arr[i].key[j] = s[rand() % sizeof(s)-1];
	    arr[i].key[j] = 0;
	    arr[i].value = i+1;
	}
    }
    else{
	for(int i=0; i<num; i++){
	    arr[i].key = i+1;
	    arr[i].value = i+1;
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %esi
movq %rsi, 0x10(%rsp)
pushq $0x35
popq %r12
leaq 0x5133(%rip), %r13      # 0xc510
movq %rdi, 0x8(%rsp)
movq %rdi, %rbp
cmpq 0x10(%rsp), %r15
je 0x7429
imulq $0x28, %r15, %r14
addq 0x8(%rsp), %r14
xorl %ebx, %ebx
cmpq $0x1f, %rbx
je 0x7417
callq 0x2050
cltq
xorl %edx, %edx
divq %r12
movb -0x1(%rdx,%r13), %al
movb %al, (%rbp,%rbx)
incq %rbx
jmp 0x73f7
movb $0x0, 0x1f(%r14)
incq %r15
movq %r15, 0x20(%r14)
addq $0x28, %rbp
jmp 0x73e5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/linear_probing.h
// Function: LinearProbingHash<char [32]>::LinearProbingHash(unsigned long)
LinearProbingHash(size_t _capacity): capacity{_capacity}, dict{new Pair<Key_t>[capacity]} {
	locksize = 256;
	nlocks = capacity / locksize + 1;
	mutex = new shared_mutex[nlocks];
	invalid_initialize<Key_t>();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc686(%rip), %rax      # 0x13c70
movq %rax, (%rdi)
movsd 0x4a4b(%rip), %xmm0     # 0xc040
movsd %xmm0, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
pushq $0x28
popq %rcx
movq %rsi, %rax
mulq %rcx
pushq $-0x1
popq %r15
cmovoq %r15, %rax
movq %rax, %rdi
callq 0x2030
testq %r14, %r14
je 0x7637
imulq $0x28, %r14, %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%rdx)
movups %xmm0, (%rax,%rdx)
addq $0x28, %rdx
cmpq %rdx, %rcx
jne 0x7625
movq %rax, 0x18(%rbx)
andq $0x0, 0x30(%rbx)
andl $0x0, 0x38(%rbx)
movl $0x100, 0x4c(%rbx)      # imm = 0x100
shrq $0x8, %r14
leal 0x1(%r14), %ecx
movslq %ecx, %r12
pushq $0x38
popq %r13
movq %r12, %rax
mulq %r13
movl %ecx, 0x48(%rbx)
cmovnoq %rax, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r15
incl %r14d
je 0x769b
imulq $0x38, %r12, %rcx
addq $-0x38, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r13
subq %rdx, %rcx
addq $0x38, %rcx
movq %r15, %rdi
xorl %esi, %esi
movq %rcx, %rdx
callq 0x20e0
movq %r15, 0x40(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0xcc47(%rip)     # 0x142f0
movaps %xmm0, 0xcc30(%rip)     # 0x142e0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/cuckoo_hash.h
// Function: CuckooHash<char [32]>::CuckooHash(unsigned long)
CuckooHash(size_t _capacity): capacity{_capacity}, table{new Pair<Key_t>[capacity]} {
        memset(&pushed, 0, sizeof(Pair<Key_t>)*2);
        locksize = 256;
        nlocks = capacity / locksize + 1;
        mutex = new std::shared_mutex[nlocks];
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc600(%rip), %rax      # 0x13cd0
movq %rax, (%rdi)
movl $0xc70f6907, %eax       # imm = 0xC70F6907
movq %rax, 0x8(%rdi)
movq $0x200, 0x10(%rdi)      # imm = 0x200
movq $0x2, 0x18(%rdi)
movl $0x3f99999a, 0x20(%rdi) # imm = 0x3F99999A
movq $0x80, 0x28(%rdi)
movq %rsi, 0x30(%rdi)
pushq $0x28
popq %rcx
movq %rsi, %rax
mulq %rcx
pushq $-0x1
popq %r15
cmovoq %r15, %rax
movq %rax, %rdi
callq 0x2030
testq %r14, %r14
je 0x7738
imulq $0x28, %r14, %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%rdx)
movups %xmm0, (%rax,%rdx)
addq $0x28, %rdx
cmpq %rdx, %rcx
jne 0x7726
movq %rax, 0x38(%rbx)
andl $0x0, 0xc8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
movl $0x100, 0xdc(%rbx)      # imm = 0x100
shrq $0x8, %r14
leal 0x1(%r14), %ecx
movslq %ecx, %r12
pushq $0x38
popq %r13
movq %r12, %rax
mulq %r13
movl %ecx, 0xd8(%rbx)
cmovnoq %rax, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r15
incl %r14d
je 0x77c8
imulq $0x38, %r12, %rcx
addq $-0x38, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r13
subq %rdx, %rcx
addq $0x38, %rcx
movq %r15, %rdi
xorl %esi, %esi
movq %rcx, %rdx
callq 0x20e0
movq %r15, 0xd0(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/extendible_hash.h
// Function: ExtendibleHash<char [32]>::Capacity()
size_t ExtendibleHash<Key_t>::Capacity(void) {
    size_t cnt = 0;
    for(int i=0; i<dir->capacity; cnt++){
	auto target = dir->_[i];
	auto stride = pow(2, dir->depth - target->local_depth);
	i += stride;
    }
    return cnt * Segment<Key_t>::kNumSlot;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %eax, %eax
movslq %eax, %r15
movq 0x8(%r14), %rax
cmpq %r15, 0x10(%rax)
jbe 0x8143
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq (%rcx,%r15,8), %rcx
subq 0xa000(%rcx), %rax
movq %rax, %xmm1
punpckldq 0x3efc(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3f04(%rip), %xmm1     # 0xc020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x2190
cvtsi2sd %r15d, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
addq $0x400, %rbx            # imm = 0x400
jmp 0x80e8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/extendible_hash.h
// Function: Directory<char [32]>::suspend()
bool suspend(void){
	int64_t val;
	do{
	    val = sema;
	    if(val < 0) return false;
	}while(!CAS(&sema, &val, -1));

	int64_t wait = 0 - val - 1;
	while(val && sema != wait){
	    asm("nop");
	}
	return true;
    }

// Assembly:
pushq $-0x1
popq %rdx
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
js 0x82b5
movq %rcx, %rax
lock
cmpxchgq %rdx, 0x8(%rdi)
jne 0x828f
testq %rax, %rax
je 0x82b5
xorq 0x8(%rdi), %rax
cmpq $-0x1, %rax
je 0x82b5
nop
jmp 0x82ac
testq %rcx, %rcx
setns %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./util/hash.h
// Function: jenkins(void const*, unsigned long, unsigned long)
inline size_t jenkins(const void* _ptr, size_t _len, size_t _seed=0xc70f6907UL){
  size_t i = 0;
  size_t hash = 0;
  const char* key = static_cast<const char*>(_ptr);
  while (i != _len) {
    hash += key[i++];
    hash += hash << (10);
    hash ^= hash >> (6);
  }
  hash += hash << (3);
  hash ^= hash >> (11);
  hash += hash << (15);
  return hash;
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x8388
movsbq (%rdi,%rcx), %rdx
incq %rcx
addq %rdx, %rax
imulq $0x401, %rax, %rdx      # imm = 0x401
movq %rdx, %rax
shrq $0x6, %rax
xorq %rdx, %rax
jmp 0x8365
leaq (%rax,%rax,8), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
imulq $0x8001, %rcx, %rax     # imm = 0x8001
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/extendible_hash.h
// Function: Segment<char [32]>::Insert4split(char (&) [32], long, unsigned long)
bool Segment<Key_t>::Insert4split(Key_t& key, Value_t value, size_t loc) {
    for (unsigned i = 0; i < kNumPairPerCacheLine * kNumCacheLine; ++i) {
	auto slot = (loc+i) % kNumSlot;
	if constexpr(sizeof(Key_t) > 8){
	    if(memcmp(_[slot].key, INVALID<Key_t>, sizeof(Key_t)) == 0){
		memcpy(_[slot].key, key, sizeof(Key_t));
		memcpy(&_[slot].value, &value, sizeof(Value_t));
		return true;
	    }
	}
	else{
	    if(memcmp(&_[slot].key, &INVALID<Key_t>, sizeof(Key_t)) == 0){
		memcpy(&_[slot].key, &key, sizeof(Key_t));
		memcpy(&_[slot].value, &value, sizeof(Value_t));
		return true;
	    }
	}
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r12
xorl %ecx, %ecx
leaq 0xbf0d(%rip), %r13      # 0x142e0
pushq $0x20
popq %rbp
movq %rcx, %r14
cmpq $0x400, %rcx            # imm = 0x400
je 0x8424
leal (%r15,%r14), %eax
andl $0x3ff, %eax            # imm = 0x3FF
imulq $0x28, %rax, %rbx
addq %r12, %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x2200
leaq 0x1(%r14), %rcx
testl %eax, %eax
jne 0x83d6
movq 0x8(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rbx)
cmpq $0x400, %r14            # imm = 0x400
setb %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/linear_probing.h
// Function: LinearProbingHash<char [32]>::Update(char (&) [32], long)
bool LinearProbingHash<Key_t>::Update(Key_t& key, Value_t value){
    uint64_t key_hash;
    if constexpr(sizeof(Key_t) > 8)
	key_hash = h(key, sizeof(Key_t));
    else
	key_hash = h(&key, sizeof(Key_t));

RETRY:
    while(resizing_lock){
	asm("nop");
    }
    for(int i=0; i<capacity; i++){
	auto loc = (key_hash + i) % capacity;
	unique_lock<shared_mutex> lock(mutex[loc/locksize]);
	if constexpr(sizeof(Key_t) > 8){
	    if(memcmp(dict[loc].key, key, sizeof(Key_t)) == 0){
		memcpy(&dict[loc].value, &value, sizeof(Value_t));
		return true;
	    }
	}
	else{
	    if(memcmp(&dict[loc].key, &key, sizeof(Key_t)) == 0){
		memcpy(&dict[loc].value, &value, sizeof(Value_t));
		return true;
	    }
	}
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %rax
movq %rdi, %r15
pushq $0x20
popq %rsi
movl $0xc70697, %edx         # imm = 0xC70697
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x2040
movq %rax, %r12
cmpl $0x0, 0x38(%r15)
je 0x86f9
nop
jmp 0x86ef
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
movq 0x10(%r15), %r14
cmpq %rbp, %r14
jbe 0x876d
leaq (%r12,%rbp), %rax
xorl %edx, %edx
divq %r14
movq %rdx, %rbx
movslq 0x4c(%r15), %rcx
movq %rdx, %rax
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %rsi
addq 0x40(%r15), %rsi
movq %r13, %rdi
callq 0x8a0c
imulq $0x28, %rbx, %rbx
addq 0x18(%r15), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
pushq $0x20
popq %rdx
callq 0x2200
testl %eax, %eax
je 0x875a
movq %r13, %rdi
callq 0x8a22
incq %rbp
jmp 0x8700
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rbx)
leaq 0x18(%rsp), %rdi
callq 0x8a22
cmpq %rbp, %r14
seta %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/linear_probing.h
// Function: LinearProbingHash<char [32]>::Delete(char (&) [32])
bool LinearProbingHash<Key_t>::Delete(Key_t& key){
    uint64_t key_hash;
    if constexpr(sizeof(Key_t) > 8)
	key_hash = h(key, sizeof(Key_t));
    else
	key_hash = h(&key, sizeof(Key_t));

RETRY:
    while(resizing_lock){
	asm("nop");
    }
    for(int i=0; i<capacity; i++){
	auto loc = (key_hash + i) % capacity;
	unique_lock<shared_mutex> lock(mutex[loc/locksize]);
	if constexpr(sizeof(Key_t) > 8){
	    if(memcmp(dict[loc].key, key, sizeof(Key_t)) == 0){
		memcpy(dict[loc].key, INVALID<Key_t>, sizeof(Key_t));
		return true;
	    }
	}
	else{
	    if(memcmp(&dict[loc].key, &key, sizeof(Key_t)) == 0){
		memcpy(&dict[loc].key, &INVALID<Key_t>, sizeof(Key_t));
		return true;
	    }
	}
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %r14
pushq $0x20
popq %rsi
movl $0xc70697, %edx         # imm = 0xC70697
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x2040
movq %rax, %r15
cmpl $0x0, 0x38(%r14)
je 0x87b7
nop
jmp 0x87ad
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq 0x10(%r14), %rbx
cmpq %r13, %rbx
jbe 0x8838
leaq (%r15,%r13), %rax
xorl %edx, %edx
divq %rbx
movq %rdx, %rbp
movslq 0x4c(%r14), %rcx
movq %rdx, %rax
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %rsi
addq 0x40(%r14), %rsi
movq %r12, %rdi
callq 0x8a0c
imulq $0x28, %rbp, %rbp
addq 0x18(%r14), %rbp
movq %rbp, %rdi
movq (%rsp), %rsi
pushq $0x20
popq %rdx
callq 0x2200
testl %eax, %eax
je 0x8818
movq %r12, %rdi
callq 0x8a22
incq %r13
jmp 0x87bf
movaps 0xbad1(%rip), %xmm0     # 0x142f0
movups %xmm0, 0x10(%rbp)
movaps 0xbab6(%rip), %xmm0     # 0x142e0
movups %xmm0, (%rbp)
leaq 0x8(%rsp), %rdi
callq 0x8a22
cmpq %r13, %rbx
seta %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/linear_probing.h
// Function: LinearProbingHash<char [32]>::Get(char (&) [32])
char* LinearProbingHash<Key_t>::Get(Key_t& key){
    uint64_t key_hash;
    if constexpr(sizeof(Key_t) > 8)
	key_hash = h(key, sizeof(Key_t));
    else
	key_hash = h(&key, sizeof(Key_t));

RETRY:
    while(resizing_lock){
	asm("nop");
    }
    for(int i=0; i<capacity; i++){
	auto loc = (key_hash + i) % capacity;
	shared_lock<shared_mutex> lock(mutex[loc/locksize]);
	if constexpr(sizeof(Key_t) > 8){
	    if(memcmp(dict[loc].key, key, sizeof(Key_t)) == 0){
		return (char*)dict[loc].value;
	    }
	}
	else{
	    if(memcmp(&dict[loc].key, &key, sizeof(Key_t)) == 0){
		return (char*)dict[loc].value;
	    }
	}
    }
    return (char*)NONE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %rsi
movl $0xc70697, %edx         # imm = 0xC70697
movq %rbx, %rdi
callq 0x2040
movq %rax, %r15
cmpl $0x0, 0x38(%r14)
je 0x887f
nop
jmp 0x8875
xorl %ebp, %ebp
movq 0x10(%r14), %rcx
cmpq %rbp, %rcx
jbe 0x88f3
leaq (%r15,%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r12
movslq 0x4c(%r14), %rcx
movq %rdx, %rax
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %rdi
addq 0x40(%r14), %rdi
movq %rdi, 0x8(%rsp)
movb $0x1, 0x10(%rsp)
callq 0x8d68
imulq $0x28, %r12, %r12
addq 0x18(%r14), %r12
movq %r12, %rdi
movq %rbx, %rsi
pushq $0x20
popq %rdx
callq 0x2200
movl %eax, %r13d
testl %eax, %eax
jne 0x88df
movq 0x20(%r12), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x8d58
incq %rbp
testl %r13d, %r13d
jne 0x8881
jmp 0x88fb
movq $0x0, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/linear_probing.h
// Function: LinearProbingHash<char [32]>::Utilization()
double Utilization(void){
	size_t size = 0;
	for(int i=0; i<capacity; i++){
	    if constexpr(sizeof(Key_t) > 8){
		if(memcmp(dict[i].key, INVALID<Key_t>, sizeof(Key_t)) != 0)
		    size++;
	    }
	    else{
		if(memcmp(&dict[i].key, &INVALID<Key_t>, sizeof(Key_t)) != 0)
		    size++;
	    }
	}
	return ((double)size) / ((double)capacity)*100;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r12
movq 0x18(%rdi), %rbx
xorl %r13d, %r13d
leaq 0xb9b5(%rip), %r14      # 0x142e0
pushq $0x20
popq %r15
movq %r12, %rbp
subq $0x1, %rbp
jb 0x8953
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2200
cmpl $0x1, %eax
sbbq $-0x1, %r13
addq $0x28, %rbx
jmp 0x8932
movq %r13, %xmm1
punpckldq 0x36b0(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x36b8(%rip), %xmm1     # 0xc020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cvtsi2sd %r12, %xmm1
divsd %xmm1, %xmm0
mulsd 0x36fb(%rip), %xmm0     # 0xc080
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/linear_probing.h
// Function: LinearProbingHash<char [32]>::FindAnyway(char (&) [32])
void LinearProbingHash<Key_t>::FindAnyway(Key_t& key){
	for(int i=0; i<capacity; i++){
		if constexpr(sizeof(Key_t) > 8){
			if(memcmp(dict[i].key, key, sizeof(Key_t)) == 0){
				//cout << "FOUND: " << dict[i].key << "\t" << key << endl;
				return;
			}
		}
		else{
			if(memcmp(&dict[i].key, &key, sizeof(Key_t)) == 0){
				//cout << "FOUND: " << dict[i].key << "\t" << key << endl;
				return;
			}
		}
	}
	cout << "NOT FOUND for key " << key << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %rdi
incq %r15
pushq $0x20
popq %r14
decq %r15
je 0x89db
leaq 0x28(%rdi), %r12
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2200
movq %r12, %rdi
testl %eax, %eax
jne 0x89b4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xb5de(%rip), %rdi      # 0x13fc0
leaq 0x39f9(%rip), %rsi      # 0xc3e2
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21d0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/linear_probing.h
// Function: LinearProbingHash<char [32]>::getLocation(unsigned long, unsigned long, Pair<char [32]>*)
size_t LinearProbingHash<Key_t>::getLocation(size_t hash_value, size_t _capacity, Pair<Key_t>* _dict){
    size_t cur = hash_value;
    int i = 0;
    if constexpr(sizeof(Key_t) > 8){
	while(memcmp(_dict[cur].key, INVALID<Key_t>, sizeof(Key_t)) != 0){
	    cur = (cur+1) % _capacity;
	    i++;
	    if(!(i < _capacity))
		return -1;
	}
	return cur;
    }
    else{
	while(memcmp(&_dict[cur].key, &INVALID<Key_t>, sizeof(Key_t)) != 0){
	    cur = (cur+1) % _capacity;
	    i++;
	    if(!(i < _capacity))
		return -1;
	}
	return cur;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
leaq 0xb5cf(%rip), %r12      # 0x142e0
pushq $0x20
popq %r13
imulq $0x28, %r15, %rdi
addq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2200
testl %eax, %eax
je 0x8d45
incq %r15
movq %r15, %rax
xorl %edx, %edx
divq %r14
incq %rbp
movq %rdx, %r15
cmpq %r14, %rbp
jb 0x8d15
pushq $-0x1
popq %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/cuckoo_hash.h
// Function: CuckooHash<char [32]>::Update(char (&) [32], long)
bool CuckooHash<Key_t>::Update(Key_t& key, Value_t value) {
    size_t f_hash, s_hash;
    if constexpr(sizeof(Key_t) > 8){
        f_hash = hash_funcs[0](key, sizeof(Key_t), _seed);
        s_hash = hash_funcs[1](key, sizeof(Key_t), _seed);
    }
    else{
        f_hash = hash_funcs[0](&key, sizeof(Key_t), _seed);
        s_hash = hash_funcs[1](&key, sizeof(Key_t), _seed);
    }

RETRY:
    while(resizing_lock){
        asm("nop");
    }

    auto f_idx = f_hash % capacity;
    auto s_idx = s_hash % capacity;

    { // try first hashing
        unique_lock<shared_mutex> lock(mutex[f_idx/locksize]);
        if constexpr(sizeof(Key_t) > 8){
            if(memcmp(table[f_idx].key, key, sizeof(Key_t)) == 0){
		memcpy(&table[f_idx].value, &value, sizeof(Value_t));
                return true;
            }
        }
        else{
            if(memcmp(&table[f_idx].key, &key, sizeof(Key_t)) == 0){
		memcpy(&table[f_idx].value, &value, sizeof(Value_t));
                return true;
            }
        }
    }

    { // try second hashing
        unique_lock<shared_mutex> lock(mutex[s_idx/locksize]);
        if constexpr(sizeof(Key_t) > 8){
            if(memcmp(table[s_idx].key, key, sizeof(Key_t)) == 0){
		memcpy(&table[s_idx].value, &value, sizeof(Value_t));
                return true;
            }
        }
        else{
            if(memcmp(&table[s_idx].key, &key, sizeof(Key_t)) == 0){
		memcpy(&table[s_idx].value, &value, sizeof(Value_t));
                return true;
            }
        }
    }
                                                                           
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdx
pushq $0x20
popq %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x2040
movq %rax, %r13
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x82f2
movq %rax, %r12
cmpl $0x0, 0xc8(%r15)
je 0x93c2
nop
jmp 0x93b5
movq 0x30(%r15), %rbp
movq %r13, %rax
xorl %edx, %edx
divq %rbp
movq %rdx, %r13
movslq 0xdc(%r15), %rcx
movq %rdx, %rax
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %rsi
addq 0xd0(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x8a0c
imulq $0x28, %r13, %r13
addq 0x38(%r15), %r13
pushq $0x20
popq %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x2200
testl %eax, %eax
je 0x9477
movq %r12, %rax
xorl %edx, %edx
divq %rbp
movq %rdx, %r12
leaq 0x8(%rsp), %rdi
callq 0x8a22
movslq 0xdc(%r15), %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %rsi
addq 0xd0(%r15), %rsi
leaq 0x8(%rsp), %rdi
callq 0x8a0c
imulq $0x28, %r12, %r12
addq 0x38(%r15), %r12
pushq $0x20
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2200
testl %eax, %eax
sete %bpl
jne 0x946b
movq %rbx, 0x20(%r12)
leaq 0x8(%rsp), %rdi
callq 0x8a22
jmp 0x9488
movq %rbx, 0x20(%r13)
leaq 0x8(%rsp), %rdi
callq 0x8a22
movb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/cuckoo_hash.h
// Function: CuckooHash<char [32]>::Get(char (&) [32])
char* CuckooHash<Key_t>::Get(Key_t& key) {
  if (resizing_lock) {
    for (unsigned i = 0; i < kNumHash; ++i) {
	    int idx;
	    if constexpr(sizeof(Key_t) > 8)
		    idx = hash_funcs[i](key, sizeof(Key_t), _seed) % old_cap;
	    else
		    idx = hash_funcs[i](&key, sizeof(Key_t), _seed) % old_cap;
      std::shared_lock<std::shared_mutex> lock(mutex[idx/locksize]);
      if constexpr(sizeof(Key_t) > 8){
	      if(memcmp(old_tab[idx].key, key, sizeof(Key_t)) == 0)
		      return (char*)old_tab[idx].value;
      }
      else
	      if(memcmp(&old_tab[idx].key, &key, sizeof(Key_t)) == 0)
		      return (char*)old_tab[idx].value;
      }

  } else {
    for (int i = 0; i < kNumHash; i++) {
	    int idx;
	    if constexpr(sizeof(Key_t) > 8)
		    idx = hash_funcs[i](key, sizeof(Key_t), _seed) % capacity;
	    else
		    idx = hash_funcs[i](&key, sizeof(Key_t), _seed) % capacity;
      std::shared_lock<std::shared_mutex> lock(mutex[idx/locksize]);
      if constexpr(sizeof(Key_t) > 8){
	      if(memcmp(table[idx].key, key, sizeof(Key_t)) == 0)
		      return (char*)table[idx].value;
      }
      else
	      if(memcmp(&table[idx].key, &key, sizeof(Key_t)) == 0)
		      return (char*)table[idx].value;
      }
    }
    return (char*)NONE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0xc8(%rdi)
je 0x9695
pushq $0x20
popq %r12
xorl %r13d, %r13d
movl %r13d, %r13d
cmpq %r13, 0x18(%r14)
jbe 0x972c
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r12, %rsi
leaq 0xa626(%rip), %rax      # 0x13c40
callq *(%rax,%r13,8)
xorl %edx, %edx
divq 0xb8(%r14)
movq %rdx, %r15
movl %r15d, %eax
cltd
idivl 0xdc(%r14)
cltq
imulq $0x38, %rax, %rdi
addq 0xd0(%r14), %rdi
movq %rdi, 0x8(%rsp)
movb $0x1, 0x10(%rsp)
callq 0x8d68
movslq %r15d, %rax
imulq $0x28, %rax, %r15
addq 0xc0(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2200
movl %eax, %ebp
testl %eax, %eax
jne 0x967b
movq 0x20(%r15), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x8d58
incl %r13d
testl %ebp, %ebp
jne 0x95fc
jmp 0x9734
leaq 0xa5a4(%rip), %r13      # 0x13c40
xorl %r12d, %r12d
cmpq %r12, 0x18(%r14)
jbe 0x972c
movq 0x8(%r14), %rdx
movq %rbx, %rdi
pushq $0x20
popq %rbp
movq %rbp, %rsi
callq *(%r13)
xorl %edx, %edx
divq 0x30(%r14)
movq %rdx, %r15
movl %r15d, %eax
cltd
idivl 0xdc(%r14)
cltq
imulq $0x38, %rax, %rdi
addq 0xd0(%r14), %rdi
movq %rdi, 0x8(%rsp)
movb $0x1, 0x10(%rsp)
callq 0x8d68
movslq %r15d, %rax
imulq $0x28, %rax, %r15
addq 0x38(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x2200
movl %eax, %ebp
testl %eax, %eax
jne 0x9711
movq 0x20(%r15), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x8d58
incq %r12
addq $0x8, %r13
testl %ebp, %ebp
jne 0x969f
jmp 0x9734
movq $0x0, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/cuckoo_hash.h
// Function: CuckooHash<char [32]>::Utilization()
double CuckooHash<Key_t>::Utilization(void) {
  size_t n = 0;
  for (int i = 0; i < capacity; i++) {
	  if constexpr(sizeof(Key_t) > 8){
		  if(memcmp(table[i].key, INVALID<Key_t>, sizeof(Key_t)) != 0)
			  n++;
	  }
	  else{
		  if(memcmp(&table[i].key, &INVALID<Key_t>, sizeof(Key_t)) != 0)
			  n++;
	  }
  }
  return ((double)n)/((double)capacity)*100;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %r12
movq 0x38(%rdi), %rbx
xorl %r13d, %r13d
leaq 0xab7b(%rip), %r14      # 0x142e0
pushq $0x20
popq %r15
movq %r12, %rbp
subq $0x1, %rbp
jb 0x978d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2200
cmpl $0x1, %eax
sbbq $-0x1, %r13
addq $0x28, %rbx
jmp 0x976c
movq %r13, %xmm1
punpckldq 0x2876(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x287e(%rip), %xmm1     # 0xc020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cvtsi2sd %r12, %xmm1
divsd %xmm1, %xmm0
mulsd 0x28c1(%rip), %xmm0     # 0xc080
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/cuckoo_hash.h
// Function: CuckooHash<char [32]>::execute_path(std::vector<std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&, char (&) [32], long, bool)
bool CuckooHash<Key_t>::execute_path(vector<pair<size_t,string>>& path, Key_t& key, Value_t value, bool flag) {
  for (int i = path.size()-1; i > 0; --i) {
	  memcpy(table[path[i].first].key, table[path[i-1].first].key, sizeof(Key_t));
	  memcpy(&table[path[i].first].value, &table[path[i-1].first].value,sizeof(Value_t));
	 // memcpy(&table[path[i].first], &table[path[i-1].first], sizeof(Pair<Key_t>));
    //table[path[i].first] = table[path[i-1].first];
  }
  memcpy(table[path[0].first].key, key, sizeof(Key_t));
  memcpy(&table[path[0].first].value, &value, sizeof(Value_t));
  return true;
}

// Assembly:
pushq %rbx
movq %rdx, %r8
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movabsq $0x28, %r9
cqto
idivq %r9
movl %eax, %eax
imulq $0x28, %rax, %rdx
addq $-0x50, %rdx
decq %rax
movq 0x38(%rdi), %r9
testl %eax, %eax
jle 0x9b89
movl %eax, %r10d
andl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
movq (%rsi), %r11
imulq $0x28, %r10, %r10
imulq $0x28, (%r11,%r10), %rbx
imulq $0x28, (%r11,%rdx), %r11
movups (%r9,%r11), %xmm0
movups 0x10(%r9,%r11), %xmm1
movups %xmm1, 0x10(%r9,%rbx)
movups %xmm0, (%r9,%rbx)
movq (%rsi), %r9
imulq $0x28, (%r9,%r10), %r10
imulq $0x28, (%r9,%rdx), %r9
movq 0x38(%rdi), %r11
movq 0x20(%r11,%r9), %r9
movq %r9, 0x20(%r11,%r10)
addq $-0x28, %rdx
jmp 0x9b2c
movq (%rsi), %rax
imulq $0x28, (%rax), %rax
movups (%r8), %xmm0
movups 0x10(%r8), %xmm1
movups %xmm1, 0x10(%r9,%rax)
movups %xmm0, (%r9,%rax)
movq 0x38(%rdi), %rax
movq (%rsi), %rdx
imulq $0x28, (%rdx), %rdx
movq %rcx, 0x20(%rax,%rdx)
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./index/cuckoo_hash.h
// Function: CuckooHash<char [32]>::execute_path(std::vector<std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&, bool)
bool CuckooHash<Key_t>::execute_path(vector<pair<size_t,string>>& path, bool flag) {
  auto i = 0;
  auto j = (i+1)%2;

  for (auto p: path) {
	  memcpy(pushed[j].key, table[p.first].key, sizeof(Key_t));
	  memcpy(&pushed[j].value, &table[p.first].value, sizeof(Value_t));
	  memcpy(table[p.first].key, pushed[i].key, sizeof(Key_t));
	  memcpy(&table[p.first].value, &pushed[i].value, sizeof(Value_t));
	 // memcpy(&pushed[j], &table[p.first], sizeof(Pair<Key_t>));
	  //memcpy(&table[p.first], &pushed[i], sizeof(Pair<Key_t>));
    //pushed[j] = table[p.first];
    //table[p.first] = pushed[i];
    i = (i+1)%2;
    j = (i+1)%2;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rdi), %rbp
xorl %r12d, %r12d
pushq $0x1
popq %r13
cmpq 0x8(%rsp), %r14
je 0xad42
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x9aee
movl %r13d, %eax
imulq $0x28, %rax, %rax
movq 0x38(%rbx), %rcx
imulq $0x28, 0x10(%rsp), %rdx
movups (%rcx,%rdx), %xmm0
movups 0x10(%rcx,%rdx), %xmm1
movups %xmm1, 0x10(%rbp,%rax)
movups %xmm0, (%rbp,%rax)
movq 0x20(%rcx,%rdx), %rsi
movq %rsi, 0x20(%rbp,%rax)
movl %r12d, %eax
imulq $0x28, %rax, %rax
movups (%rbp,%rax), %xmm0
movups 0x10(%rbp,%rax), %xmm1
movups %xmm1, 0x10(%rcx,%rdx)
movups %xmm0, (%rcx,%rdx)
movq 0x38(%rbx), %rcx
imulq $0x28, 0x10(%rsp), %rdx
movq 0x20(%rbp,%rax), %rax
movq %rax, 0x20(%rcx,%rdx)
andl $0x1, %r12d
movl %r12d, %r15d
xorl $0x1, %r15d
leaq 0x18(%rsp), %rdi
callq 0x20a0
addq $0x28, %r14
movl %r12d, %r13d
movl %r15d, %r12d
jmp 0xacaa
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./util/config.h
// Function: void start_threads<char [32], benchmark_t<char [32]>::latency(int, Pair<char [32]>*, int, int)::'lambda'(int, bool)&, bool>(Hash<char [32]>*, unsigned long, benchmark_t<char [32]>::latency(int, Pair<char [32]>*, int, int)::'lambda'(int, bool)&, bool&&)
void start_threads(Hash<Key_t> *hash_p, uint64_t num_threads, Fn &&fn, Args &&...args) {
    std::vector<std::thread> thread_group;

    auto fn2 = [hash_p, &fn](uint64_t thread_id, Args ...args) {
	pin_core(thread_id);
	fn(thread_id, args...);
	return;
    };

    for (uint64_t thread_itr = 0; thread_itr < num_threads; ++thread_itr) {
	thread_group.push_back(std::thread{fn2, thread_itr, std::ref(args...)});
    }

    for (uint64_t thread_itr = 0; thread_itr < num_threads; ++thread_itr) {
	thread_group[thread_itr].join();
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x38(%rsp), %r12
movq %rdi, (%r12)
movq %rdx, 0x8(%r12)
xorl %eax, %eax
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x10(%rsp), %r15
movq %rax, 0x8(%rsp)
cmpq %rbx, %rax
jae 0xae2a
movq %r14, 0x10(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0xae86
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0xaf3c
movq %r13, %rdi
callq 0xaf0c
movq 0x8(%rsp), %rax
incq %rax
jmp 0xadeb
xorl %r14d, %r14d
subq $0x1, %rbx
jb 0xae46
movq 0x20(%rsp), %rdi
addq %r14, %rdi
callq 0x2320
addq $0x8, %r14
jmp 0xae2d
leaq 0x20(%rsp), %rdi
callq 0xaf1a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xae70
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xaf0c
jmp 0xae73
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xaf1a
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O2/chahk0129[P]hash_bench/./util/config.h
// Function: pin_core(unsigned long)
inline void pin_core(size_t tid){
    cpu_set_t cpu_set;
    CPU_ZERO(&cpu_set);

    size_t core_id = tid % MAX_CORE_NUM;
    if(hyperthreading)
	CPU_SET(core_alloc_map_hyper[core_id], &cpu_set);
    else
	CPU_SET(core_alloc_map_numa[core_id], &cpu_set);

    int ret = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set), &cpu_set);
    if(ret != 0){
	fprintf(stderr, "%s returns non-zero\n", __func__);
	exit(1);
    }
    return;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rax
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x70(%rbx)
movaps %xmm0, 0x60(%rbx)
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
pushq $0x38
popq %rcx
xorl %edx, %edx
divq %rcx
leaq 0x1433(%rip), %rax      # 0xc600
leaq 0x150c(%rip), %rcx      # 0xc6e0
cmpb $0x0, 0x8ffd(%rip)      # 0x141d8
cmovneq %rax, %rcx
movl %edx, %eax
movslq (%rcx,%rax,4), %rcx
pushq $0x1
popq %rax
shlq %cl, %rax
shrq $0x6, %rcx
orq %rax, (%rsp,%rcx,8)
callq 0x2180
movl $0x80, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2330
testl %eax, %eax
jne 0xb215
addq $0x80, %rsp
popq %rbx
retq
movq 0x8dac(%rip), %rax      # 0x13fc8
movq (%rax), %rdi
leaq 0x120f(%rip), %rsi      # 0xc435
leaq 0x121d(%rip), %rdx      # 0xc44a
xorl %eax, %eax
callq 0x2270
pushq $0x1
popq %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_pyramid.cpp
// Function: void pyramid<double>()
void pyramid()
{
   typedef exprtk::symbol_table<T> symbol_table_t;
   typedef exprtk::expression<T>   expression_t;
   typedef exprtk::parser<T>       parser_t;

   exprtk::rtl::io::package<T> io_package;

   symbol_table_t symbol_table;

   symbol_table.add_package(io_package);

   const std::string pyramid_program =
      " const var n := 30;                           "
      "                                              "
      " for (var i := 0; i < n; i += 1)              "
      " {                                            "
      "    for (var j := 0; j < n - i - 1; j += 1)   "
      "    {                                         "
      "       print(' ');                            "
      "    };                                        "
      "                                              "
      "    for (var j := 0; j < 2 * i + 1; j += 1)   "
      "    {                                         "
      "       print('*');                            "
      "    };                                        "
      "                                              "
      "    println();                                "
      " }                                            ";

   expression_t expression;
   expression.register_symbol_table(symbol_table);

   parser_t parser;
   parser.compile(pyramid_program,expression);

   expression.value();
}

// Assembly:
pushq %rbx
subq $0xb90, %rsp            # imm = 0xB90
leaq 0x48(%rsp), %rdi
callq 0x1104fa
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x11059e
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0x1122fc
leaq 0x12adcd(%rip), %rsi    # 0x23b101
leaq 0x28(%rsp), %rdi
leaq 0x268(%rsp), %rdx
callq 0x1102c8
leaq 0x8(%rsp), %rdi
callq 0x1105c2
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x110622
leaq 0x118(%rsp), %rdi
pushq $0x7f
popq %rsi
callq 0x11067e
leaq 0x268(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0x11078e
leaq 0x118(%rsp), %rdi
callq 0x110da6
leaq 0x268(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x110dee
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x268(%rsp), %rdi
callq 0x111270
leaq 0x8(%rsp), %rdi
callq 0x1113aa
leaq 0x28(%rsp), %rdi
callq 0x10e5c8
movq %rsp, %rdi
callq 0x1113c0
leaq 0x48(%rsp), %rdi
callq 0x111402
addq $0xb90, %rsp            # imm = 0xB90
popq %rbx
retq
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0x110da6
jmp 0x11042b
jmp 0x110405
movq %rax, %rbx
jmp 0x11042b
movq %rax, %rbx
jmp 0x110435
jmp 0x110411
movq %rax, %rbx
jmp 0x11043f
movq %rax, %rbx
jmp 0x110447
movq %rax, %rbx
leaq 0x268(%rsp), %rdi
callq 0x111270
leaq 0x8(%rsp), %rdi
callq 0x1113aa
leaq 0x28(%rsp), %rdi
callq 0x10e5c8
movq %rsp, %rdi
callq 0x1113c0
leaq 0x48(%rsp), %rdi
callq 0x111402
movq %rbx, %rdi
callq 0x10e310
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/sock.c
// Function: host_ip
int
host_ip(char const *host, int port, IPSTR ip)
{
    dyninit();

    struct addrinfo *aip;
	ADRINFO hint = { AI_NUMERICSERV, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP,
                            /*addrlen*/0, /*addr*/0, /*canonname*/0, /*next*/0 };
    char sport[7];

    if (port > 0) sprintf(sport, "%hu", (uint16_t)port);
    if (getaddrinfo(host, port > 0 ? sport : NULL, &hint, &aip))
        return -1;

    int fail = -!inet_ntop(aip->ai_family,
                           aip->ai_family == AF_INET   
                              ? (void*)&((IN4ADDR*)aip->ai_addr)->sin_addr
                              : (void*)&((IN6ADDR*)aip->ai_addr)->sin6_addr,
                           ip, sizeof(IPSTR));
    freeaddrinfo(aip);
    return fail;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x5ce6
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x400, 0x10(%rsp)      # imm = 0x400
movabsq $0x600000001, %rax      # imm = 0x600000001
movq %rax, 0x18(%rsp)
testl %ebp, %ebp
jle 0x5c83
movzwl %bp, %edx
leaq 0x2f2e(%rip), %rsi      # 0x8ba0
leaq 0x9(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3080
jmp 0x5c86
xorl %r15d, %r15d
leaq 0x10(%rsp), %rdx
movq %rsp, %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x33f0
testl %eax, %eax
je 0x5ca2
pushq $-0x1
popq %rbx
jmp 0x5cd9
movq (%rsp), %rax
movl 0x4(%rax), %edi
xorl %ecx, %ecx
cmpl $0x2, %edi
setne %cl
movq 0x18(%rax), %rax
leaq (%rax,%rcx,4), %rsi
addq $0x4, %rsi
pushq $0x2e
popq %rcx
movq %rbx, %rdx
callq 0x3320
xorl %ebx, %ebx
cmpq $0x1, %rax
sbbl %ebx, %ebx
movq (%rsp), %rdi
callq 0x3400
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq