LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %ecx, %eax
andl $0x3ff, %eax            # imm = 0x3FF
leaq (%rax,%rax,4), %rax
movdqu (%rdi,%rax,8), %xmm0
movdqu 0x10(%rdi,%rax,8), %xmm1
pcmpeqb 0xacd6(%rip), %xmm1     # 0x142e0
pcmpeqb 0xacbe(%rip), %xmm0     # 0x142d0
pand %xmm1, %xmm0
pmovmskb %xmm0, %r8d
cmpl $0xffff, %r8d           # imm = 0xFFFF
je 0x9686
incq %rcx
xorl %r9d, %r9d
cmpq $0x3ff, %r9             # imm = 0x3FF
je 0x969f
movq %r9, %rax
leal (%rcx,%r9), %r8d
andl $0x3ff, %r8d            # imm = 0x3FF
leaq (%r8,%r8,4), %r8
movdqu (%rdi,%r8,8), %xmm0
movdqu 0x10(%rdi,%r8,8), %xmm1
pcmpeqb 0xac86(%rip), %xmm1     # 0x142e0
pcmpeqb 0xac6e(%rip), %xmm0     # 0x142d0
pand %xmm1, %xmm0
pmovmskb %xmm0, %r10d
incq %r9
cmpl $0xffff, %r10d          # imm = 0xFFFF
jne 0x962a
leaq (%rdi,%r8,8), %rcx
cmpq $0x3ff, %rax            # imm = 0x3FF
setb %al
jmp 0x968c
leaq (%rdi,%rax,8), %rcx
movb $0x1, %al
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
movq %rdx, 0x20(%rcx)
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %esi
movl $0xc70697, %edx         # imm = 0xC70697
movq %r14, %rdi
callq 0x2050
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x38(%r15)
je 0x996c
nop
jmp 0x9962
movq 0x10(%r15), %rcx
testq %rcx, %rcx
setne %bpl
je 0x9a30
movq %rbx, 0x18(%rsp)
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
movq 0x20(%rsp), %rax
addq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rbx
movslq 0x4c(%r15), %rcx
movq %rdx, %rax
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %rax
addq 0x40(%r15), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %r13, %rdi
callq 0xa0ba
movb $0x1, 0x10(%rsp)
movq 0x18(%r15), %rax
leaq (%rbx,%rbx,4), %rcx
movdqu (%rax,%rcx,8), %xmm0
movdqu 0x10(%rax,%rcx,8), %xmm1
movdqu (%r14), %xmm2
pcmpeqb %xmm0, %xmm2
movdqu 0x10(%r14), %xmm0
pcmpeqb %xmm1, %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %edx
cmpl $0xffff, %edx           # imm = 0xFFFF
je 0x9a19
movq %r13, %rdi
callq 0x9de6
incq %r12
movq 0x10(%r15), %rcx
cmpq %r12, %rcx
seta %bpl
ja 0x998a
jmp 0x9a30
leaq (%rax,%rcx,8), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
leaq 0x8(%rsp), %rdi
callq 0x9de6
andb $0x1, %bpl
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
movl $0x20, %esi
movl $0xc70697, %edx         # imm = 0xC70697
movq %rbx, %rdi
callq 0x2050
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x38(%r14)
je 0x9a7b
nop
jmp 0x9a71
movq 0x10(%r14), %rcx
testq %rcx, %rcx
setne %bpl
je 0x9b48
xorl %r15d, %r15d
movq %rsp, %r12
movq 0x10(%rsp), %rax
addq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r13
movslq 0x4c(%r14), %rcx
movq %rdx, %rax
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %rax
addq 0x40(%r14), %rax
movq %rax, (%rsp)
movb $0x0, 0x8(%rsp)
movq %r12, %rdi
callq 0xa0ba
movb $0x1, 0x8(%rsp)
movq 0x18(%r14), %rax
leaq (,%r13,4), %rcx
addq %r13, %rcx
movdqu (%rax,%rcx,8), %xmm0
movdqu 0x10(%rax,%rcx,8), %xmm1
movdqu (%rbx), %xmm2
pcmpeqb %xmm0, %xmm2
movdqu 0x10(%rbx), %xmm0
pcmpeqb %xmm1, %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %edx
cmpl $0xffff, %edx           # imm = 0xFFFF
je 0x9b25
movq %r12, %rdi
callq 0x9de6
incq %r15
movq 0x10(%r14), %rcx
cmpq %r15, %rcx
seta %bpl
ja 0x9a92
jmp 0x9b48
leaq (%rax,%rcx,8), %rax
movaps 0xa7b0(%rip), %xmm0     # 0x142e0
movups %xmm0, 0x10(%rax)
movdqa 0xa794(%rip), %xmm0     # 0x142d0
movdqu %xmm0, (%rax)
movq %rsp, %rdi
callq 0x9de6
andb $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_O1/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20, %esi
movl $0xc70697, %edx         # imm = 0xC70697
movq %rbx, %rdi
callq 0x2050
movq %rax, %r15
cmpl $0x0, 0x38(%r14)
je 0x9b8e
nop
jmp 0x9b84
movq 0x10(%r14), %rcx
testq %rcx, %rcx
je 0x9c31
xorl %r12d, %r12d
leaq (%r15,%r12), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rbp
movslq 0x4c(%r14), %rcx
movq %rdx, %rax
xorl %edx, %edx
divq %rcx
imulq $0x38, %rax, %r13
addq 0x40(%r14), %r13
movq %r13, %rdi
callq 0xa118
movq 0x18(%r14), %rax
leaq (,%rbp,4), %rcx
addq %rbp, %rcx
movdqu (%rax,%rcx,8), %xmm0
movdqu 0x10(%rax,%rcx,8), %xmm1
movdqu (%rbx), %xmm2
pcmpeqb %xmm0, %xmm2
movdqu 0x10(%rbx), %xmm0
pcmpeqb %xmm1, %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %edx
xorl %ebp, %ebp
cmpl $0xffff, %edx           # imm = 0xFFFF
setne %dl
jne 0x9c12
leaq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
movb %dl, %bpl
movq %r13, %rdi
callq 0x2240
testl %ebp, %ebp
je 0x9c35
incq %r12
movq 0x10(%r14), %rcx
cmpq %r12, %rcx
ja 0x9b9e
xorl %eax, %eax
jmp 0x9c39
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x9cb7
movq 0x18(%rdi), %rdx
xorl %ecx, %ecx
movq %rax, %rsi
movdqu (%rdx), %xmm0
movdqu 0x10(%rdx), %xmm1
pcmpeqb 0xa675(%rip), %xmm1     # 0x142e0
pcmpeqb 0xa65d(%rip), %xmm0     # 0x142d0
pand %xmm1, %xmm0
pmovmskb %xmm0, %edi
xorl %r8d, %r8d
cmpl $0xffff, %edi           # imm = 0xFFFF
setne %r8b
addq %r8, %rcx
addq $0x28, %rdx
decq %rsi
jne 0x9c5a
movq %rcx, %xmm1
punpckldq 0x336f(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3377(%rip), %xmm1     # 0xd020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0x9cbb
xorpd %xmm0, %xmm0
movq %rax, %xmm1
punpckldq 0x3348(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3350(%rip), %xmm1     # 0xd020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
mulsd 0x3390(%rip), %xmm0     # 0xd078
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
setne %dl
je 0x9d87
movq 0x18(%rdi), %rcx
movdqu (%rcx), %xmm0
movdqu 0x10(%rcx), %xmm1
movdqu (%rbx), %xmm2
pcmpeqb %xmm0, %xmm2
movdqu 0x10(%rbx), %xmm0
pcmpeqb %xmm1, %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %esi
cmpl $0xffff, %esi           # imm = 0xFFFF
je 0x9d7b
addq $0x28, %rcx
leaq -0x1(%rax), %rsi
xorl %edx, %edx
cmpq %rdx, %rsi
je 0x9d87
movdqu (%rcx), %xmm0
movdqu 0x10(%rcx), %xmm1
movdqu (%rbx), %xmm2
pcmpeqb %xmm0, %xmm2
movdqu 0x10(%rbx), %xmm0
pcmpeqb %xmm1, %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %edi
addq $0x28, %rcx
incq %rdx
cmpl $0xffff, %edi           # imm = 0xFFFF
jne 0x9d3f
cmpq %rdx, %rax
seta %dl
testb %dl, %dl
je 0x9d87
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xa232(%rip), %r14      # 0x13fc0
leaq 0x3645(%rip), %rsi      # 0xd3da
movl $0x12, %edx
movq %r14, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x20a0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0xaec9
movq 0x38(%rdi), %rdx
xorl %ecx, %ecx
movq %rax, %rsi
movdqu (%rdx), %xmm0
movdqu 0x10(%rdx), %xmm1
pcmpeqb 0x9463(%rip), %xmm1     # 0x142e0
pcmpeqb 0x944b(%rip), %xmm0     # 0x142d0
pand %xmm1, %xmm0
pmovmskb %xmm0, %edi
xorl %r8d, %r8d
cmpl $0xffff, %edi           # imm = 0xFFFF
setne %r8b
addq %r8, %rcx
addq $0x28, %rdx
decq %rsi
jne 0xae6c
movq %rcx, %xmm1
punpckldq 0x215d(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2165(%rip), %xmm1     # 0xd020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0xaecd
xorpd %xmm0, %xmm0
movq %rax, %xmm1
punpckldq 0x2136(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x213e(%rip), %xmm1     # 0xd020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
mulsd 0x217e(%rip), %xmm0     # 0xd078
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq (%rsi), %r12
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rsp)
cmpq %rax, %r12
je 0xc72d
movq 0x10(%rsp), %rax
leaq 0x40(%rax), %r14
movl $0x1, %ebp
xorl %r13d, %r13d
movq (%r12), %rax
movq %rax, 0x20(%rsp)
leaq 0x8(%r12), %r15
leaq 0xf(%rsp), %rdi
movq %r15, %rsi
callq 0x70cc
leaq 0x38(%rsp), %rbx
movq %rbx, 0x28(%rsp)
leaq 0xf(%rsp), %rdi
callq 0xb9aa
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xbbec
movl %ebp, %eax
leaq (%rax,%rax,4), %rax
movq 0x10(%rsp), %rdi
movq 0x38(%rdi), %rcx
movq 0x20(%rsp), %rdx
leaq (%rdx,%rdx,4), %rdx
movups (%rcx,%rdx,8), %xmm0
movups 0x10(%rcx,%rdx,8), %xmm1
movups %xmm1, 0x10(%r14,%rax,8)
movups %xmm0, (%r14,%rax,8)
movq 0x20(%rcx,%rdx,8), %rsi
movq %rsi, 0x20(%r14,%rax,8)
movl %r13d, %eax
leaq (%rax,%rax,4), %rax
movups (%r14,%rax,8), %xmm0
movups 0x10(%r14,%rax,8), %xmm1
movups %xmm1, 0x10(%rcx,%rdx,8)
movups %xmm0, (%rcx,%rdx,8)
movq 0x38(%rdi), %rcx
movq 0x20(%rsp), %rdx
leaq (%rdx,%rdx,4), %rdx
movq 0x20(%r14,%rax,8), %rax
movq %rax, 0x20(%rcx,%rdx,8)
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0xc70e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movl %r13d, %ebp
andl $0x1, %ebp
movl %ebp, %r13d
xorl $0x1, %r13d
addq $0x20, %r15
movq %r15, %r12
cmpq 0x18(%rsp), %r15
jne 0xc649
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %eax, %eax
movq %rax, 0x20(%rsp)
movq %rdi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rax, (%rsp)
testq %rsi, %rsi
je 0xc7c1
movq %rcx, %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r13
leaq 0x30(%rsp), %rbp
leaq 0x10(%rsp), %r12
movq %r14, 0x30(%rsp)
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0xc81c
movq %r12, %rdi
movq %r15, %rsi
callq 0xc8f2
cmpq $0x0, 0x8(%rsp)
jne 0xc802
movq (%rsp), %rax
incq %rax
movq %rax, (%rsp)
cmpq %rbx, %rax
jb 0xc786
testq %rbx, %rbx
je 0xc7df
xorl %r14d, %r14d
movq 0x10(%rsp), %rdi
addq %r14, %rdi
callq 0x2310
addq $0x8, %r14
decq %rbx
jne 0xc7c9
leaq 0x10(%rsp), %rdi
callq 0xc8b6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc807
cmpq $0x0, 0x8(%rsp)
je 0xc807
callq 0x2070
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc8b6
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5d2c
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 0x5cc7
movzwl %bp, %edx
leaq 0x2eea(%rip), %rsi      # 0x8ba0
leaq 0x9(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3080
jmp 0x5cca
xorl %r15d, %r15d
leaq 0x10(%rsp), %rdx
movq %rsp, %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x33e0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x5d1f
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
movq %rbx, %rdx
movl $0x2e, %ecx
callq 0x3310
xorl %ebp, %ebp
cmpq $0x1, %rax
sbbl %ebp, %ebp
movq (%rsp), %rdi
callq 0x33f0
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x1, 0x6b31(%rip)      # 0xc870
jne 0x5e0c
movl $0x80000, 0x6b21(%rip)  # imm = 0x80000
leaq 0x30a8(%rip), %rdi      # 0x8dfe
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x5e24
testl %eax, %eax
js 0x5e02
movl %eax, %ebx
leaq 0xc(%rsp), %r15
movl $0x10, (%r15)
movl %eax, %edi
movl $0x1, %esi
callq 0x3370
leaq 0x10(%rsp), %r12
movl %ebx, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x32d0
movzwl 0x2(%r12), %eax
rolw $0x8, %ax
movzwl %ax, %esi
leaq 0x2265(%rip), %rdi      # 0x800d
movl $0x1, %edx
callq 0x6253
movl %eax, %ebp
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
movl $0x80000, %ecx          # imm = 0x80000
callq 0x3180
movl %eax, %r15d
testl %eax, %eax
js 0x5de3
movl %r15d, %edi
movl $0x1, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x31d0
movl %eax, %r14d
andl $0x1, %r14d
movl %r14d, 0x6aa6(%rip)     # 0xc890
movl %r15d, %edi
callq 0x3550
movl %ebp, %edi
callq 0x3550
movl %ebx, %edi
callq 0x3550
jmp 0x5e0c
movl $0x0, 0x6a64(%rip)      # 0xc870
callq 0x3040
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x5d2c
leaq 0x14(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5eff
testl %eax, %eax
js 0x5ee9
movl %eax, %ebp
movzwl 0x14(%rsp), %edi
callq 0x5f75
movl %eax, 0xc(%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x5eee
cmpw $0xa, 0x14(%rsp)
jne 0x5e98
leaq 0x10(%rsp), %rcx
movl $0x0, (%rcx)
movl %eax, %edi
movl $0x29, %esi
movl $0x1a, %edx
movl $0x4, %r8d
callq 0x34e0
testl %eax, %eax
jne 0x5ede
leaq 0xc(%rsp), %rcx
movl (%rcx), %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x34e0
testl %eax, %eax
jne 0x5ede
movl 0xc(%rsp), %edi
leaq 0x14(%rsp), %rsi
movl %ebp, %edx
callq 0x3070
testl %eax, %eax
jne 0x5ede
movl 0xc(%rsp), %edi
movl $0x5, %esi
callq 0x3370
testl %eax, %eax
je 0x5ef9
movl 0xc(%rsp), %edi
callq 0x5fc7
jmp 0x5eee
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl 0xc(%rsp), %ebx
jmp 0x5eee
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0xc(%rdi)
rolw $0x8, %dx
movw %dx, 0x2(%rdi)
movw $0x2, (%rdi)
movl $0x10, %ebx
testq %rsi, %rsi
je 0x5f6d
movq %rsi, %r15
cmpb $0x0, (%rsi)
je 0x5f6d
movq %rdi, %r14
leaq 0x4(%rdi), %rdx
movl $0x2, %edi
movq %r15, %rsi
callq 0x3520
cmpl $0x1, %eax
je 0x5f6d
movw $0xa, (%r14)
addq $0x8, %r14
movl $0xa, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3520
xorl %ebx, %ebx
cmpl $0x1, %eax
setne %bl
negl %ebx
orl $0x1c, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl 0x68f2(%rip), %esi      # 0xc870
orl $0x1, %esi
xorl %edx, %edx
callq 0x30a0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x5fbe
movl %eax, %ebp
cmpl $0x0, 0x68d6(%rip)      # 0xc870
je 0x5fa0
movl %ebp, %ebx
jmp 0x5fbe
movl %ebp, %edi
movl $0x2, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x31d0
testl %eax, %eax
je 0x5f9c
movl %ebp, %edi
callq 0x5fc7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %edi, %ebp
callq 0x5d2c
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x30e0
movl %eax, %ebx
testl %eax, %eax
jns 0x6011
callq 0x3040
cmpl $0x4, (%rax)
je 0x5ff6
testl %ebx, %ebx
js 0x6041
cmpl $0x0, 0x6874(%rip)      # 0xc890
jne 0x6041
movl %ebx, %edi
movl $0x2, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x31d0
testl %eax, %eax
je 0x6041
movl %ebx, %edi
callq 0x5fc7
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0x5d2c
leaq 0xa(%rsp), %rdi
movq %rbx, %rsi
callq 0x6114
testl %eax, %eax
je 0x60f5
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3160
testl %eax, %eax
je 0x608a
callq 0x3040
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x2, (%rax)
jne 0x6105
movl $0x1, %edi
callq 0x5f75
movl %eax, 0x4(%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x6105
leaq 0x4(%rsp), %rcx
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x34e0
testl %eax, %eax
jne 0x60ea
movl 0x4(%rsp), %edi
addl $0x2, %ebp
leaq 0xa(%rsp), %rsi
movl %ebp, %edx
callq 0x3070
testl %eax, %eax
jne 0x60ea
movl 0x4(%rsp), %edi
movl $0x5, %esi
callq 0x3370
testl %eax, %eax
je 0x610e
movl 0x4(%rsp), %edi
callq 0x5fc7
jmp 0x6105
callq 0x3040
movl $0x16, (%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movl 0x4(%rsp), %ebx
jmp 0x6105
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3140
xorl %ecx, %ecx
cmpl $0x6c, %eax
jg 0x6170
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x5e(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movw $0x1, (%rbx)
addq $0x2, %rbx
movslq %eax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3140
movq %rax, %rcx
addl $0x2, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
callq 0x5d2c
leaq 0x2(%rsp), %rdi
movq %rbx, %rsi
callq 0x6114
testl %eax, %eax
je 0x621e
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x32b0
testl %eax, %eax
jne 0x621e
movl $0xf000, %eax           # imm = 0xF000
andl 0x88(%rsp), %eax
cmpl $0xc000, %eax           # imm = 0xC000
jne 0x621e
movl $0x1, %edi
callq 0x5f75
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x622e
movl %eax, %ebp
callq 0x3040
movq %rax, %r14
leaq 0x4(%rsp), %r15
leaq 0x2(%rsp), %r12
movl $0x0, (%r14)
movq %r15, %rdi
callq 0x3140
leal 0x2(%rax), %edx
movl %ebp, %edi
movq %r12, %rsi
callq 0x3280
testl %eax, %eax
jns 0x621a
movl (%r14), %eax
cmpl $0x4, %eax
je 0x61ed
cmpl $0xb, %eax
jne 0x6240
movl %ebp, %ebx
jmp 0x622e
callq 0x3040
movl $0x16, (%rax)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0x5fc7
jmp 0x622e
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: sock_connect
int
sock_connect(const char *host, int port, int nowait)
{
    dyninit();

    char sport[7];
    sprintf(sport, "%hu", (uint16_t)port);
    ADRINFO *aip, hint = {
        AI_NUMERICSERV, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP,
        /*addrlen */0, /*addr */0, /*canonname */0, /*next */0
    };

    if (getaddrinfo(host, sport, &hint, &aip)) return -1;

    // "ai_family" usable here because PF_INET=AF_INET, PF_INET6=AF_INET6.
    int fd = sockit(aip->ai_family), ret = -1;
    if (fd >= 0
        && !(nowait && sock_setopt(fd, SOCK_NOWAIT, 1))
        && !setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&fd, sizeof fd)) {

        do errno = 0, ret = connect(fd, aip->ai_addr, aip->ai_addrlen);
        while (ret < 0 && errno == EINTR);
    }

    freeaddrinfo(aip);
    return ret < 0 && errno != EINPROGRESS ? eclose(fd) : fd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x5d2c
movzwl %bp, %edx
leaq 0x292d(%rip), %rsi      # 0x8ba0
leaq 0x19(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3080
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movl $0x400, (%rdx)          # imm = 0x400
movabsq $0x600000001, %rax      # imm = 0x600000001
movq %rax, 0x8(%rdx)
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x33e0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x636a
movq 0x10(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x5f75
movl %eax, 0xc(%rsp)
testl %eax, %eax
js 0x6342
testl %ebx, %ebx
je 0x62f6
movl %eax, %edi
movl $0x2, %esi
movl $0x1, %edx
callq 0x6381
testl %eax, %eax
jne 0x6342
leaq 0xc(%rsp), %rcx
movl (%rcx), %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x34e0
testl %eax, %eax
jne 0x6342
callq 0x3040
movq %rax, %rbx
movl $0x0, (%rbx)
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x3280
testl %eax, %eax
jns 0x6375
cmpl $0x4, (%rbx)
je 0x631e
movq 0x10(%rsp), %rdi
callq 0x33f0
callq 0x3040
cmpl $0x73, (%rax)
jne 0x635c
movl 0xc(%rsp), %eax
jmp 0x636a
movl 0xc(%rsp), %edi
callq 0x5fc7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
callq 0x33f0
jmp 0x6356
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: sock_setopt
int
sock_setopt(int skt, SOCK_OPT opt, int val)
{
    dyninit();

    if (opt >= SOCK_OPTS) return errno = EINVAL, -1;
#ifdef TCP_KEEPALIVE    // Darwin,FreeBSD
    if (opt == SOCK_KEEPALIVE && setsockopt(skt, SOL_SOCKET, SO_KEEPALIVE, (char const*)&val, sizeof val))
        return -1;
#endif

    struct linger lng = { val > 0, val }; //XXX why winwarn?
    return opt == SOCK_LINGER      ? setsockopt(skt, SOL_SOCKET, SO_LINGER, &lng, sizeof lng)
        : opts[opt].lvl == F_GETFL ? fcntl(skt, F_SETFL, BIT(fcntl(skt, F_GETFL, 0), opts[opt].opt, val))
                                   : setsockopt(skt, opts[opt].lvl, opts[opt].opt, (char*)&val, sizeof val);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movl %edi, %ebx
movl %edx, 0xc(%rsp)
callq 0x5d2c
cmpl $0x8, %ebp
jb 0x63b2
callq 0x3040
movl $0x16, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6442
movl 0xc(%rsp), %eax
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
movl %ecx, 0x10(%rsp)
movl %eax, 0x14(%rsp)
cmpl $0x6, %ebp
jne 0x63e3
leaq 0x10(%rsp), %rcx
movl %ebx, %edi
movl $0x1, %esi
movl $0xd, %edx
movl $0x8, %r8d
jmp 0x643d
movl %ebp, %r14d
leaq 0x27f3(%rip), %r15      # 0x8be0
movl (%r15,%r14,8), %esi
cmpl $0x3, %esi
jne 0x642b
movl %ebx, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x31d0
movl 0x4(%r15,%r14,8), %edx
movl %edx, %ecx
orl %eax, %ecx
notl %edx
andl %eax, %edx
cmpl $0x0, 0xc(%rsp)
cmovnel %ecx, %edx
movl %ebx, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x31d0
jmp 0x6442
movl 0x4(%r15,%r14,8), %edx
leaq 0xc(%rsp), %rcx
movl %ebx, %edi
movl $0x4, %r8d
callq 0x34e0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: sock_ready
int
sock_ready(int skt, int mode, int waitsecs)
{
    dyninit();

    int ret, err;
#ifdef USE_POLL
    struct pollfd sockpoll = { skt, mode ? POLLOUT : POLLIN,  0 };

    do errno = 0, ret = poll(&sockpoll, 1, waitsecs);
    while (ret < 0 && errno == EINTR);

    err = sockpoll.revents & POLLERR;
#else//USE_POLL
    fd_set rwfds, erfds;
    FD_ZERO(&rwfds);
    FD_ZERO(&erfds);
    do {
        struct timeval to = { waitsecs, 0 }, *top = waitsecs == WAIT_FOREVER ? NULL : &to;
        FD_SET(skt, &rwfds);
        FD_SET(skt, &erfds);

        errno = 0;
        ret = mode  ? select(skt + 1, NULL, &rwfds, &erfds, top)
                    : select(skt + 1, &rwfds, NULL, &erfds, top);
    } while (ret < 0 && errno == EINTR);

    err = FD_ISSET(skt, &erfds);
#endif//USE_POLL

    return err && ret > 0 ? -2 : ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movl %edx, %ebp
movl %esi, 0xc(%rsp)
movl %edi, %r14d
callq 0x5d2c
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x70(%rax)
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movslq %ebp, %r15
xorl %eax, %eax
cmpl $-0x1, %r15d
leaq 0x10(%rsp), %r13
cmoveq %rax, %r13
leal 0x3f(%r14), %eax
testl %r14d, %r14d
cmovnsl %r14d, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %r14d, %ecx
subl %edx, %ecx
movl $0x1, %r12d
shlq %cl, %r12
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
sarl $0x6, %eax
movslq %eax, %rbx
callq 0x3040
movq %rax, %rbp
incl %r14d
orq %r12, 0xa0(%rsp,%rbx,8)
orq %r12, 0x20(%rsp,%rbx,8)
movq %r15, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, (%rbp)
cmpl $0x0, 0xc(%rsp)
je 0x6533
movl %r14d, %edi
xorl %esi, %esi
leaq 0xa0(%rsp), %rdx
jmp 0x6540
movl %r14d, %edi
leaq 0xa0(%rsp), %rsi
xorl %edx, %edx
leaq 0x20(%rsp), %rcx
movq %r13, %r8
callq 0x32f0
testl %eax, %eax
jns 0x6557
cmpl $0x4, (%rbp)
je 0x64fb
testq %r12, 0x20(%rsp,%rbx,8)
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
cmovel %eax, %ecx
testl %eax, %eax
cmovlel %eax, %ecx
movl %ecx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: sock_recv
int
sock_recv(int skt, char *buf, int size)
{
    dyninit();

    int ret;
    do errno = 0, ret = recv(skt, buf, size, 0);
    while (ret < 0 && errno == EINTR);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movl %edi, %ebp
callq 0x5d2c
callq 0x3040
movq %rax, %r14
movslq %r15d, %r15
movl $0x0, (%r14)
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x30f0
testl %eax, %eax
jns 0x67b2
cmpl $0x4, (%r14)
je 0x6792
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: sock_send
int
sock_send(int skt, char const *buf, int size)
{
    dyninit();

    int ret;
    do errno = 0, ret = send(skt, buf, size, 0);
    while (ret < 0 && errno == EINTR);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movl %edi, %ebp
callq 0x5d2c
callq 0x3040
movq %rax, %r14
movslq %r15d, %r15
movl $0x0, (%r14)
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x3190
testl %eax, %eax
jns 0x67fc
cmpl $0x4, (%r14)
je 0x67dc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: sock_recvfd
int
sock_recvfd(int skt, int *pfd, char *buf, int size)
{
    dyninit();

    int ret;
    char x;
    FDCMSG ctl = { {sizeof ctl, 0, 0} , -1 };
    struct iovec iov[2] = { {&x, sizeof x} , {buf, size} };
    struct msghdr msg = { 0, 0, iov, 1 + (buf && size), &ctl, sizeof ctl, 0 };

    do errno = 0, ret = recvmsg(skt, &msg, cmsg_cloexec);
    while (ret < 0 && errno == EINTR);

    if (ret >= 0 && !cmsg_cloexec && fcntl(ctl.fd, F_SETFD, FD_CLOEXEC))
        return close(ctl.fd), -1;

    if (pfd)
        *pfd = ctl.fd;

    return ret < 0 ? ret
        : memcmp(&ctl.c, &fdc_hdr, sizeof fdc_hdr) ? errno = ENOMSG, -1
        : ret - (int) sizeof(x) * (ret > 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %ebp
callq 0x5d2c
movdqu 0x2382(%rip), %xmm0     # 0x8bb0
leaq 0x10(%rsp), %rax
movdqa %xmm0, (%rax)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rax)
leaq 0xf(%rsp), %rcx
leaq 0x30(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x1, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movslq %r14d, %rcx
movq %rcx, 0x18(%rdx)
leaq 0x58(%rsp), %r12
movq $0x0, (%r12)
xorl %esi, %esi
movl %esi, 0x8(%r12)
movq %rdx, 0x10(%r12)
testq %r15, %r15
setne %dl
testl %ecx, %ecx
setne %cl
andb %dl, %cl
movzbl %cl, %ecx
incq %rcx
movq %rcx, 0x18(%r12)
movq %rax, 0x20(%r12)
movq $0x18, 0x28(%r12)
movl %esi, 0x30(%r12)
callq 0x3040
movq %rax, %r15
movl $0x0, (%r15)
movl %ebp, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x30c0
movq %rax, %r14
testl %r14d, %r14d
jns 0x68cf
cmpl $0x4, (%r15)
je 0x68ac
jmp 0x68f3
movl 0x20(%rsp), %edi
movl $0x2, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x31d0
testl %eax, %eax
je 0x68f3
movl 0x20(%rsp), %edi
callq 0x3550
jmp 0x6923
testq %rbx, %rbx
je 0x68fe
movl 0x20(%rsp), %eax
movl %eax, (%rbx)
testl %r14d, %r14d
js 0x6933
movdqa 0x10(%rsp), %xmm0
pcmpeqb 0x227f(%rip), %xmm0     # 0x8b90
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x692b
movl $0x2a, (%r15)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x6933
cmpl $0x1, %r14d
adcl $-0x1, %r14d
movl %r14d, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: sock_sendfd
int
sock_sendfd(int skt, int fd, char const *buf, int size)
{
    dyninit();

    char          x = 0;
    FDCMSG        ctl = { fdc_hdr, fd };
    struct iovec  iov[2] = { {&x, sizeof x}, {(void *) (intptr_t) buf, size} };
    struct msghdr msg = { 0, 0, iov, 1 + (buf && size), &ctl, sizeof ctl, 0 };
    int           ret;

    do errno = 0, ret = sendmsg(skt, &msg, 0);
    while (ret < 0 && errno == EINTR);

    return ret - sizeof(x) * (ret > 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r14d
movl %edi, %ebx
callq 0x5d2c
leaq 0xf(%rsp), %rax
movb $0x0, (%rax)
movups 0x2257(%rip), %xmm0     # 0x8bc8
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movl %r14d, 0x10(%rcx)
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movq $0x1, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movslq %ebp, %rax
movq %rax, 0x18(%rdx)
leaq 0x50(%rsp), %r14
movq $0x0, (%r14)
xorl %esi, %esi
movl %esi, 0x8(%r14)
movq %rdx, 0x10(%r14)
testq %r15, %r15
setne %dl
testl %eax, %eax
setne %al
andb %dl, %al
movzbl %al, %eax
incq %rax
movq %rax, 0x18(%r14)
movq %rcx, 0x20(%r14)
movq $0x18, 0x28(%r14)
movl %esi, 0x30(%r14)
callq 0x3040
movq %rax, %r15
movl $0x0, (%r15)
movl %ebx, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3250
testl %eax, %eax
jns 0x69fa
cmpl $0x4, (%r15)
je 0x69dd
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
subl %ecx, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: sock_getopt
int
sock_getopt(int skt, SOCK_OPT opt)
{
    dyninit();

    int         ret, val;
    socklen_t   len;

    if (opt >= SOCK_OPTS) return errno = EINVAL, -1;

    if (opt == SOCK_LINGER) {
        struct linger lng;
        len = sizeof lng;
        ret = getsockopt(skt, SOL_SOCKET, SO_LINGER, (char*)&lng, &len);
        return ret ? ret : lng.l_onoff ? lng.l_linger : 0;
    } else if (opts[opt].lvl == F_GETFL) {
        return !!(fcntl(skt, F_GETFL, 0) & opts[opt].opt);
    } else {
        len = sizeof val;
        ret = getsockopt(skt, opts[opt].lvl, opts[opt].opt, (char*)&val, &len);
        return ret ? ret : val;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movl %edi, %ebx
callq 0x5d2c
cmpl $0x8, %ebp
jb 0x6a3e
callq 0x3040
movl $0x16, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x6ad2
cmpl $0x6, %ebp
jne 0x6a7c
leaq 0x14(%rsp), %r8
movl $0x8, (%r8)
leaq 0xc(%rsp), %r14
movl %ebx, %edi
movl $0x1, %esi
movl $0xd, %edx
movq %r14, %rcx
callq 0x3230
movl %eax, %ecx
movl (%r14), %eax
testl %eax, %eax
je 0x6a75
movl 0x10(%rsp), %eax
testl %ecx, %ecx
cmovnel %ecx, %eax
jmp 0x6ad2
movl %ebp, %r14d
leaq 0x215a(%rip), %r15      # 0x8be0
movl (%r15,%r14,8), %esi
cmpl $0x3, %esi
jne 0x6aad
movl %ebx, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x31d0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, 0x4(%r15,%r14,8)
setne %al
jmp 0x6ad2
leaq 0x14(%rsp), %r8
movl $0x4, (%r8)
movl 0x4(%r15,%r14,8), %edx
leaq 0xc(%rsp), %rcx
movl %ebx, %edi
callq 0x3230
testl %eax, %eax
jne 0x6ad2
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: sock_addr
int
sock_addr(int skt, IPSTR ip, int *pport, char *name, int size)
{
    dyninit();

    INxADDR sin;
    socklen_t len = sizeof(sin);
    if (0 > getsockname(skt, (SOADDR*)&sin, &len))
        return -1;

    ininfo(&sin, ip, pport);
    return -(name && size
             && getnameinfo((SOADDR*) &sin, len, name, size, NULL, 0, 0));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %ebp
callq 0x5d2c
leaq 0x10(%rsp), %rdx
movl $0x1c, (%rdx)
leaq 0x14(%rsp), %rsi
movl %ebp, %edi
callq 0x32d0
testl %eax, %eax
js 0x6b63
leaq 0x14(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x6b79
testq %r14, %r14
sete %al
testl %ebx, %ebx
sete %cl
xorl %r15d, %r15d
orb %al, %cl
jne 0x6b69
movl 0x10(%rsp), %esi
movl $0x0, (%rsp)
xorl %r15d, %r15d
leaq 0x14(%rsp), %rdi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x31e0
negl %eax
sbbl %r15d, %r15d
jmp 0x6b69
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: ininfo
static void
ininfo(INxADDR const*xp, IPSTR ip, int *pport)
{
    if (pport) *pport = ntohs(xp->inx_port);
    if (ip) inet_ntop(AF_INET,
                      xp->inx_family == AF_INET ? (void const*)&xp->in4.sin_addr
                                                : (void const*)&xp->in6.sin6_addr,
                      ip, sizeof(IPSTR));
}

// Assembly:
movq %rsi, %rax
testq %rdx, %rdx
je 0x6b8e
movzwl 0x2(%rdi), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
movl %ecx, (%rdx)
testq %rax, %rax
je 0x6bb6
xorl %ecx, %ecx
cmpw $0x2, (%rdi)
setne %cl
leaq (%rdi,%rcx,4), %rsi
addq $0x4, %rsi
movl $0x2, %edi
movq %rax, %rdx
movl $0x2e, %ecx
jmp 0x3310
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock.c
// Function: sock_peer
int
sock_peer(int skt, IPSTR ip, int *pport, char *name, int size)
{
    dyninit();

    INxADDR sin;
    socklen_t len = sizeof(sin);
    if (0 > getpeername(skt, (SOADDR*)&sin, &len)) return -1;

    ininfo(&sin, ip, pport);
    return -(name && size &&
             getnameinfo((SOADDR*)&sin, len, name, size, NULL, 0,
                          NI_NAMEREQD + NI_NOFQDN));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %ebp
callq 0x5d2c
leaq 0x10(%rsp), %rdx
movl $0x1c, (%rdx)
leaq 0x14(%rsp), %rsi
movl %ebp, %edi
callq 0x3210
testl %eax, %eax
js 0x6c3d
leaq 0x14(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x6b79
testq %r14, %r14
sete %al
testl %ebx, %ebx
sete %cl
xorl %r15d, %r15d
orb %al, %cl
jne 0x6c43
movl 0x10(%rsp), %esi
movl $0xc, (%rsp)
xorl %r15d, %r15d
leaq 0x14(%rsp), %rdi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x31e0
negl %eax
sbbl %r15d, %r15d
jmp 0x6c43
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq