LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_dropWhile()
auto test_dropWhile() -> void {
  using Prelude::dropWhile;
  auto expect = std::vector<int>{5, 6, 7, 8};
  auto result = dropWhile([](int x) { return x < 5; },
                          std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8});
  assert(result == expect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x5, -0x38(%rbp)
movl $0x6, -0x34(%rbp)
movl $0x7, -0x30(%rbp)
movl $0x8, -0x2c(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x4, -0x20(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xa900
movq -0xd0(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa920
jmp 0x63d1
leaq -0x39(%rbp), %rdi
callq 0xaa00
movups 0x17dc3(%rip), %xmm0    # 0x1e1a4
movaps %xmm0, -0xb0(%rbp)
movups 0x17da5(%rip), %xmm0    # 0x1e194
movaps %xmm0, -0xc0(%rbp)
leaq -0xc0(%rbp), %rax
movq %rax, -0x98(%rbp)
movq $0x8, -0x90(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xa900
movq -0xd8(%rbp), %rcx
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0xa920
jmp 0x6445
leaq -0x68(%rbp), %rdi
leaq -0x69(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x6550
jmp 0x645b
leaq -0x88(%rbp), %rdi
callq 0xa9a0
leaq -0xc1(%rbp), %rdi
callq 0xaa00
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0xd9(%rbp)
jmp 0x6488
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x6494
jmp 0x6499
jmp 0x651a
leaq 0x17e0c(%rip), %rdi     # 0x1e2ac
leaq 0x17dd4(%rip), %rsi     # 0x1e27b
movl $0xff, %edx
leaq 0x1833b(%rip), %rcx     # 0x1e7ee
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xaa00
jmp 0x653e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x64f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xa9a0
leaq -0xc1(%rbp), %rdi
callq 0xaa00
jmp 0x6535
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa9a0
jmp 0x6535
leaq -0x68(%rbp), %rdi
callq 0xa9a0
leaq -0x18(%rbp), %rdi
callq 0xa9a0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xa9a0
movq -0x48(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: kdungs[P]cpp-prelude/test_prelude.cc
// Function: test_zipWith()
auto test_zipWith() -> void {
  using Prelude::zipWith;
  auto expect = std::vector<int>{1, 0, 3, 0, 5, 0};
  auto result = zipWith([](int x, bool y) { return y ? x : 0; },
                        std::vector<int>{1, 2, 3, 4, 5, 6},
                        std::list<bool>{true, false, true, false, true, false});
  assert(result == expect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movups 0x16cb2(%rip), %xmm0    # 0x1e1f4
movaps %xmm0, -0x40(%rbp)
movq $0x5, -0x30(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x6, -0x20(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0xa900
movq -0x100(%rbp), %rcx
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa920
jmp 0x7588
leaq -0x41(%rbp), %rdi
callq 0xaa00
movabsq $0x600000005, %rax      # imm = 0x600000005
movq %rax, -0xb0(%rbp)
movups 0x16c63(%rip), %xmm0    # 0x1e20c
movaps %xmm0, -0xc0(%rbp)
leaq -0xc0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x6, -0x98(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xa900
movq -0x108(%rbp), %rcx
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0xa920
jmp 0x75ff
movb $0x1, -0xf6(%rbp)
movb $0x0, -0xf5(%rbp)
movb $0x1, -0xf4(%rbp)
movb $0x0, -0xf3(%rbp)
movb $0x1, -0xf2(%rbp)
movb $0x0, -0xf1(%rbp)
leaq -0xf6(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq $0x6, -0xe8(%rbp)
leaq -0xf7(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0xa840
movq -0x110(%rbp), %rcx
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
leaq -0xe0(%rbp), %rdi
callq 0xba90
jmp 0x7678
leaq -0x70(%rbp), %rdi
leaq -0x71(%rbp), %rsi
leaq -0x90(%rbp), %rdx
leaq -0xe0(%rbp), %rcx
callq 0x77d0
jmp 0x7695
leaq -0xe0(%rbp), %rdi
callq 0xbb40
leaq -0xf7(%rbp), %rdi
callq 0xa8e0
leaq -0x90(%rbp), %rdi
callq 0xa9a0
leaq -0xc1(%rbp), %rdi
callq 0xaa00
leaq -0x70(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xabe0
movb %al, -0x111(%rbp)
jmp 0x76da
movb -0x111(%rbp), %al
testb $0x1, %al
jne 0x76e6
jmp 0x76eb
jmp 0x7795
leaq 0x16bba(%rip), %rdi     # 0x1e2ac
leaq 0x16b82(%rip), %rsi     # 0x1e27b
movl $0x133, %edx            # imm = 0x133
leaq 0x17144(%rip), %rcx     # 0x1e849
callq 0x2110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0xaa00
jmp 0x77b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7770
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7758
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0xbb40
leaq -0xf7(%rbp), %rdi
callq 0xa8e0
leaq -0x90(%rbp), %rdi
callq 0xa9a0
leaq -0xc1(%rbp), %rdi
callq 0xaa00
jmp 0x77b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa9a0
jmp 0x77b0
leaq -0x70(%rbp), %rdi
callq 0xa9a0
leaq -0x18(%rbp), %rdi
callq 0xa9a0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xa9a0
movq -0x50(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: kdungs[P]cpp-prelude/./prelude.h
// Function: std::vector<int, std::allocator<int>> Prelude::zipWith<test_zipWith()::$_0, std::vector, int, std::allocator<int>, std::__cxx11::list, bool, std::allocator<bool>, std::vector, int, std::allocator<int>>(test_zipWith()::$_0 const&, std::vector<int, std::allocator<int>> const&, std::__cxx11::list<bool, std::allocator<bool>> const&)
auto zipWith(const FN& f, const CA<A, AllocA>& left, const CB<B, AllocB>& right)
    -> CC<C, AllocC> {
  auto res = CC<C, AllocC>{};
  auto l = std::begin(left);
  auto r = std::begin(right);
  while (l != std::end(left) && r != std::end(right)) {
    res.emplace_back(f(*l, *r));
    ++l;
    ++r;
  }
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20d0
movq -0x68(%rbp), %rdi
callq 0xaf60
movq -0x18(%rbp), %rdi
callq 0xf330
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x16df0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf360
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xf3c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x71(%rbp)
jne 0x7851
jmp 0x786e
movq -0x20(%rbp), %rdi
callq 0x16e50
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x16e20
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x7877
jmp 0x78f6
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf400
movl (%rax), %eax
movl %eax, -0x7c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x16f00
movq -0x88(%rbp), %rdi
movl -0x7c(%rbp), %esi
movzbl (%rax), %edx
andl $0x1, %edx
callq 0xa660
movl %eax, -0x78(%rbp)
jmp 0x78b3
movq -0x68(%rbp), %rdi
movl -0x78(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x19b90
jmp 0x78c8
leaq -0x30(%rbp), %rdi
callq 0xf470
leaq -0x38(%rbp), %rdi
callq 0x16f30
jmp 0x7829
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0xa9a0
jmp 0x7916
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x7909
movq -0x68(%rbp), %rdi
callq 0xa9a0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x22b0
nop
// File: kdungs[P]cpp-prelude/test_prelude.cc
// Function: main
int main() {
  test_not_();
  // List operations
  test_map();
  test_join();
  test_filter();
  test_head();
  test_last();
  test_tail();
  test_init();
  test_null();
  test_at();
  test_reverse();
  // Reducing lists (folds)
  test_foldl();
  test_foldl1();
  test_foldr();
  test_foldr1();
  // Special folds
  test_and_();
  test_or_();
  test_any();
  test_all();
  test_sum();
  test_product();
  test_concat();
  test_concatMap();
  test_maximum();
  test_minimum();
  // Sublists
  test_take();
  test_drop();
  test_splitAt();
  test_takeWhile();
  test_dropWhile();
  test_span();
  test_break_();
  // Zipping and unzipping lists
  test_zip();
  test_zip3();
  test_zipWith();
  test_zipWith3();
  test_unzip();
  test_unzip3();

  std::cout << "Looking good!\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2430
callq 0x25c0
callq 0x2880
callq 0x2af0
callq 0x2d90
callq 0x2e80
callq 0x2f70
callq 0x3140
callq 0x3310
callq 0x35d0
callq 0x36c0
callq 0x3890
callq 0x39e0
callq 0x3b80
callq 0x3d50
callq 0x3f70
callq 0x4150
callq 0x4330
callq 0x45b0
callq 0x4830
callq 0x4920
callq 0x4a10
callq 0x4dc0
callq 0x5020
callq 0x5110
callq 0x5200
callq 0x5480
callq 0x5810
callq 0x60e0
callq 0x6370
callq 0x6600
callq 0x6ad0
callq 0x6ed0
callq 0x71a0
callq 0x7530
callq 0x7920
callq 0x80e0
callq 0x8480
movq 0x265bf(%rip), %rdi     # 0x2efd8
leaq 0x15e94(%rip), %rsi     # 0x1e8b4
callq 0x21a0
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20d0
movq -0x88(%rbp), %rdi
callq 0xaf60
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14cd0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14d00
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14d30
testb $0x1, %al
jne 0x14ba8
jmp 0x14c68
leaq -0x28(%rbp), %rdi
callq 0x14d60
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x11020
jmp 0x14bbf
movq -0x88(%rbp), %rdi
callq 0x111c0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x111f0
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xf330
movq -0xa0(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0xf360
movq -0x88(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
callq 0x11110
movq %rax, -0x98(%rbp)
jmp 0x14c21
movq -0x98(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa9a0
leaq -0x28(%rbp), %rdi
callq 0x14d90
jmp 0x14b92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x14c8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa9a0
jmp 0x14c8e
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x14c7e
movq -0x88(%rbp), %rdi
callq 0xa9a0
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0xa9a0
movq -0x50(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x16dd0
movq -0x10(%rbp), %rdi
callq 0xf330
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16df0
movq %rax, -0x58(%rbp)
jmp 0xb9a5
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf360
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xf3c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x69(%rbp)
jne 0xb9d5
jmp 0xb9fc
movq -0x18(%rbp), %rdi
callq 0x16e50
movq %rax, -0x78(%rbp)
jmp 0xb9e4
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x16e20
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xba05
jmp 0xba5b
leaq -0x28(%rbp), %rdi
callq 0xf400
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x16f00
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
callq 0x16e80
jmp 0xba2d
leaq -0x28(%rbp), %rdi
callq 0xf470
leaq -0x30(%rbp), %rdi
callq 0x16f30
jmp 0xb9ad
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xbbe0
jmp 0xba7b
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xba6e
movq -0x68(%rbp), %rdi
callq 0xbbe0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x18b80
movq -0x10(%rbp), %rdi
callq 0xf330
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16df0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x18ba0
movq %rax, -0x70(%rbp)
jmp 0xbda6
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf360
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xf3c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x81(%rbp)
jne 0xbdd9
jmp 0xbe34
movq -0x18(%rbp), %rdi
callq 0x16e50
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x16e20
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x81(%rbp)
jne 0xbe04
jmp 0xbe34
movq -0x20(%rbp), %rdi
callq 0x18c10
movq %rax, -0x90(%rbp)
jmp 0xbe16
movq -0x90(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x18bd0
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0xbe40
jmp 0xbebc
leaq -0x30(%rbp), %rdi
callq 0xf400
movq %rax, -0xa0(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x16f00
movq %rax, -0x98(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x18cd0
movq -0x80(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq %rax, %rcx
callq 0x18c40
jmp 0xbe85
leaq -0x30(%rbp), %rdi
callq 0xf470
leaq -0x38(%rbp), %rdi
callq 0x16f30
leaq -0x40(%rbp), %rdi
callq 0x18cf0
jmp 0xbdae
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xc050
jmp 0xbedc
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xbecf
movq -0x80(%rbp), %rdi
callq 0xc050
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20d0
leaq -0x28(%rbp), %rdi
callq 0xaf60
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20d0
leaq -0x50(%rbp), %rdi
callq 0xc3d0
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x17920
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x17950
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1b9c0
testb $0x1, %al
jne 0xc47b
jmp 0xc4e6
leaq -0x60(%rbp), %rdi
callq 0x1ba00
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x17b40
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x12a20
jmp 0xc49f
movq -0x70(%rbp), %rdi
callq 0x17c10
movzbl (%rax), %esi
andl $0x1, %esi
leaq -0x50(%rbp), %rdi
callq 0xf4b0
jmp 0xc4b9
jmp 0xc4bb
leaq -0x60(%rbp), %rdi
callq 0x1ba20
jmp 0xc468
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xaae0
leaq -0x28(%rbp), %rdi
callq 0xa9a0
jmp 0xc51e
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x1ba40
jmp 0xc4fc
leaq -0x50(%rbp), %rdi
callq 0xaae0
leaq -0x28(%rbp), %rdi
callq 0xa9a0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20d0
leaq -0x28(%rbp), %rdi
callq 0xaf60
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20d0
leaq -0x40(%rbp), %rdi
callq 0xc5d0
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x20d0
leaq -0x68(%rbp), %rdi
callq 0xc3d0
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1c770
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1c7a0
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c7d0
testb $0x1, %al
jne 0xc697
jmp 0xc737
leaq -0x78(%rbp), %rdi
callq 0x1c810
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x1c830
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x12a20
jmp 0xc6c1
movq -0x88(%rbp), %rdi
callq 0x1c8c0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1c850
jmp 0xc6db
movq -0x88(%rbp), %rdi
callq 0x1c8e0
movzbl (%rax), %esi
andl $0x1, %esi
leaq -0x68(%rbp), %rdi
callq 0xf4b0
jmp 0xc6f8
jmp 0xc6fa
leaq -0x78(%rbp), %rdi
callq 0x1c900
jmp 0xc681
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xaae0
leaq -0x40(%rbp), %rdi
callq 0xbf70
leaq -0x28(%rbp), %rdi
callq 0xa9a0
jmp 0xc77c
movq -0xa8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x68(%rbp), %rcx
callq 0x1c920
jmp 0xc751
leaq -0x68(%rbp), %rdi
callq 0xaae0
leaq -0x40(%rbp), %rdi
callq 0xbf70
leaq -0x28(%rbp), %rdi
callq 0xa9a0
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x43c0
movl -0x10(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x79(%rbp)
jg 0x4a08
cmpl $0x0, -0xc(%rbp)
seta %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x4a14
jmp 0x4aa7
movl -0xc(%rbp), %eax
movl %eax, %esi
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x23, %rax
movl %eax, %ecx
addl %ecx, %ecx
movl %ecx, %eax
leal (%rax,%rax,4), %eax
subl %eax, %esi
leaq -0x58(%rbp), %rdi
callq 0x5510
jmp 0x4a3c
movq -0x78(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x54c0
jmp 0x4a4f
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4340
leaq -0x38(%rbp), %rdi
callq 0x41c0
leaq -0x58(%rbp), %rdi
callq 0x41c0
movl -0xc(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0xc(%rbp)
jmp 0x49e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4ac7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x41c0
jmp 0x4ac7
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4aba
movq -0x78(%rbp), %rdi
callq 0x41c0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x41c0
movq -0x60(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
movq %rcx, -0x40(%rbp)
movq 0x30(%rax), %rdi
addq $0x88, %rdi
callq 0x56a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x5320
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x88, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x56c0
movq -0x38(%rbp), %rcx
cmpq %rcx, (%rax)
jne 0x5310
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x88, %rdi
movq %rdi, -0x50(%rbp)
callq 0x57b0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x57e0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5820
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5740
movq %rax, -0x48(%rbp)
jmp 0x5306
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x5320
jmp 0x5312
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x526b
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x54b0
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x8530
subq $0x1, %rax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x74e0
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
sarl %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x8560
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x23, %edx
callq 0x4150
cmpl $0x0, %eax
jg 0x74ae
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x23, %rsi
movl $0x23, %edx
callq 0x4150
cmpl $0x0, %eax
jge 0x74ae
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x23, %edx
callq 0x4150
cmpl $0x0, %eax
jg 0x74d0
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x74d9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x74db
jmp 0x744b
leaq 0xbc12(%rip), %rdi      # 0x130f9
leaq 0xbc2c(%rip), %rsi      # 0x1311a
movl $0x1c, %edx
leaq 0xbc2d(%rip), %rcx      # 0x13127
callq 0x41e0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0x8580
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rdi)
movl $0x0, -0x1a(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movl $0x0, -0x41(%rbp)
pcmpeqd %xmm0, %xmm0
movups %xmm0, -0x2d(%rbp)
movups %xmm0, -0x3d(%rbp)
movl $0xffffffff, -0x1e(%rbp) # imm = 0xFFFFFFFF
leaq -0x60(%rbp), %rsi
callq 0x85a0
jmp 0x756a
movq -0x80(%rbp), %rax
movl $0x1, 0x20(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x5a30
movq -0x68(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4100
movq %rax, %rdi
leaq 0xbb8a(%rip), %rsi      # 0x1315c
callq 0x4310
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x8530
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x4590
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x38(%rbp)
callq 0x8530
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x7650
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x8610
movq %rax, %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x4a, %edx
callq 0x4590
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7605
movq -0x18(%rbp), %rdi
callq 0x42b0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x5640
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xde30
testb $0x1, %al
jne 0x76aa
movq 0x1493c(%rip), %rax     # 0x1bfd0
movq (%rax), %rdi
leaq 0xbac1(%rip), %rsi      # 0x1315f
movb $0x0, %al
callq 0x43f0
jmp 0x77ae
movq -0x48(%rbp), %rdi
callq 0x8630
callq 0x5640
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xd900
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x7720
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x85a0
movq -0x28(%rbp), %rax
addq $0x4a, %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x76ec
callq 0x5640
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xdc00
movq -0x48(%rbp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, -0x3c(%rbp)
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %eax
movq %rax, -0x50(%rbp)
callq 0x8530
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x77a1
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x8610
movq -0x48(%rbp), %rcx
movl 0x46(%rax), %eax
cmpl 0x20(%rcx), %eax
jbe 0x7794
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x8610
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl 0x46(%rcx), %ecx
movl %ecx, 0x20(%rax)
jmp 0x7796
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7743
movq -0x48(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7a11
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7420
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
movq 0x18(%rsi), %r8
callq 0x86a0
jmp 0x7a28
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq 0x18(%rsi), %r8
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x86a0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xd720
testb $0x1, %al
jne 0x7a8e
movq 0x14555(%rip), %rax     # 0x1bfd0
movq (%rax), %rdi
leaq 0xb710(%rip), %rsi      # 0x13195
movb $0x0, %al
callq 0x43f0
jmp 0x7b05
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %rsi, -0x88(%rbp)
callq 0x7420
movq -0x80(%rbp), %rdi
movl %eax, -0x54(%rbp)
movq 0x18(%rdi), %rax
movq %rax, -0x98(%rbp)
movslq -0x54(%rbp), %rsi
callq 0x8610
movq -0x98(%rbp), %rsi
movl 0x46(%rax), %edx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x8650
movq -0x90(%rbp), %rdi
callq 0x8680
movq -0x88(%rbp), %rsi
movq %rax, %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xb600
jmp 0x7afc
leaq -0x68(%rbp), %rdi
callq 0x5f20
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5f20
movq -0x70(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x6a(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x23, %edx
callq 0x4250
leaq -0x6a(%rbp), %rdi
addq $0x23, %rdi
movq -0x20(%rbp), %rsi
movl $0x23, %edx
callq 0x4250
movq -0x90(%rbp), %rdi
leaq -0x6a(%rbp), %rsi
callq 0x85a0
movq -0x90(%rbp), %rdi
callq 0x87e0
movq -0x90(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x8810
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
leaq 0x97e(%rip), %rdx       # 0x8840
callq 0x8790
movl $0x0, -0x84(%rbp)
movq -0x90(%rbp), %rdi
movl -0x84(%rbp), %eax
movq %rax, -0x98(%rbp)
callq 0x8530
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x7f37
movq -0x90(%rbp), %rdi
movl -0x84(%rbp), %eax
movl %eax, %esi
callq 0x8610
movl 0x46(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x7f24
movl -0x84(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
jmp 0x7f26
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x7ed1
leaq 0xb303(%rip), %rdi      # 0x13241
leaq 0xb1d5(%rip), %rsi      # 0x1311a
movl $0x100, %edx            # imm = 0x100
leaq 0xb311(%rip), %rcx      # 0x13262
callq 0x41e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd720
testb $0x1, %al
jne 0x8015
movb $0x0, -0x1(%rbp)
jmp 0x80a2
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0x80(%rbp)
callq 0x7420
movq -0x70(%rbp), %rdi
movl %eax, -0x44(%rbp)
movq 0x18(%rdi), %rax
movq %rax, -0x90(%rbp)
movslq -0x44(%rbp), %rsi
callq 0x8610
movq -0x90(%rbp), %rsi
movl 0x46(%rax), %edx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x8650
movq -0x88(%rbp), %rdi
callq 0x8680
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0xb150
movb %al, -0x71(%rbp)
jmp 0x8078
movb -0x71(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5f20
jmp 0x80a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5f20
jmp 0x80b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x44f0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x48(%rbp)
callq 0x8530
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x843f
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8610
movq -0x40(%rbp), %rsi
movl 0x46(%rax), %edx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8870
movq -0x58(%rbp), %rdi
callq 0x8680
movq %rax, %rdi
callq 0x88c0
movl %eax, -0x4c(%rbp)
jmp 0x8407
movl -0x4c(%rbp), %eax
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5f20
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x83b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5f20
jmp 0x8449
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x48(%rbp)
callq 0x8530
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x850f
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8610
movq -0x40(%rbp), %rsi
movl 0x46(%rax), %edx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8870
movq -0x58(%rbp), %rdi
callq 0x8680
movq %rax, %rdi
callq 0x88f0
movl %eax, -0x4c(%rbp)
jmp 0x84d7
movl -0x4c(%rbp), %eax
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5f20
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8483
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5f20
jmp 0x8519
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0xc540
callq 0x5640
movq %rax, -0x38(%rbp)
jmp 0xa9f6
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xde30
movb %al, -0x49(%rbp)
jmp 0xaa08
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xaa44
jmp 0xaa11
callq 0x5640
movq %rax, -0x58(%rbp)
jmp 0xaa1c
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl 0x118e2(%rip), %edx     # 0x1c30c
callq 0xde90
jmp 0xaa31
jmp 0xaa44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xaaf0
callq 0x5640
movq %rax, -0x60(%rbp)
jmp 0xaa4f
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd900
movq %rax, -0x68(%rbp)
jmp 0xaa62
movq -0x48(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movl 0x11892(%rip), %edx     # 0x1c310
shlq $0x6, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
addq $0x18, %rax
movq %rax, -0x78(%rbp)
movl $0x18, %edi
callq 0x42c0
movq %rax, -0x70(%rbp)
jmp 0xaaa7
movq -0x70(%rbp), %rdi
movl 0x1185f(%rip), %esi     # 0x1c310
callq 0xf0a0
jmp 0xaab8
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0xc560
jmp 0xaac7
movq -0x48(%rbp), %rdi
callq 0xab10
jmp 0xaad2
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4290
movq -0x40(%rbp), %rdi
callq 0xc5b0
movq -0x20(%rbp), %rdi
callq 0x44f0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0xadc0
movl %eax, -0x20(%rbp)
cmpl $-0x2, -0x20(%rbp)
jne 0xad0f
cmpl $0x0, -0x1c(%rbp)
jl 0xad0f
movl -0x1c(%rbp), %eax
cmpl 0x11603(%rip), %eax     # 0x1c310
jb 0xad1c
movq $0x0, -0x8(%rbp)
jmp 0xadac
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movzbl 0x115c9(%rip), %ecx     # 0x1c309
andl %ecx, %eax
cmpl $0x0, %eax
je 0xad49
jmp 0xad68
leaq 0x8613(%rip), %rdi      # 0x13363
leaq 0x8572(%rip), %rsi      # 0x132c9
movl $0x4b, %edx
leaq 0x8619(%rip), %rcx      # 0x1337c
callq 0x41e0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
movl $0x23, %edx
callq 0x4130
cmpl $0x0, %eax
jne 0xad85
jmp 0xada4
leaq 0x8644(%rip), %rdi      # 0x133d0
leaq 0x8536(%rip), %rsi      # 0x132c9
movl $0x4c, %edx
leaq 0x85dd(%rip), %rcx      # 0x1337c
callq 0x41e0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0xadc0
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0xb20a
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb300
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0xadc0
movl %eax, -0x20(%rbp)
cmpl $-0x2, -0x20(%rbp)
je 0xb1d7
jmp 0xb1f6
leaq 0x82ce(%rip), %rdi      # 0x134ac
leaq 0x80e4(%rip), %rsi      # 0x132c9
movl $0xf6, %edx
leaq 0x82d1(%rip), %rcx      # 0x134c2
callq 0x41e0
cmpl $-0x1, -0x20(%rbp)
jne 0xb208
movl $0x1, -0x4(%rbp)
jmp 0xb2f5
jmp 0xb21e
cmpl $-0x2, -0x20(%rbp)
jne 0xb21c
movl $0x2, -0x4(%rbp)
jmp 0xb2f5
jmp 0xb21e
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %ecx
movzbl 0x110c6(%rip), %eax     # 0x1c308
andl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
jne 0xb269
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movzbl 0x110ad(%rip), %ecx     # 0x1c309
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xb272
jmp 0xb274
jmp 0xb293
leaq 0x8284(%rip), %rdi      # 0x134ff
leaq 0x8047(%rip), %rsi      # 0x132c9
movl $0xff, %edx
leaq 0x8234(%rip), %rcx      # 0x134c2
callq 0x41e0
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x4180
movzbl 0x1105e(%rip), %eax     # 0x1c308
movzbl 0x11058(%rip), %ecx     # 0x1c309
orl %ecx, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
movl $0x23, %edx
callq 0x4250
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x8a20
movq %rax, %rdi
movl -0x1c(%rbp), %esi
movl $0x1, %edx
callq 0xc5d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop