LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x14(%rbp), %rax
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1cb21
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rax
subq 0xa000(%rax), %rsi
movl $0x2, %edi
callq 0x1cb40
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
cvtsi2sdl -0x14(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1cab3
movq -0x10(%rbp), %rax
shlq $0xa, %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x1ceec
movb $0x0, -0x1(%rbp)
jmp 0x1cf6e
jmp 0x1ceee
movq -0x38(%rbp), %rcx
movq $-0x1, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
lock
cmpxchgq %rdx, 0x8(%rcx)
movq %rax, %rcx
sete %al
movb %al, -0x41(%rbp)
movq %rcx, -0x40(%rbp)
testb $0x1, %al
jne 0x1cf21
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ced0
xorl %eax, %eax
subq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x42(%rbp)
je 0x1cf5e
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x30(%rbp), %rax
setne %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x1cf67
jmp 0x1cf6a
nop
jmp 0x1cf40
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: chahk0129[P]hash_bench/./index/extendible_hash.h
// Function: Directory<char [32]>::lock()
bool lock(void){
	int64_t val = sema;
	while(val > -1){
	    if(CAS(&sema, &val, val+1)) return true;
	    val = sema;
	}
	return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jle 0x1cff7
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
incq %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
lock
cmpxchgq %rdx, 0x8(%rcx)
movq %rax, %rcx
sete %al
movb %al, -0x39(%rbp)
movq %rcx, -0x38(%rbp)
testb $0x1, %al
jne 0x1cfd5
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x1cfe9
movb $0x1, -0x1(%rbp)
jmp 0x1cffb
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1cf98
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chahk0129[P]hash_bench/./util/hash.h
// Function: murmur2(void const*, unsigned long, unsigned long)
inline size_t murmur2 ( const void * key, size_t len, size_t seed=0xc70f6907UL)
{
	// 'm' and 'r' are mixing constants generated offline.
	// They're not really 'magic', they just happen to work well.

	const unsigned int m = 0x5bd1e995;
	const int r = 24;

	// Initialize the hash to a 'random' value

	unsigned int h = seed ^ len;

	// Mix 4 bytes at a time into the hash

	const unsigned char * data = (const unsigned char *)key;

	while(len >= 4)
	{
		unsigned int k = *(unsigned int *)data;

		k *= m;
		k ^= k >> r;
		k *= m;
		
		h *= m;
		h ^= k;

		data += 4;
		len -= 4;
	}
	
	// Handle the last few bytes of the input array

	switch(len)
	{
	case 3: h ^= data[2] << 16;
	case 2: h ^= data[1] << 8;
	case 1: h ^= data[0];
	        h *= m;
	};

	// Do a few final mixes of the hash to ensure the last few
	// bytes are well-incorporated.

	h ^= h >> 13;
	h *= m;
	h ^= h >> 15;

	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x5bd1e995, -0x1c(%rbp) # imm = 0x5BD1E995
movl $0x18, -0x20(%rbp)
movq -0x18(%rbp), %rax
xorq -0x10(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x4, -0x10(%rbp)
jb 0x1d14e
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
imull $0x5bd1e995, -0x34(%rbp), %eax # imm = 0x5BD1E995
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
shrl $0x18, %eax
xorl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
imull $0x5bd1e995, -0x34(%rbp), %eax # imm = 0x5BD1E995
movl %eax, -0x34(%rbp)
imull $0x5bd1e995, -0x24(%rbp), %eax # imm = 0x5BD1E995
movl %eax, -0x24(%rbp)
movl -0x34(%rbp), %eax
xorl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x1d0f1
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
subq $0x1, %rax
je 0x1d198
jmp 0x1d15e
movq -0x40(%rbp), %rax
subq $0x2, %rax
je 0x1d187
jmp 0x1d16a
movq -0x40(%rbp), %rax
subq $0x3, %rax
jne 0x1d1af
jmp 0x1d176
movq -0x30(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
xorl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
xorl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
xorl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
imull $0x5bd1e995, -0x24(%rbp), %eax # imm = 0x5BD1E995
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shrl $0xd, %eax
xorl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
imull $0x5bd1e995, -0x24(%rbp), %eax # imm = 0x5BD1E995
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shrl $0xf, %eax
xorl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x1d254
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movsbq (%rax,%rcx), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq $0xa, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq $0x6, %rax
xorq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x1d208
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq $0xb, %rax
xorq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq $0xf, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpq $0x400, %rax            # imm = 0x400
jae 0x1d3b3
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
addq %rcx, %rax
andq $0x3ff, %rax            # imm = 0x3FF
movq %rax, -0x38(%rbp)
imulq $0x28, -0x38(%rbp), %rax
addq %rax, %rdi
leaq 0x3d953(%rip), %rsi     # 0x5aca0
movl $0x20, %edx
callq 0x6190
cmpl $0x0, %eax
jne 0x1d3a3
movq -0x40(%rbp), %rax
imulq $0x28, -0x38(%rbp), %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq -0x18(%rbp), %rdx
movq (%rdx), %rsi
movq %rsi, (%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rcx)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rcx)
imulq $0x28, -0x38(%rbp), %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1d3b7
jmp 0x1d3a5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d317
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movl $0x20, %esi
movl $0xc70697, %edx         # imm = 0xC70697
callq 0x1dd60
movq %rax, -0x28(%rbp)
jmp 0x1d885
movq -0x58(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x1d892
nop
jmp 0x1d885
movl $0x0, -0x2c(%rbp)
movq -0x58(%rbp), %rcx
movslq -0x2c(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1d958
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rdx
addq %rdx, %rax
xorl %edx, %edx
divq 0x10(%rcx)
movq %rdx, -0x38(%rbp)
movq 0x40(%rcx), %rsi
movq -0x38(%rbp), %rax
movslq 0x4c(%rcx), %rcx
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %rax
addq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x1dd90
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rdi
imulq $0x28, -0x38(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0x20, %edx
callq 0x6190
cmpl $0x0, %eax
jne 0x1d92d
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x28, -0x38(%rbp), %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0x1d934
movl $0x0, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1ddd0
movl -0x4c(%rbp), %eax
testl %eax, %eax
je 0x1d948
jmp 0x1d946
jmp 0x1d95c
jmp 0x1d94a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d899
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movl $0x20, %esi
movl $0xc70697, %edx         # imm = 0xC70697
callq 0x1dd60
movq %rax, -0x20(%rbp)
jmp 0x1d9a1
movq -0x50(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x1d9ae
nop
jmp 0x1d9a1
movl $0x0, -0x24(%rbp)
movq -0x50(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1da97
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rdx
addq %rdx, %rax
xorl %edx, %edx
divq 0x10(%rcx)
movq %rdx, -0x30(%rbp)
movq 0x40(%rcx), %rsi
movq -0x30(%rbp), %rax
movslq 0x4c(%rcx), %rcx
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1dd90
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
imulq $0x28, -0x30(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0x20, %edx
callq 0x6190
cmpl $0x0, %eax
jne 0x1da6c
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x28, -0x30(%rbp), %rcx
addq %rcx, %rax
movq 0x3d265(%rip), %rcx     # 0x5aca0
movq %rcx, (%rax)
movq 0x3d263(%rip), %rcx     # 0x5aca8
movq %rcx, 0x8(%rax)
movq 0x3d260(%rip), %rcx     # 0x5acb0
movq %rcx, 0x10(%rax)
movq 0x3d25d(%rip), %rcx     # 0x5acb8
movq %rcx, 0x18(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x1da73
movl $0x0, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1ddd0
movl -0x44(%rbp), %eax
testl %eax, %eax
je 0x1da87
jmp 0x1da85
jmp 0x1da9b
jmp 0x1da89
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1d9b5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movl $0x20, %esi
movl $0xc70697, %edx         # imm = 0xC70697
callq 0x1dd60
movq %rax, -0x20(%rbp)
jmp 0x1dae1
movq -0x50(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x1daee
nop
jmp 0x1dae1
movl $0x0, -0x24(%rbp)
movq -0x50(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1dbb0
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rdx
addq %rdx, %rax
xorl %edx, %edx
divq 0x10(%rcx)
movq %rdx, -0x30(%rbp)
movq 0x40(%rcx), %rsi
movq -0x30(%rbp), %rax
movslq 0x4c(%rcx), %rcx
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1e3b0
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
imulq $0x28, -0x30(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0x20, %edx
callq 0x6190
cmpl $0x0, %eax
jne 0x1db85
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x28, -0x30(%rbp), %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x1db8c
movl $0x0, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1e3e0
movl -0x44(%rbp), %eax
testl %eax, %eax
je 0x1dba0
jmp 0x1db9e
jmp 0x1dbb8
jmp 0x1dba2
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1daf5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1dc43
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
leaq 0x3d085(%rip), %rsi     # 0x5aca0
movl $0x20, %edx
callq 0x6190
cmpl $0x0, %eax
je 0x1dc36
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1dc38
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1dbf3
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %xmm0
movaps 0x243dd(%rip), %xmm3    # 0x42030
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x243e1(%rip), %xmm2    # 0x42040
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x10(%rax), %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 0x2438e(%rip), %xmm1    # 0x42020
mulsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1dd22
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
callq 0x6190
cmpl $0x0, %eax
jne 0x1dd15
jmp 0x1dd50
jmp 0x1dd17
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1dcdf
movq 0x3c28f(%rip), %rdi     # 0x59fb8
leaq 0x2468a(%rip), %rsi     # 0x423ba
callq 0x6400
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6400
movq %rax, %rdi
movq 0x3c255(%rip), %rsi     # 0x59fa0
callq 0x6460
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x28(%rbp), %rdi
imulq $0x28, -0x30(%rbp), %rax
addq %rax, %rdi
leaq 0x3c946(%rip), %rsi     # 0x5aca0
movl $0x20, %edx
callq 0x6190
cmpl $0x0, %eax
je 0x1e39c
movq -0x30(%rbp), %rax
addq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
movq %rdx, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x1e39a
movq $-0x1, -0x8(%rbp)
jmp 0x1e3a4
jmp 0x1e347
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rax
cmpq 0x30(%rcx), %rax
jae 0x1f573
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
leaq 0x3b755(%rip), %rsi     # 0x5aca0
movl $0x20, %edx
callq 0x6190
cmpl $0x0, %eax
je 0x1f566
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1f568
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f523
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %xmm0
movaps 0x22aad(%rip), %xmm3    # 0x42030
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x22ab1(%rip), %xmm2    # 0x42040
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x30(%rax), %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 0x22a5e(%rip), %xmm1    # 0x42020
mulsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1fbd0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1fc00
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1fc30
testb $0x1, %al
jne 0x242cf
jmp 0x243e2
leaq -0x30(%rbp), %rdi
callq 0x1fc70
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x1fc90
movq -0x68(%rbp), %rcx
movq %rcx, %rax
addq $0x40, %rax
movslq -0x1c(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq 0x38(%rcx), %rdx
imulq $0x28, -0x60(%rbp), %rsi
addq %rsi, %rdx
movq (%rdx), %rsi
movq %rsi, (%rax)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rax)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rax)
movq %rcx, %rax
addq $0x40, %rax
movslq -0x1c(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq 0x38(%rcx), %rdx
imulq $0x28, -0x60(%rbp), %rsi
addq %rsi, %rdx
movq 0x20(%rdx), %rdx
movq %rdx, 0x20(%rax)
movq 0x38(%rcx), %rax
imulq $0x28, -0x60(%rbp), %rdx
addq %rdx, %rax
movq %rcx, %rdx
addq $0x40, %rdx
movslq -0x18(%rbp), %rsi
imulq $0x28, %rsi, %rsi
addq %rsi, %rdx
movq (%rdx), %rsi
movq %rsi, (%rax)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rax)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rax)
movq 0x38(%rcx), %rax
imulq $0x28, -0x60(%rbp), %rdx
addq %rdx, %rax
addq $0x40, %rcx
movslq -0x18(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1fd00
leaq -0x30(%rbp), %rdi
callq 0x1fd20
jmp 0x242b9
movb $0x1, %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x24670
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x24605
movq -0x20(%rbp), %rdi
callq 0x246c0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x246f0
jmp 0x245ba
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24690
jmp 0x245c9
leaq -0x58(%rbp), %rdi
callq 0x247c0
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x2458c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x24650
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x247c0
jmp 0x24650
movq $0x0, -0x78(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2463e
movq -0x78(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x247f0
movq %rax, %rdi
callq 0x6720
jmp 0x2462e
jmp 0x24630
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x2460d
leaq -0x38(%rbp), %rdi
callq 0x24810
addq $0x80, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x24810
movq -0x68(%rbp), %rdi
callq 0x6780
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x61f0
movq -0x8(%rbp), %rax
movl $0x38, %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x90(%rbp)
testb $0x1, 0x34bea(%rip)     # 0x5a478
je 0x2590e
movq -0x90(%rbp), %rcx
leaq 0x34c02(%rip), %rax     # 0x5a4a0
movslq (%rax,%rcx,4), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0x258f3
movq -0x98(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x98(%rbp), %rcx
shrq $0x6, %rcx
orq -0x88(%rbp,%rcx,8), %rax
movq %rax, -0x88(%rbp,%rcx,8)
movq %rax, -0xc0(%rbp)
jmp 0x258fe
xorl %eax, %eax
movq %rax, -0xc0(%rbp)
jmp 0x258fe
movq -0xc0(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x2598a
movq -0x90(%rbp), %rcx
leaq 0x34c64(%rip), %rax     # 0x5a580
movslq (%rax,%rcx,4), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0x25971
movq -0xa8(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0xa8(%rbp), %rcx
shrq $0x6, %rcx
orq -0x88(%rbp,%rcx,8), %rax
movq %rax, -0x88(%rbp,%rcx,8)
movq %rax, -0xc8(%rbp)
jmp 0x2597c
xorl %eax, %eax
movq %rax, -0xc8(%rbp)
jmp 0x2597c
movq -0xc8(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x63a0
movq %rax, %rdi
movl $0x80, %esi
leaq -0x88(%rbp), %rdx
callq 0x6770
movl %eax, -0xb4(%rbp)
cmpl $0x0, -0xb4(%rbp)
je 0x259db
movq 0x34607(%rip), %rax     # 0x59fc0
movq (%rax), %rdi
leaq 0x1ca6b(%rip), %rsi     # 0x4242e
leaq 0x1ca79(%rip), %rdx     # 0x42443
movb $0x0, %al
callq 0x65c0
movl $0x1, %edi
callq 0x6500
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x8020
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x31c0
movl $0x400, -0x58(%rbp)     # imm = 0x400
movl $0x1, -0x50(%rbp)
movl $0x6, -0x4c(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x7f4e
leaq -0x5f(%rbp), %rdi
movl -0x14(%rbp), %eax
movzwl %ax, %edx
leaq 0x3c59(%rip), %rsi      # 0xbba0
movb $0x0, %al
callq 0x3090
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x7f66
leaq -0x5f(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x7f6e
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x7f6e
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x33f0
cmpl $0x0, %eax
je 0x7f91
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8009
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x7c(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x7fba
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x4, %rax
movq %rax, -0x88(%rbp)
jmp 0x7fcd
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movl -0x7c(%rbp), %edi
movq -0x88(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x2e, %ecx
callq 0x3320
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x64(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3400
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/sock.c
// Function: dyninit
static void
dyninit(void)
{
    if (sock_cloexec == 1) {    // initial state, ie neither 0 nor SOCK_CLOEXEC
#ifdef WIN32
        WSADATA wsaData;
        WSAStartup(WINSOCK_VERSION, &wsaData);
#endif
       #ifdef SOCK_CLOEXEC
        sock_cloexec = SOCK_CLOEXEC;    // Safely re-enter dyninit from sock_bind
        int fd = sock_bind("", 0);
        if (fd < 0) {
            sock_cloexec = 0;
            cmsg_cloexec = 0;
        } else {
           #if defined(linux) && defined(_GNU_SOURCE)
            // Test whether glibc.accept4 really works:
            IN4ADDR sin;
            socklen_t len = sizeof(sin);
            listen(fd, 1);
            getsockname(fd, (SOADDR*)&sin, &len);
            int con = sock_connect("127.0.0.1", ntohs(sin.sin_port), 1);
            int ret = accept4(fd, NULL, NULL, SOCK_CLOEXEC);
            has_accept4 = ret >= 0 && fcntl(ret, F_GETFD, 0) & FD_CLOEXEC;
            close(ret);
            close(con);
           #endif
            close(fd);
        }
       #else
        sock_cloexec = 0;
       #endif
    }
    errno = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
cmpl $0x1, 0x78a1(%rip)      # 0xf8d0
jne 0x812b
movl $0x80000, 0x7891(%rip)  # imm = 0x80000
leaq 0x3d68(%rip), %rdi      # 0xbdae
xorl %esi, %esi
callq 0x8140
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x806f
movl $0x0, 0x7870(%rip)      # 0xf8d0
movl $0x0, 0x788a(%rip)      # 0xf8f4
jmp 0x8129
movl $0x10, -0x18(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
callq 0x3380
movl -0x4(%rbp), %edi
leaq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x32e0
movzwl -0x12(%rbp), %edi
callq 0x3510
movzwl %ax, %esi
leaq 0x2f5f(%rip), %rdi      # 0xb00d
movl $0x1, %edx
callq 0x87b0
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %edi
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x80000, %ecx          # imm = 0x80000
callq 0x3190
movl %eax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
jl 0x8103
movl -0x28(%rbp), %edi
movl $0x1, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x31e0
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x77df(%rip)      # 0xf8f0
movl -0x28(%rbp), %edi
callq 0x3580
movl -0x24(%rbp), %edi
callq 0x3580
movl -0x4(%rbp), %edi
callq 0x3580
jmp 0x812b
callq 0x3040
movl $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/sock.c
// Function: sock_bind
int
sock_bind(IPSTR const ip, int port)
{
    dyninit();

    INxADDR addr;
    int addrlen = ininit(&addr, ip, port);
    if (addrlen < 0)
        return -1;

    int fd = sockit(addr.inx_family);
    if (fd < 0)
        return -1;
    #ifdef IPV6_V6ONLY
    if (addr.inx_family == AF_INET6) {
        int     no = 0;
        if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &no, sizeof(no)))
            return eclose(fd);
    }
    #endif
    //XXX support bindresvport(), i.e. ask for an arb port in 512..1023?
    return setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&fd, sizeof fd)
            || bind(fd, (SOADDR*)&addr, addrlen)
            || listen(fd, 5)
         ? eclose(fd) : fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x8020
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0x8250
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x8179
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x823f
movzwl -0x30(%rbp), %edi
callq 0x8310
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x8197
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x823f
movzwl -0x30(%rbp), %eax
cmpl $0xa, %eax
jne 0x81d7
movl $0x0, -0x3c(%rbp)
movl -0x38(%rbp), %edi
movl $0x29, %esi
movl $0x1a, %edx
leaq -0x3c(%rbp), %rcx
movl $0x4, %r8d
callq 0x3500
cmpl $0x0, %eax
je 0x81d5
movl -0x38(%rbp), %edi
callq 0x8390
movl %eax, -0x4(%rbp)
jmp 0x823f
jmp 0x81d7
movl -0x38(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x38(%rbp), %rcx
movl $0x4, %r8d
callq 0x3500
cmpl $0x0, %eax
jne 0x8226
movl -0x38(%rbp), %edi
leaq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x34(%rbp), %edx
movq -0x48(%rbp), %rsi
callq 0x3080
cmpl $0x0, %eax
jne 0x8226
movl -0x38(%rbp), %edi
movl $0x5, %esi
callq 0x3380
cmpl $0x0, %eax
je 0x8233
movl -0x38(%rbp), %edi
callq 0x8390
movl %eax, -0x4c(%rbp)
jmp 0x8239
movl -0x38(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/sock.c
// Function: ininit
static int
ininit(INxADDR *xp, IPSTR const ip, int port)
{
   #if defined(__FreeBSD__) || defined(__APPLE__)
       #define SETLEN(x) (int)(xp->in4.sin_len = (x))
   #else
       #define SETLEN(x) (int)(x)
   #endif
    // We rely on INADDR_ANY == 0x00000000
    memset(xp, 0, sizeof(*xp));
    xp->inx_port   = (uint16_t)htons((uint16_t)port);
    xp->inx_family = AF_INET;
    return !ip || !*ip ||
              1 == inet_pton(AF_INET, ip, &xp->in4.sin_addr)
            ? SETLEN(sizeof(IN4ADDR))
            : 1 == inet_pton(xp->inx_family = AF_INET6, ip, &xp->in6.sin6_addr)
            ? SETLEN(sizeof(IN6ADDR))
            : -1;
   #undef SETLEN
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1c, %edx
callq 0x31c0
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x3050
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rax
movw $0x2, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x82c3
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x82c3
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x3550
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x82cd
movl $0x10, %eax
movl %eax, -0x18(%rbp)
jmp 0x8305
movq -0x8(%rbp), %rax
movw $0xa, (%rax)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x8, %rdx
movl $0xa, %edi
callq 0x3550
movl %eax, %esi
movl $0x1, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1c, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/sock.c
// Function: sockit
static int
sockit(int domain)
{
    int fd = socket(domain, SOCK_STREAM | sock_cloexec, 0);
    if (fd < 0) return -1;

#ifdef SO_NOSIGPIPE
    // If the connection breaks. the client finds out because SEND fails (RECV just waits).
    //  On Darwin, by default, writing to a broken connection throws SIGPIPE.
    int on = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, (const void *) &on, sizeof on))
        return eclose(fd);
#endif
    return fd >= 0 && !sock_cloexec && fcntl(fd, F_SETFD, FD_CLOEXEC) ? eclose(fd) : fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl 0x75ac(%rip), %esi      # 0xf8d0
orl $0x1, %esi
xorl %edx, %edx
callq 0x30b0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x8340
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8381
cmpl $0x0, -0xc(%rbp)
jl 0x8375
cmpl $0x0, 0x7583(%rip)      # 0xf8d0
jne 0x8375
movl -0xc(%rbp), %edi
movl $0x2, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x31e0
cmpl $0x0, %eax
je 0x8375
movl -0xc(%rbp), %edi
callq 0x8390
movl %eax, -0x10(%rbp)
jmp 0x837b
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/sock.c
// Function: sock_accept
int
sock_accept(int skt)
{
    dyninit();

    int fd;
    do fd =
           #if 0 && defined(linux) && defined(_GNU_SOURCE)
            has_accept4 ? accept4(skt, NULL, NULL, sock_cloexec) :
           #endif
            accept(skt, NULL, NULL);
    while (fd < 0 && errno == EINTR);

    return fd >= 0 && !has_accept4 && fcntl(fd, F_SETFD, FD_CLOEXEC)
         ? eclose(fd) : fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0x8020
movl -0x4(%rbp), %edi
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x30f0
movl %eax, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
jge 0x8414
callq 0x3040
cmpl $0x4, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x83e0
cmpl $0x0, -0x8(%rbp)
jl 0x8450
cmpl $0x0, 0x74c8(%rip)      # 0xf8f0
jne 0x8450
movl -0x8(%rbp), %edi
movl $0x2, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x31e0
cmpl $0x0, %eax
je 0x8450
movl -0x8(%rbp), %edi
callq 0x8390
movl %eax, -0x18(%rbp)
jmp 0x8456
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/sock.c
// Function: sock_create
int
sock_create(char const *path)
{
    dyninit();

#ifdef WIN32
    //CreateNamedPipe...  http://msdn.microsoft.com/en-us/library/windows/desktop/aa365601%28v=vs.85%29.aspx
    return INVALID_SOCKET;
#else
    UNADDR sun;
    int fd, len = uninit(&sun, path);
    if (!len) return errno = EINVAL, -1;
    if (unlink(path) && errno != ENOENT) return -1;
    if (0 > (fd = sockit(AF_UNIX))) return -1;

    return setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &fd, sizeof fd)
           || bind(fd, (SOADDR*)&sun, sizeof sun.sun_family + len)
           || listen(fd, 5)
         ? eclose(fd) : fd;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
callq 0x8020
movq -0x10(%rbp), %rsi
leaq -0x7e(%rbp), %rdi
callq 0x8590
movl %eax, -0x88(%rbp)
cmpl $0x0, -0x88(%rbp)
jne 0x84a7
callq 0x3040
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8582
movq -0x10(%rbp), %rdi
callq 0x3170
cmpl $0x0, %eax
je 0x84cb
callq 0x3040
cmpl $0x2, (%rax)
je 0x84cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8582
movl $0x1, %edi
callq 0x8310
movl %eax, %ecx
movl %ecx, -0x84(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x84ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8582
movl -0x84(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x84(%rbp), %rcx
movl $0x4, %r8d
callq 0x3500
cmpl $0x0, %eax
jne 0x855a
movl -0x84(%rbp), %edi
leaq -0x7e(%rbp), %rax
movq %rax, -0x90(%rbp)
movslq -0x88(%rbp), %rax
addq $0x2, %rax
movl %eax, %edx
movq -0x90(%rbp), %rsi
callq 0x3080
cmpl $0x0, %eax
jne 0x855a
movl -0x84(%rbp), %edi
movl $0x5, %esi
callq 0x3380
cmpl $0x0, %eax
je 0x856d
movl -0x84(%rbp), %edi
callq 0x8390
movl %eax, -0x94(%rbp)
jmp 0x8579
movl -0x84(%rbp), %eax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/sock.c
// Function: uninit
static int
uninit(UNADDR * uap, char const *path)
{
    int len = strlen(path);
    if (len > (int) sizeof uap->sun_path) return 0;

    memset(uap, 0, sizeof(UNADDR));
   #ifdef __FreeBSD__
    uap->sun_len = len;
   #endif
    uap->sun_family = AF_UNIX;
    memcpy(uap->sun_path, path, len);
    return SUN_LEN(uap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3150
movl %eax, -0x1c(%rbp)
cmpl $0x6c, -0x1c(%rbp)
jle 0x85bb
movl $0x0, -0x4(%rbp)
jmp 0x8605
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x6e, %edx
callq 0x31c0
movq -0x10(%rbp), %rax
movw $0x1, (%rax)
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x3270
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
callq 0x3150
movq %rax, %rcx
xorl %eax, %eax
addq $0x2, %rax
addq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/sock.c
// Function: sock_open
int
sock_open(char const *path)
{
    dyninit();

#ifdef WIN32
    // WaitNamedPipe, CreateFile 
    return INVALID_SOCKET;
#else
    struct stat st;
    UNADDR sun;
    int fd, ret, len = uninit(&sun, path);
    if (!len || stat(path, &st) || !S_ISSOCK(st.st_mode))
        return errno = EINVAL, -1;

    if (0 > (fd = sockit(AF_UNIX))) return -1;

    do errno = 0, ret = connect(fd, (SOADDR*)&sun, SUN_LEN(&sun));
    while (ret < 0 && errno == EINTR);

    return ret < 0 && errno != EAGAIN ? eclose(fd) : fd;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
callq 0x8020
movq -0x10(%rbp), %rsi
leaq -0x10e(%rbp), %rdi
callq 0x8590
movl %eax, -0x11c(%rbp)
cmpl $0x0, -0x11c(%rbp)
je 0x866a
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x32c0
cmpl $0x0, %eax
jne 0x866a
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xc000, %eax           # imm = 0xC000
je 0x8681
callq 0x3040
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x876d
movl $0x1, %edi
callq 0x8310
movl %eax, %ecx
movl %ecx, -0x114(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x86a5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x876d
jmp 0x86a7
callq 0x3040
movl $0x0, (%rax)
movl -0x114(%rbp), %eax
movl %eax, -0x12c(%rbp)
leaq -0x10e(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x10e(%rbp), %rdi
addq $0x2, %rdi
callq 0x3150
movl -0x12c(%rbp), %edi
movq %rax, %rcx
xorl %eax, %eax
addq $0x2, %rax
addq %rcx, %rax
movl %eax, %edx
movq -0x128(%rbp), %rsi
callq 0x3290
movl %eax, -0x118(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x118(%rbp)
movb %al, -0x12d(%rbp)
jge 0x8724
callq 0x3040
cmpl $0x4, (%rax)
sete %al
movb %al, -0x12d(%rbp)
movb -0x12d(%rbp), %al
testb $0x1, %al
jne 0x86a7
cmpl $0x0, -0x118(%rbp)
jge 0x8758
callq 0x3040
cmpl $0xb, (%rax)
je 0x8758
movl -0x114(%rbp), %edi
callq 0x8390
movl %eax, -0x134(%rbp)
jmp 0x8764
movl -0x114(%rbp), %eax
movl %eax, -0x134(%rbp)
movl -0x134(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)