LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]cpp-prelude/./prelude.h
// Function: std::vector<int, std::allocator<int>> Prelude::concat<std::__cxx11::list<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>, std::vector<int, std::allocator<int>>>(std::__cxx11::list<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
auto concat(const _Container& c) -> Inner {
  auto res = Inner{};
  for (const auto _c : c) {
    res.insert(std::end(res), std::begin(_c), std::end(_c));
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsp, %r15
movq %rsi, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x72dc
leaq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x6802
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x6850
movq %r15, %rdi
callq 0x62fa
jmp 0x72a7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x72fb
movq %rax, %r14
movq %rsp, %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x62fa
movq %r14, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]cpp-prelude/./prelude.h
// Function: std::vector<std::tuple<int, bool>, std::allocator<std::tuple<int, bool>>> Prelude::zip<std::vector, int, std::allocator<int>, std::__cxx11::list, bool, std::allocator<bool>, std::vector, std::tuple<int, bool>, std::allocator<std::tuple<int, bool>>>(std::vector<int, std::allocator<int>> const&, std::__cxx11::list<bool, std::allocator<bool>> const&)
auto zip(const CA<A, AllocA>& left, const CB<B, AllocB>& right)
    -> CRES<RES, AllocRES> {
  auto res = CRES<RES, AllocRES>{};
  auto l = std::begin(left);
  auto r = std::begin(right);
  while (l != std::end(left) && r != std::end(right)) {
    res.emplace_back(*l, *r);
    ++l;
    ++r;
  }
  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %r12
movq %rdx, %r13
cmpq 0x8(%r15), %r12
je 0x5ae1
movq (%r13), %r13
cmpq %r14, %r13
je 0x5ae1
leaq 0x10(%r13), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x786e
addq $0x4, %r12
jmp 0x5abd
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x76e6
movq %r14, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]cpp-prelude/./prelude.h
// Function: std::vector<std::tuple<int, bool, char>, std::allocator<std::tuple<int, bool, char>>> Prelude::zip3<std::vector, int, std::allocator<int>, std::__cxx11::list, bool, std::allocator<bool>, std::vector, char, std::allocator<char>, std::vector, std::tuple<int, bool, char>, std::allocator<std::tuple<int, bool, char>>>(std::vector<int, std::allocator<int>> const&, std::__cxx11::list<bool, std::allocator<bool>> const&, std::vector<char, std::allocator<char>> const&)
auto zip3(const CA<A, AllocA>& left, const CB<B, AllocB>& middle,
          const CC<C, AllocC>& right) -> CRES<RES, AllocRES> {
  auto res = CRES<RES, AllocRES>{};
  auto l = std::begin(left);
  auto m = std::begin(middle);
  auto r = std::begin(right);
  while (l != std::end(left) && m != std::end(middle) && r != std::end(right)) {
    res.emplace_back(*l, *m, *r);
    ++l;
    ++m;
    ++r;
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
movq (%rsi), %r13
movq %rcx, %rbx
movq (%rcx), %rbp
movq %rdx, %r15
cmpq 0x8(%r12), %r13
je 0x5bf5
movq (%r15), %r15
cmpq %r14, %r15
je 0x5bf5
cmpq 0x8(%rbx), %rbp
je 0x5bf5
leaq 0x10(%r15), %rdx
movq (%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rcx
callq 0x7ba8
addq $0x4, %r13
incq %rbp
jmp 0x5bc4
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
callq 0x7a5c
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]cpp-prelude/./prelude.h
// Function: std::tuple<std::vector<int, std::allocator<int>>, std::vector<bool, std::allocator<bool>>> Prelude::unzip<std::vector, std::tuple<int, bool>, std::allocator<std::tuple<int, bool>>, std::vector, int, std::allocator<int>, std::vector, bool, std::allocator<bool>>(std::vector<std::tuple<int, bool>, std::allocator<std::tuple<int, bool>>> const&)
auto unzip(const CN<TUP, AllocTUP>& c)
    -> std::tuple<CA<A, AllocA>, CB<B, AllocB>> {
  auto ca = CA<A, AllocA>{};
  auto cb = CB<B, AllocB>{};
  for (const auto& t : c) {
    // wanted to use emplace_back but not
    // available for vector<bool>, maybe use back_inserter...
    ca.push_back(std::get<0>(t));
    cb.push_back(std::get<1>(t));
  }
  return std::make_tuple(ca, cb);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x20(%rsp), %r15
andq $0x0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x5dd2
addq $0x4, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x6b66
movzbl -0x4(%r12), %esi
movq %r15, %rdi
callq 0x6384
addq $0x4, %r12
jmp 0x5daa
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x8394
leaq 0x20(%rsp), %rdi
callq 0x5620
movq %rsp, %rdi
callq 0x62fa
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5e07
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5620
movq %rsp, %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]cpp-prelude/./prelude.h
// Function: std::tuple<std::vector<int, std::allocator<int>>, std::vector<char, std::allocator<char>>, std::vector<bool, std::allocator<bool>>> Prelude::unzip3<std::vector, std::tuple<int, char, bool>, std::allocator<std::tuple<int, char, bool>>, std::vector, int, std::allocator<int>, std::vector, char, std::allocator<char>, std::vector, bool, std::allocator<bool>>(std::vector<std::tuple<int, char, bool>, std::allocator<std::tuple<int, char, bool>>> const&)
auto unzip3(const CN<TUP, AllocTUP>& c)
    -> std::tuple<CA<A, AllocA>, CB<B, AllocB>, CC<C, AllocC>> {
  auto ca = CA<A, AllocA>{};
  auto cb = CB<B, AllocB>{};
  auto cc = CC<C, AllocC>{};
  for (const auto& t : c) {
    ca.push_back(std::get<0>(t));
    cb.push_back(std::get<1>(t));
    cc.push_back(std::get<2>(t));
  }
  return std::make_tuple(ca, cb, cc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq %rsp, %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
leaq 0x40(%rsp), %r12
andq $0x0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq (%rsi), %r13
movq 0x8(%rsi), %rbp
cmpq %rbp, %r13
je 0x5ed1
addq $0x4, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x6b66
addq $-0x3, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x85b8
movzbl -0x1(%r13), %esi
movq %r12, %rdi
callq 0x6384
addq $0x7, %r13
jmp 0x5e9b
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
leaq 0x40(%rsp), %rcx
movq %rbx, %rdi
callq 0x86cc
leaq 0x40(%rsp), %rdi
callq 0x5620
movq %rsp, %rdi
callq 0x7b3e
leaq 0x20(%rsp), %rdi
callq 0x62fa
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5f16
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5620
movq %rsp, %rdi
callq 0x7b3e
leaq 0x20(%rsp), %rdi
callq 0x62fa
movq %rbx, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_db.cc
// Function: to_string[abi:cxx11](unsigned int, int)
std::string to_string(unsigned int n, int n_digits) {
	std::string r;
	while (n_digits-- > 0 || n > 0) {
		r = std::to_string(n%10) + r;
		n /= 10;
	}
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
pushq $0xa
popq %r13
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
testl %ebp, %ebp
setg %al
testl %r14d, %r14d
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x3883
movl %r14d, %eax
xorl %edx, %edx
divl %r13d
movl %eax, %r14d
movq %r15, %rdi
movl %edx, %esi
callq 0x3e0c
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3ded
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32e0
movq %r12, %rdi
callq 0x3100
movq %r15, %rdi
callq 0x3100
decl %ebp
jmp 0x382f
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3100
jmp 0x38a7
movq %rax, %r14
movq %rbx, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_db.cc
// Function: DNS_DB::DomainIterator::~DomainIterator()
DNS_DB::DomainIterator::~DomainIterator() {
	for (unsigned int i = 0; i < db->iterators.size(); i++) {
		if (db->iterators[i] == this) {
			db->iterators.erase(db->iterators.begin()+i);
			break;
		}
	}
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq 0x30(%rdi), %rdx
leaq 0x88(%rdx), %rdi
movq 0x88(%rdx), %rcx
movq 0x90(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %r8d, %r8d
movl %r8d, %esi
cmpq %rsi, %rdx
jbe 0x3da0
leal 0x1(%rsi), %r8d
cmpq %rax, (%rcx,%rsi,8)
jne 0x3d85
leaq (%rcx,%rsi,8), %rsi
callq 0x3ecc
popq %rax
retq
movq %rax, %rdi
callq 0x3de2
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::lookupNode(char const*) const
int DNS_DB::DnsIndex::lookupNode(const char * domain) const {
	// Look for node which potentially has this domain
	int first = 0, last = nodes.size()-1;
	while (first <= last) {
		int middle = (first+last)>>1;
		const Node * n = &nodes[middle];
		if ( less_eq(n->min, domain) && less(domain, n->max) )
			return middle;
		else if less_eq(domain, n->min)
			last = middle - 1;
		else
			first = middle + 1;
	}
	assert(0 && "This should never occur\n");
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq %rcx, (%rsp)
subq %rcx, %rax
pushq $0x4a
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
decl %r14d
xorl %ebp, %ebp
pushq $0x23
popq %r15
cmpl %r14d, %ebp
jg 0x42f1
leal (%r14,%rbp), %r12d
shrl %r12d
imulq $0x4a, %r12, %r13
addq (%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3120
testl %eax, %eax
jg 0x42bd
leaq 0x23(%r13), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3120
testl %eax, %eax
js 0x42df
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x3120
testl %eax, %eax
jle 0x42d7
incl %r12d
movl %r12d, %ebp
jmp 0x4284
decl %r12d
movl %r12d, %r14d
jmp 0x4284
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e01(%rip), %rdi      # 0x90f9
leaq 0x4e1b(%rip), %rsi      # 0x911a
leaq 0x4e21(%rip), %rcx      # 0x9127
pushq $0x1c
popq %rdx
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::DnsIndex(DNS_DB*)
DNS_DB::DnsIndex::DnsIndex(DNS_DB * db) : database(db) {
	Node n;
	n.dnsblock_id = 0;
	memset(n.min, 0, sizeof(n.min));
	memset(n.max,~0, sizeof(n.min));
	nodes.push_back(n);
	current_id = 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqu %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movq %rsp, %rsi
movdqa %xmm0, (%rsi)
movdqa %xmm0, 0x10(%rsi)
andl $0x0, 0x1f(%rsi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x42(%rsi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x23(%rsi)
movdqu %xmm0, 0x33(%rsi)
callq 0x4e14
movl $0x1, 0x20(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f06
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::serialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DNS_DB::DnsIndex::serialize(std::string file) {
	// Write to file
	FILE * fd = fopen(file.c_str(),"wb");
	uint32_t s = nodes.size();
	fwrite(&s, 1, 4, fd);
	for (unsigned int i = 0; i < nodes.size(); i++) {
		fwrite(&nodes[i], 1, MAX_DNS_SIZE*2 + 4, fd);
	}
	fclose(fd);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x4dca(%rip), %rsi      # 0x915c
callq 0x32b0
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
movq %rax, %r14
pushq $0x4a
popq %r15
movq %rcx, %rax
cqto
idivq %r15
leaq 0xc(%rsp), %rdi
movl %eax, (%rdi)
pushq $0x1
popq %r12
pushq $0x4
popq %rdx
movq %r12, %rsi
movq %r14, %rcx
callq 0x3490
xorl %eax, %eax
movl %eax, %r13d
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r15
cmpq %r13, %rax
jbe 0x43fa
imulq $0x4a, %r13, %rax
addq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3490
leal 0x1(%r13), %eax
jmp 0x43c8
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3250
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::unserialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void DNS_DB::DnsIndex::unserialize(const std::string & file) {
	// Read from file
	if (!FileMapper::getInstance().fileExists(file)) {
		fprintf(stderr,"Warning: Could not read DB index!\n");
		return;
	}

	// Discard our own index
	nodes.clear();

	void * fptr = FileMapper::getInstance().mapFile(file);

	uint32_t nblks = *(uint32_t*)fptr;
	char * cptr = (char*)fptr;
	cptr += 4;

	for (unsigned int i = 0; i < nblks; i++) {
		Node * nodeptr = (Node*)cptr;
		nodes.push_back(*nodeptr);
		cptr += MAX_DNS_SIZE*2 + 4;
	}
	FileMapper::getInstance().unmap(fptr);

	// Find the biggest id
	current_id = 0;
	for (unsigned i = 0; i < nodes.size(); i++)
		if (nodes[i].dnsblock_id > current_id)
			current_id = nodes[i].dnsblock_id;
	current_id++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3e6a
movq %rax, %rdi
movq %r14, %rsi
callq 0x6eba
testb %al, %al
je 0x44c6
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x4442
movq %rax, 0x8(%rbx)
callq 0x3e6a
movq %rax, %rdi
movq %r14, %rsi
callq 0x6b90
movq %rax, %r14
movl (%rax), %ebp
movq %rax, %r15
addq $0x4, %r15
subl $0x1, %ebp
jb 0x4474
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4e14
addq $0x4a, %r15
jmp 0x445e
callq 0x3e6a
movq %rax, %rdi
movq %r14, %rsi
callq 0x6d88
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
pushq $0x4a
popq %rsi
cqto
idivq %rsi
xorl %edx, %edx
xorl %esi, %esi
movl %esi, %esi
cmpq %rsi, %rax
jbe 0x44b6
imulq $0x4a, %rsi, %rdi
movl 0x46(%rcx,%rdi), %edi
cmpl %edx, %edi
jbe 0x44b2
movl %edi, 0x20(%rbx)
movl %edi, %edx
incl %esi
jmp 0x449a
incl %edx
movl %edx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xab03(%rip), %rax      # 0xefd0
movq (%rax), %rcx
leaq 0x4c88(%rip), %rdi      # 0x915f
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::check()
void DNS_DB::DnsIndex::check() {
	// Check consistency
	for (unsigned int i = 0; i < nodes.size(); i++) {
		if (!less(nodes[i].min, nodes[i].max)) {
			fprintf(stderr, "DB index error!!!\n");
		}
	}

	// Make sure the index is sorted
	for (unsigned int i = 1; i < nodes.size(); i++) {
		if (!less(nodes[i-1].min, nodes[i].min) ||
			!  eq(nodes[i-1].max, nodes[i].min)) {

			fprintf(stderr, "DB index error!!!\n");
		}
	}

	for (unsigned int i = 0; i < nodes.size(); i++) {
		DNS_DB::DnsBlockPtr blk = database->getBlock(nodes[i].dnsblock_id);
		blk->check();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r13d, %r13d
pushq $0x23
popq %r15
pushq $0x1
popq %r12
movl %r13d, %r13d
movq (%rbx), %rbp
movq 0x8(%rbx), %r14
movq %r14, %rax
subq %rbp, %rax
cqto
pushq $0x4a
popq %rcx
idivq %rcx
cmpq %r13, %rax
jbe 0x4564
imulq $0x4a, %r13, %rax
leaq (%rax,%rbp), %rdi
leaq (%rax,%rbp), %rsi
addq $0x23, %rsi
movq %r15, %rdx
callq 0x3120
testl %eax, %eax
jns 0x4546
incl %r13d
jmp 0x4508
movq 0xaa83(%rip), %rax      # 0xefd0
movq (%rax), %rcx
leaq 0x4c2b(%rip), %rdi      # 0x9182
pushq $0x12
popq %rsi
movq %r12, %rdx
callq 0x3490
jmp 0x4541
movq %rbx, (%rsp)
xorl %ecx, %ecx
pushq $0x23
popq %rbx
leal 0x1(%rcx), %r15d
movq %r14, %rax
subq %rbp, %rax
cqto
pushq $0x4a
popq %rsi
idivq %rsi
cmpq %r15, %rax
jbe 0x45ea
movl %ecx, %eax
imulq $0x4a, %rax, %r12
addq %rbp, %r12
imulq $0x4a, %r15, %r13
addq %rbp, %r13
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x3120
testl %eax, %eax
jns 0x45c1
addq $0x23, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x3120
testl %eax, %eax
jne 0x45c1
movl %r15d, %ecx
jmp 0x456d
movq 0xaa08(%rip), %rax      # 0xefd0
movq (%rax), %rcx
leaq 0x4bb0(%rip), %rdi      # 0x9182
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x3490
movq (%rsp), %rax
movq (%rax), %rbp
movq 0x8(%rax), %r14
jmp 0x45bc
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq (%rsp), %rbx
movl %r13d, %r13d
subq %rbp, %r14
movq %r14, %rax
cqto
pushq $0x4a
popq %rcx
idivq %rcx
cmpq %r13, %rax
jbe 0x4643
movq 0x18(%rbx), %rsi
imulq $0x4a, %r13, %rax
movl 0x46(%rbp,%rax), %edx
movq %r12, %rdi
callq 0x7510
movq 0x8(%rsp), %rdi
callq 0x63be
movq %r15, %rdi
callq 0x3f74
incl %r13d
movq (%rbx), %rbp
movq 0x8(%rbx), %r14
jmp 0x45fb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x3f74
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::getIterator(char const*)
DNS_DB::DnsIndex::Iterator DNS_DB::DnsIndex::getIterator(const char * domint) {
	if (domint) {
		int n = lookupNode(domint);
		return DNS_DB::DnsIndex::Iterator(this, n, domint, database);
	}else{
		return DNS_DB::DnsIndex::Iterator(this, 0, 0, database);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x4695
movq %rdx, %r15
movq %r14, %rdi
movq %rdx, %rsi
callq 0x4254
movq 0x18(%r14), %r8
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movq %r15, %rcx
jmp 0x46a3
movq 0x18(%r14), %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4e46
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::replaceIpv4(char const*, IPv4_Record const&, IPv4_Record const&)
void DNS_DB::DnsIndex::replaceIpv4(const char * domain, const IPv4_Record & oldrec, const IPv4_Record & newrec) {
	char domint[MAX_DNS_SIZE];
	if (!domain2idom(domain, domint)) {
		fprintf(stderr, "Domain too long!\n");
		return;
	}

	int n = lookupNode(domint);
	DNS_DB::DnsBlockPtr blk = database->getBlock(nodes[n].dnsblock_id);
	blk->replaceDomainIpv4(domint, oldrec, newrec);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %r15
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x6a68
testb %al, %al
je 0x472d
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4254
movq (%r15), %rcx
movq 0x18(%r15), %rsi
cltq
imulq $0x4a, %rax, %rax
movl 0x46(%rcx,%rax), %edx
movq %rsp, %r15
movq %r15, %rdi
callq 0x7510
movq (%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x5f88
leaq 0x8(%rsp), %rdi
callq 0x3f74
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xa89c(%rip), %rax      # 0xefd0
movq (%rax), %rcx
leaq 0x4a57(%rip), %rdi      # 0x9195
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
callq 0x3490
jmp 0x4721
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3f74
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::addBlock(unsigned int, char const*, char const*)
int DNS_DB::DnsIndex::addBlock(unsigned int nwblk_id, const char * vmin, const char * vmax) {
	DNS_DB::DnsIndex::Node node;
	node.dnsblock_id = nwblk_id;
	memcpy(node.min, vmin, MAX_DNS_SIZE);
	memcpy(node.max, vmax, MAX_DNS_SIZE);
	nodes.push_back(node);

	// Now sort all the nodes
	std::sort(nodes.begin(), nodes.end(), DNS_DB::DnsIndex::Node::lessthan);

	for (unsigned int i = 0; i < nodes.size(); i++)
		if (nodes[i].dnsblock_id == nwblk_id)
			return i;

	assert(0 && "Should never reach this\n");
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %rsi
movl %ebx, 0x46(%rsi)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, (%rsi)
movaps %xmm1, 0x10(%rsi)
movl 0x1f(%rdx), %eax
movl %eax, 0x1f(%rsi)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm0, 0x23(%rsi)
movups %xmm1, 0x33(%rsi)
movl 0x1f(%rcx), %eax
movl %eax, 0x42(%rsi)
callq 0x4e14
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x4e8(%rip), %rdx       # 0x4eb4
callq 0x50ac
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
pushq $0x4a
popq %rcx
cqto
idivq %rcx
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %eax
cmpq %rax, %rcx
jbe 0x4a05
imulq $0x4a, %rax, %rdx
cmpl %ebx, 0x46(%rsi,%rdx)
je 0x49fd
incl %eax
jmp 0x49e8
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x4835(%rip), %rdi      # 0x9241
leaq 0x4707(%rip), %rsi      # 0x911a
leaq 0x4848(%rip), %rcx      # 0x9262
movl $0x100, %edx            # imm = 0x100
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::hasDomain(char const*)
bool DNS_DB::DnsIndex::hasDomain(const char * domain) {
	char domint[MAX_DNS_SIZE];
	if (!domain2idom(domain, domint))
		return false;

	int n = lookupNode(domint);
	DNS_DB::DnsBlockPtr blk = database->getBlock(nodes[n].dnsblock_id);
	
	return blk->hasDomain(domint);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x6a68
testb %al, %al
je 0x4ad7
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4254
movq (%rbx), %rcx
movq 0x18(%rbx), %rsi
cltq
imulq $0x4a, %rax, %rax
movl 0x46(%rcx,%rax), %edx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7510
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x5c88
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x3f74
jmp 0x4ad9
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3f74
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::getNumberRecords()
unsigned long DNS_DB::DnsIndex::getNumberRecords() {
	unsigned long ret = 0;
	for (unsigned int i = 0; i < nodes.size(); i++) {
		ret += this->getBlock(nodes[i].dnsblock_id)->getNumRecords();
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbx
pushq $0x4a
popq %rbp
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
movl %r13d, %r13d
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
idivq %rbp
cmpq %r13, %rax
jbe 0x4d5e
imulq $0x4a, %r13, %rax
movl 0x46(%rcx,%rax), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ec2
movq 0x8(%rsp), %rdi
callq 0x4ee2
cltq
addq %rax, %r12
movq %rbx, %rdi
callq 0x3f74
incl %r13d
jmp 0x4d18
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f74
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_index.cc
// Function: DNS_DB::DnsIndex::getNumberFreeRecords()
unsigned long DNS_DB::DnsIndex::getNumberFreeRecords() {
	unsigned long ret = 0;
	for (unsigned int i = 0; i < nodes.size(); i++) {
		ret += this->getBlock(nodes[i].dnsblock_id)->getNumFreeRecords();
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbx
pushq $0x4a
popq %rbp
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
movl %r13d, %r13d
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
cqto
idivq %rbp
cmpq %r13, %rax
jbe 0x4dee
imulq $0x4a, %r13, %rax
movl 0x46(%rcx,%rax), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ec2
movq 0x8(%rsp), %rdi
callq 0x4eec
cltq
addq %rax, %r12
movq %rbx, %rdi
callq 0x3f74
incl %r13d
jmp 0x4da8
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f74
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::DnsBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
DNS_DB::DnsBlock::DnsBlock(const std::string & file, int blkid) {
	if (!FileMapper::getInstance().fileExists(file))
		FileMapper::getInstance().createFile(file, DNS_DB::DnsBlock::blockSize);
	
	void * ptr = FileMapper::getInstance().mapFile(file);

	this->blockptr = (InternalBlock *)ptr;
	this->endptr = &this->blockptr[numBlocks];
	this->blockid = blkid;
	this->bitmap.reset(new Bitmap(numBlocks));

	updateBM();

	assert(sizeof(InternalBlock) == 64);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
callq 0x3e6a
movq %rax, %rdi
movq %r14, %rsi
callq 0x6eba
testb %al, %al
jne 0x5840
callq 0x3e6a
movl 0x9a57(%rip), %edx      # 0xf28c
movq %rax, %rdi
movq %r14, %rsi
callq 0x6ee2
callq 0x3e6a
movq %rax, %rdi
movq %r14, %rsi
callq 0x6b90
movq %rax, (%rbx)
movl 0x9a36(%rip), %r15d     # 0xf290
movq %r15, %rcx
shlq $0x6, %rcx
addq %rax, %rcx
movq %rcx, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
pushq $0x18
popq %rdi
callq 0x3260
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x72e8
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x67cc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x58c6
movq %rax, %r15
movq %r14, %rdi
callq 0x3230
jmp 0x58b1
jmp 0x58ae
movq %rax, %r15
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x3f74
movq %r15, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::lookupDomain(char const*) const
DNS_DB::DnsBlock::InternalBlock * DNS_DB::DnsBlock::lookupDomain(const char * domain) const {
	// Pick the specified element
	int p;
	int res = lookupEmptyDomainSpot(domain, &p);
	if (res != ALREADY_EXISTS || p < 0 || p >= numBlocks) return 0;

	DNS_DB::DnsBlock::InternalBlock * ptr = &blockptr[p];

	assert(ptr->header & flagDomain);
	assert(memcmp(domain, ptr->data.domain.domain, MAX_DNS_SIZE) == 0);
	
	return ptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc(%rsp), %rdx
callq 0x5a60
xorl %ebx, %ebx
cmpl $-0x2, %eax
jne 0x5a1c
movl 0xc(%rsp), %eax
testl %eax, %eax
js 0x5a1c
cmpl 0x989e(%rip), %eax      # 0xf290
jae 0x5a1c
movq (%r15), %rbx
shlq $0x6, %rax
movb 0x9888(%rip), %cl       # 0xf289
testb %cl, (%rbx,%rax)
je 0x5a29
addq %rax, %rbx
leaq 0x1(%rbx), %rsi
pushq $0x23
popq %rdx
movq %r14, %rdi
callq 0x3270
testl %eax, %eax
jne 0x5a42
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3933(%rip), %rdi      # 0x9363
leaq 0x3892(%rip), %rsi      # 0x92c9
leaq 0x393e(%rip), %rcx      # 0x937c
pushq $0x4b
jmp 0x5a59
leaq 0x3987(%rip), %rdi      # 0x93d0
leaq 0x3879(%rip), %rsi      # 0x92c9
leaq 0x3925(%rip), %rcx      # 0x937c
pushq $0x4c
popq %rdx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::getIpsv4(int) const
std::vector <IPv4_Record> DNS_DB::DnsBlock::getIpsv4(int p) const {
	std::vector <IPv4_Record> ret;
	const DNS_DB::DnsBlock::InternalBlock * ptr = &blockptr[p];
	if (ptr == 0)
		return ret;

	assert((ptr->header & DNS_DB::DnsBlock::flagDomain) != 0);
	assert((ptr->header & DNS_DB::DnsBlock::flagUsed) != 0);

	do {
		if (ptr->header & DNS_DB::DnsBlock::flagDomain) {
			for (int i = 0; i < 2; i++)
				if (ptr->data.domain.records[i].ip != 0)
					ret.push_back(ptr->data.domain.records[i]);
		}
		else {
			for (int i = 0; i < 5; i++)
				if (ptr->data.records.records[i].ip != 0)
					ret.push_back(ptr->data.records.records[i]);
		}
		ptr++;
	} while (ptr != endptr && !(ptr->header & DNS_DB::DnsBlock::flagDomain) && (ptr->header & DNS_DB::DnsBlock::flagUsed));

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x8(%rsp)
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x5c2a
movslq %edx, %rdx
shlq $0x6, %rdx
leaq (%rsi,%rdx), %r12
movb (%r12), %al
movb 0x9713(%rip), %cl       # 0xf289
testb %al, %cl
je 0x5c3c
testb %al, 0x9704(%rip)       # 0xf288
je 0x5c55
leaq (%rdx,%rsi), %r15
addq $0x24, %r15
leaq (%rdx,%rsi), %rbp
addq $0xc, %rbp
leaq (%rdx,%rsi), %r14
addq $0x4, %r14
testb %al, %cl
movq %r15, 0x10(%rsp)
je 0x5bcd
pushq $0x2
popq %r13
subq $0x1, %r13
jb 0x5bf0
cmpl $0x0, 0x8(%r15)
je 0x5bc7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x681c
addq $0xc, %r15
jmp 0x5baf
xorl %r15d, %r15d
cmpq $0x3c, %r15
je 0x5bf0
cmpl $0x0, (%rbp,%r15)
je 0x5bea
leaq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x681c
addq $0xc, %r15
jmp 0x5bd0
addq $0x40, %r12
movq 0x8(%rsp), %rax
cmpq 0x8(%rax), %r12
movq 0x10(%rsp), %r15
je 0x5c2a
movb (%r12), %al
movb 0x967b(%rip), %cl       # 0xf289
testb %al, %cl
jne 0x5c2a
addq $0x40, %r15
addq $0x40, %rbp
addq $0x40, %r14
testb %al, 0x9664(%rip)       # 0xf288
jne 0x5ba2
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37c8(%rip), %rdi      # 0x940b
leaq 0x367f(%rip), %rsi      # 0x92c9
leaq 0x37ec(%rip), %rcx      # 0x943d
pushq $0x58
jmp 0x5c6c
leaq 0x3820(%rip), %rdi      # 0x947c
leaq 0x3666(%rip), %rsi      # 0x92c9
leaq 0x37d3(%rip), %rcx      # 0x943d
pushq $0x59
popq %rdx
callq 0x31a0
jmp 0x5c74
movq %rax, %r14
movq %rbx, %rdi
callq 0x6840
movq %r14, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::addDomain(char const*)
DNS_DB::queryError DNS_DB::DnsBlock::addDomain(const char * domint) {
	int spot, res;
	res = lookupEmptyDomainSpot(domint, &spot);

	if (res == NO_EMPTY_SPOT) {
		// No spece between records or at the end of the block,
		// we need to do some relocs or split the chunk

		// Try to find a place again
		makeRoomMove(domint);
		res = lookupEmptyDomainSpot(domint,&spot);
		assert(res != ALREADY_EXISTS);  // We would have detected this before, obviously

		if (res == NO_EMPTY_SPOT)
			return resNoSpaceLeft;
	}
	else if (res == ALREADY_EXISTS)
		return resAlreadyExists;

	DNS_DB::DnsBlock::InternalBlock * place = &blockptr[spot];
	assert((!(place->header & DNS_DB::DnsBlock::flagUsed) && !(place->header & DNS_DB::DnsBlock::flagDomain)));

	// Insert the new register
	memset(place, 0, sizeof(InternalBlock));
	place->header = DNS_DB::DnsBlock::flagUsed | DNS_DB::DnsBlock::flagDomain;
	memcpy(place->data.domain.domain, domint, MAX_DNS_SIZE);
	bitmap->setBit(spot,true);

	#ifdef EXTRA_CHECK
	checkBM();
	#endif

	return resOK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xc(%rsp), %rdx
callq 0x5a60
cmpl $-0x2, %eax
je 0x5d5e
pushq $0x1
popq %rbx
cmpl $-0x1, %eax
jne 0x5ceb
movq %r14, %rdi
movq %r15, %rsi
callq 0x5dac
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5a60
cmpl $-0x1, %eax
je 0x5d61
cmpl $-0x2, %eax
je 0x5d8c
movq (%r14), %rax
movslq 0xc(%rsp), %rcx
movq %rcx, %rdi
shlq $0x6, %rdi
movb (%rax,%rdi), %r8b
movb 0x9584(%rip), %dl       # 0xf288
testb %r8b, %dl
jne 0x5d6d
movb 0x9579(%rip), %sil      # 0xf289
testb %r8b, %sil
jne 0x5d6d
movl %ecx, %ecx
addq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x21(%rax)
movups %xmm0, 0x11(%rax)
movups %xmm0, 0x1(%rax)
orb %dl, %sil
movb %sil, (%rax)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm0, 0x1(%rax)
movups %xmm1, 0x11(%rax)
movl 0x1f(%r15), %edx
shll %cl, %ebx
movl %edx, 0x20(%rax)
movq 0x18(%r14), %rax
movq (%rax), %rax
shrl $0x5, %ecx
orl %ebx, (%rax,%rcx,4)
xorl %ebx, %ebx
jmp 0x5d61
pushq $0x2
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x378b(%rip), %rdi      # 0x94ff
leaq 0x354e(%rip), %rsi      # 0x92c9
leaq 0x3740(%rip), %rcx      # 0x94c2
movl $0xff, %edx
callq 0x31a0
leaq 0x3719(%rip), %rdi      # 0x94ac
leaq 0x352f(%rip), %rsi      # 0x92c9
leaq 0x3721(%rip), %rcx      # 0x94c2
movl $0xf6, %edx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::replaceDomainIpv4(char const*, IPv4_Record const&, IPv4_Record const&)
bool DNS_DB::DnsBlock::replaceDomainIpv4(const char * domint, const IPv4_Record & oldrec, const IPv4_Record & newrec) {
	DNS_DB::DnsBlock::InternalBlock * ptr = lookupDomain(domint);
	if (ptr == 0)
		return false;

	do {
		if (ptr->header & DNS_DB::DnsBlock::flagDomain) {
			for (int i = 0; i < 2; i++)
				if (ptr->data.domain.records[i] == oldrec) {
					ptr->data.domain.records[i] = newrec;
					return true;
				}
		}
		else {
			for (int i = 0; i < 5; i++)
				if (ptr->data.records.records[i] == oldrec) {
					ptr->data.records.records[i] = newrec;
					return true;
				}
		}

		ptr++;
	} while ( ptr != endptr && (ptr->header & DNS_DB::DnsBlock::flagUsed) && !(ptr->header & DNS_DB::DnsBlock::flagDomain));

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r12
callq 0x59c4
testq %rax, %rax
je 0x6086
movq %rax, %r15
movq %rbx, 0x10(%rsp)
movb 0x92cd(%rip), %sil      # 0xf289
movq 0x8(%r12), %rax
movq %rax, 0x18(%rsp)
movb 0x92bc(%rip), %al       # 0xf288
movb %al, 0x6(%rsp)
movb (%r15), %cl
leaq 0x18(%r15), %rdi
leaq 0x24(%r15), %r8
leaq -0x8(%r15), %r12
movq %r15, %rbp
addq $0x4, %rbp
movb %sil, 0x7(%rsp)
movq %rdi, 0x8(%rsp)
testb %cl, %sil
movq %r8, 0x20(%rsp)
je 0x601e
movq %r8, %rdi
xorl %ebx, %ebx
addq $-0xc, %rbx
cmpq $-0x24, %rbx
je 0x6042
leaq 0xc(%rdi), %r13
movq %r14, %rsi
callq 0x60b7
movq %r13, %rdi
testb %al, %al
je 0x5fff
jmp 0x608a
movq %rbp, %rdi
xorl %ebx, %ebx
addq $-0xc, %rbx
cmpq $-0x48, %rbx
je 0x6042
leaq 0xc(%rdi), %r13
movq %r14, %rsi
callq 0x60b7
movq %r13, %rdi
testb %al, %al
je 0x6023
jmp 0x608f
addq $0x40, %r15
cmpq 0x18(%rsp), %r15
je 0x6086
movb (%r15), %cl
xorl %eax, %eax
movb 0x7(%rsp), %sil
testb %sil, %cl
jne 0x60a8
movb 0x6(%rsp), %dl
andb %cl, %dl
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x20(%rsp), %r8
addq $0x40, %r8
addq $0x40, %r12
addq $0x40, %rbp
testb %dl, %dl
jne 0x5feb
jmp 0x60a8
xorl %eax, %eax
jmp 0x60a8
movq 0x8(%rsp), %r12
subq %rbx, %r12
movq 0x10(%rsp), %rcx
movl 0x8(%rcx), %eax
movl %eax, 0x8(%r12)
movq (%rcx), %rax
movq %rax, (%r12)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::addDomainIpv4_int(char const*, IPv4_Record const&, bool)
bool DNS_DB::DnsBlock::addDomainIpv4_int(const char * domint, const IPv4_Record & iprec, bool ret) {
	DNS_DB::DnsBlock::InternalBlock * ptr = lookupDomain(domint);
	if (ptr == 0)
		return false;

	// Take a look to see whether we can make use of an existing record chain
	do {
		if (ptr->header & DNS_DB::DnsBlock::flagDomain) {
			for (int i = 0; i < 2; i++)
				if (ptr->data.domain.records[i].ip == 0) {
					ptr->data.domain.records[i] = iprec;
					return true;
				}
		}
		else {
			for (int i = 0; i < 5; i++)
				if (ptr->data.records.records[i].ip == 0) {
					ptr->data.records.records[i] = iprec;
					return true;
				}
		}

		ptr++;
	} while ( ptr != endptr && (ptr->header & DNS_DB::DnsBlock::flagUsed) && !(ptr->header & DNS_DB::DnsBlock::flagDomain));

	// We reached here, there is no block which can be reused, try to allocate
	// the next block
	if (ptr != endptr && !(ptr->header & DNS_DB::DnsBlock::flagUsed)) {
		memset(ptr, 0, sizeof(InternalBlock));
		ptr->header = DNS_DB::DnsBlock::flagUsed;
		ptr->data.records.records[0] = iprec;
		updateBM(); // FIXME do this with bit set!
		return true;
	}
	else if (ret) {
		// Try to move blocks away, only once!
		makeRoomMove(domint);
		// Try again now
		return addDomainIpv4_int(domint, iprec, false);
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $-0x8
popq %r13
pushq $0x24
popq %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x59c4
testq %rax, %rax
je 0x61b0
movb 0x9180(%rip), %sil      # 0xf289
movq 0x8(%r14), %rdi
movb 0x9175(%rip), %dl       # 0xf288
movb (%rax), %r8b
movq %rax, %rcx
testb %r8b, %sil
je 0x6145
cmpl $0x0, 0x2c(%rcx)
je 0x619f
cmpl $0x0, 0x38(%rcx)
je 0x619b
leaq 0x40(%rcx), %rax
cmpq %rdi, %rax
je 0x6164
movb (%rax), %r8b
testb %sil, %r8b
jne 0x615f
movl %edx, %r9d
andb %r8b, %r9b
jne 0x6116
jmp 0x615f
movq %r13, %r8
leaq 0xc(%r8), %rax
cmpq $0x40, %rax
je 0x612a
cmpl $0x0, 0x14(%rcx,%r8)
movq %rax, %r8
jne 0x6148
jmp 0x617c
testb %r8b, %dl
je 0x61b4
testb $0x1, %bpl
je 0x61b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5dac
xorl %ebp, %ebp
jmp 0x60ee
movl 0x8(%rbx), %edx
movl %edx, 0x8(%rcx,%rax)
movq (%rbx), %rdx
movq %rdx, (%rcx,%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %r12
movl 0x8(%rbx), %eax
movl %eax, 0x8(%rcx,%r12)
movq (%rbx), %rax
movq %rax, (%rcx,%r12)
jmp 0x618a
xorl %eax, %eax
jmp 0x618c
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rcx)
movups %xmm0, 0x61(%rcx)
movups %xmm0, 0x51(%rcx)
movups %xmm0, 0x41(%rcx)
movb %dl, 0x40(%rcx)
movq (%rbx), %rax
movq %rax, 0x44(%rcx)
movl 0x8(%rbx), %eax
movl %eax, 0x4c(%rcx)
movq %r14, %rdi
callq 0x58c6
jmp 0x618a
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::splitBlock(char const*, std::shared_ptr<DNS_DB::DnsBlock>&)
void DNS_DB::DnsBlock::splitBlock(const char * domint, DNS_DB::DnsBlockPtr & newblk) {
	int pos = -1;
	// Just split in 1/16 chunks, to minimize spill
	for (int start = 8*numBlocks/16; start >= 0; start -= numBlocks/16) {
		for (int i = start; i < numBlocks-16; i++) {
			DNS_DB::DnsBlock::InternalBlock * ptr = &blockptr[i];
			if ((ptr->header & DNS_DB::DnsBlock::flagUsed) && (ptr->header & DNS_DB::DnsBlock::flagDomain)) {
				pos = i;
				break;
			}
		}
		if (pos >= 0) break;
	}

	assert(pos >= 0 && pos < numBlocks);

	// Just memcpy the regs after and then zero the old ones
	int regs_after  = numBlocks - pos;
	
	memcpy(newblk->blockptr, &this->blockptr[pos], sizeof(InternalBlock)*regs_after);
	memset(&this->blockptr[pos], 0, sizeof(InternalBlock)*regs_after);

	this->updateBM();
	newblk->updateBM();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl 0x909a(%rip), %eax      # 0xf290
movl %eax, %ecx
shrl %ecx
andl $0xfffffff, %ecx        # imm = 0xFFFFFFF
leal -0x10(%rax), %edx
movq (%rdi), %rsi
movb 0x907b(%rip), %dil      # 0xf288
movb 0x9075(%rip), %r8b      # 0xf289
movl %eax, %r9d
shrl $0x4, %r9d
pushq $-0x1
popq %r10
testl %ecx, %ecx
js 0x6258
movl %ecx, %r11d
movq %r11, %r15
shlq $0x6, %r15
addq %rsi, %r15
cmpq %rdx, %r11
jae 0x6253
movb (%r15), %bpl
testb %bpl, %dil
je 0x6242
andb %r8b, %bpl
jne 0x624b
incq %r11
addq $0x40, %r15
jmp 0x6230
movl %r11d, %r10d
testl %r11d, %r11d
jns 0x625b
subl %r9d, %ecx
jmp 0x621f
movl %r10d, %r11d
testl %r11d, %r11d
js 0x62ac
subl %r11d, %eax
jbe 0x62ac
movq (%rbx), %rcx
movq (%rcx), %rdi
movl %r11d, %r15d
shlq $0x6, %r15
addq %r15, %rsi
movslq %eax, %r12
shlq $0x6, %r12
movq %r12, %rdx
callq 0x3200
addq (%r14), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3160
movq %r14, %rdi
callq 0x58c6
movq (%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x58c6
leaq 0x3357(%rip), %rdi      # 0x960a
leaq 0x300f(%rip), %rsi      # 0x92c9
leaq 0x3365(%rip), %rcx      # 0x9626
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::getMaxDomain(char*) const
void DNS_DB::DnsBlock::getMaxDomain(char *d) const {
	for (int i = numBlocks-1; i >= 0; i--) {
		if ((blockptr[i].header & flagUsed) && (blockptr[i].header & flagDomain)) {
			memcpy(d, blockptr[i].data.domain.domain, MAX_DNS_SIZE);
			return;
		}
	}
	assert(0 && "getMaxDomain failed");
}

// Assembly:
pushq %rax
movl 0x8fbd(%rip), %ecx      # 0xf290
movq (%rdi), %rax
movb 0x8fac(%rip), %dl       # 0xf288
movb 0x8fa6(%rip), %dil      # 0xf289
decq %rcx
testl %ecx, %ecx
js 0x6323
movl %ecx, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
shlq $0x6, %r8
movb (%rax,%r8), %r9b
decq %rcx
testb %r9b, %dl
je 0x62e6
andb %dil, %r9b
je 0x62e6
addq %r8, %rax
movl 0x20(%rax), %ecx
movl %ecx, 0x1f(%rsi)
movups 0x1(%rax), %xmm0
movups 0x11(%rax), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
popq %rax
retq
leaq 0x3343(%rip), %rdi      # 0x966d
leaq 0x2f98(%rip), %rsi      # 0x92c9
leaq 0x3350(%rip), %rcx      # 0x9688
movl $0x1bf, %edx            # imm = 0x1BF
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::getMinDomain(char*) const
void DNS_DB::DnsBlock::getMinDomain(char *d) const {
	for (int i = 0; i < numBlocks; i++) {
		if ((blockptr[i].header & flagUsed) && (blockptr[i].header & flagDomain)) {
			memcpy(d, blockptr[i].data.domain.domain, MAX_DNS_SIZE);
			return;
		}
	}
	assert(0 && "getMinDomain failed");
}

// Assembly:
pushq %rax
movl 0x8f47(%rip), %ecx      # 0xf290
movq (%rdi), %rax
movb 0x8f36(%rip), %dl       # 0xf288
movb 0x8f30(%rip), %dil      # 0xf289
shlq $0x6, %rcx
addq $0x40, %rcx
xorl %r9d, %r9d
leaq 0x40(%r9), %r8
cmpq %r8, %rcx
je 0x639e
movb (%rax,%r9), %r10b
movq %r8, %r9
testb %r10b, %dl
je 0x6364
movq %r8, %r9
andb %dil, %r10b
je 0x6364
movl -0x20(%rax,%r8), %ecx
movl %ecx, 0x1f(%rsi)
movups -0x3f(%rax,%r8), %xmm0
movups -0x2f(%rax,%r8), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
popq %rax
retq
leaq 0x3315(%rip), %rdi      # 0x96ba
leaq 0x2f1d(%rip), %rsi      # 0x92c9
leaq 0x3322(%rip), %rcx      # 0x96d5
movl $0x1c8, %edx            # imm = 0x1C8
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::check() const
void DNS_DB::DnsBlock::check() const {
	char prev[MAX_DNS_SIZE] = {0};
	bool last_empty = true; // Cannot start with IP record
	for (int i = 0; i < numBlocks; i++) {
		// Make sure all domains are in order
		if ((blockptr[i].header & flagUsed) && (blockptr[i].header & flagDomain)) {
			if (!less(prev, blockptr[i].data.domain.domain)) {
				fprintf(stderr, "Error in block %d, unsorted record!\n", blockid);
				memcpy(prev, blockptr[i].data.domain.domain, MAX_DNS_SIZE);
			}
		}
		// Make sure there is no gap between a Domain and IP records
		if ((blockptr[i].header & flagUsed) && !(blockptr[i].header & flagDomain)) {
			if (last_empty) {
				fprintf(stderr, "Error in block %d, hole found!\n", blockid);
			}
		}
		last_empty = ((blockptr[i].header & flagUsed) == 0);
	}

	
	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, 0x10(%rax)
andl $0x0, 0x1f(%rax)
movaps %xmm0, (%rax)
movb $0x1, %r13b
pushq $0x1
popq %rbp
xorl %r15d, %r15d
movl 0x8ea1(%rip), %eax      # 0xf290
cmpq %rax, %r15
jae 0x64c4
movq (%rbx), %rsi
movb -0x1(%rsi,%rbp), %r14b
movb $0x1, %r12b
testb %r14b, 0x8e7e(%rip)     # 0xf288
je 0x643b
testb %r14b, 0x8e76(%rip)     # 0xf289
je 0x6427
addq %rbp, %rsi
movq %rsp, %rdi
pushq $0x23
popq %rdx
callq 0x3120
testl %eax, %eax
jns 0x6475
testb %r14b, 0x8e5b(%rip)     # 0xf289
sete %al
andb %r13b, %al
cmpb $0x1, %al
je 0x6447
xorl %r12d, %r12d
incq %r15
addq $0x40, %rbp
movl %r12d, %r13d
jmp 0x63e9
movq 0x8b82(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movl 0x10(%rbx), %edx
leaq 0x32d1(%rip), %rsi      # 0x972c
xorl %eax, %eax
callq 0x3350
movq (%rbx), %rax
movb 0x8e1d(%rip), %cl       # 0xf288
testb %cl, -0x1(%rax,%rbp)
sete %r12b
jmp 0x643b
movq 0x8b54(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movl 0x10(%rbx), %edx
leaq 0x327e(%rip), %rsi      # 0x9707
xorl %eax, %eax
callq 0x3350
movq (%rbx), %rax
movl 0x1f(%rax,%rbp), %ecx
movl %ecx, 0x1f(%rsp)
movups (%rax,%rbp), %xmm0
movups 0x10(%rax,%rbp), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movb -0x1(%rax,%rbp), %r14b
testb %r14b, 0x8dcf(%rip)     # 0xf288
jne 0x6427
jmp 0x643b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::Iterator::Iterator(int, char const*, DNS_DB*)
DNS_DB::DnsBlock::Iterator::Iterator (int blkid, const char * domint, DNS_DB * dbref) : block_id(blkid), db(dbref) {
	DnsBlockPtr block = db->getBlock(blkid);

	if (domint) {
		int r = block->lookupEmptyDomainSpot(domint, &p);
		assert(r == ALREADY_EXISTS);
	}
	else
		p = 0;

	while (&block->blockptr[p] != block->endptr && 
		!( (block->blockptr[p].header & flagDomain) && (block->blockptr[p].header & flagUsed)) ) {

		p++;
	}

	assert(p >= 0 && p < numBlocks);
	assert(block->blockptr[p].header & flagDomain);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movl %esi, %edx
movq %rdi, %rbx
movl %esi, 0x4(%rdi)
movq %rcx, 0x8(%rdi)
movq %rsp, %rdi
movq %rcx, %rsi
callq 0x7510
testq %r15, %r15
je 0x651c
movq (%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5a60
cmpl $-0x2, %eax
jne 0x65c0
movslq (%rbx), %rax
jmp 0x6525
andl $0x0, (%rbx)
xorl %eax, %eax
movq (%rsp), %r14
movq 0x8(%r14), %rsi
movb 0x8d5a(%rip), %cl       # 0xf289
movb 0x8d52(%rip), %dil      # 0xf288
movq %rax, %rdx
shlq $0x6, %rdx
addq (%r14), %rdx
cmpq %rsi, %rdx
je 0x655d
movb (%rdx), %r8b
testb %r8b, %cl
je 0x6552
andb %dil, %r8b
jne 0x655d
incq %rax
movl %eax, (%rbx)
addq $0x40, %rdx
jmp 0x6540
testq %rax, %rax
js 0x6582
cmpl %eax, 0x8d28(%rip)      # 0xf290
jbe 0x6582
testb %cl, (%rdx)
je 0x65a1
leaq 0x8(%rsp), %rdi
callq 0x3f74
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3219(%rip), %rdi      # 0x97a2
leaq 0x2d39(%rip), %rsi      # 0x92c9
leaq 0x31c9(%rip), %rcx      # 0x9760
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x31a0
leaq 0x3212(%rip), %rdi      # 0x97ba
leaq 0x2d1a(%rip), %rsi      # 0x92c9
leaq 0x31aa(%rip), %rcx      # 0x9760
movl $0x1f9, %edx            # imm = 0x1F9
callq 0x31a0
leaq 0x3185(%rip), %rdi      # 0x974c
leaq 0x2cfb(%rip), %rsi      # 0x92c9
leaq 0x318b(%rip), %rcx      # 0x9760
movl $0x1ed, %edx            # imm = 0x1ED
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidgfnet[P]dns-db/dns_block.cc
// Function: DNS_DB::DnsBlock::Iterator::next()
void DNS_DB::DnsBlock::Iterator::next() {
	DnsBlockPtr block = db->getBlock(block_id);
	do {
		p++;
	} while (&block->blockptr[p] != block->endptr && 
		!( (block->blockptr[p].header & flagDomain) && (block->blockptr[p].header & flagUsed) ));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movl 0x4(%rdi), %edx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7510
movq (%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rax
movslq (%rbx), %rdi
movb 0x8c78(%rip), %cl       # 0xf289
movb 0x8c71(%rip), %dl       # 0xf288
leal 0x1(%rdi), %r8d
shlq $0x6, %rdi
addq %rdi, %rsi
addq $0x40, %rsi
movl %r8d, %edi
cmpq %rax, %rsi
je 0x6643
movb (%rsi), %r9b
leal 0x1(%rdi), %r8d
addq $0x40, %rsi
testb %r9b, %cl
je 0x6626
andb %dl, %r9b
je 0x6626
movl %edi, (%rbx)
leaq 0x10(%rsp), %rdi
callq 0x3f74
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop