LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: henrixh[P]shittydsa/examples/../src/fft.h
// Function: bitreversecopy(std::vector<std::complex<double>, std::allocator<std::complex<double>>>&)
vc bitreversecopy(vc& xs) {
  vc res;
  ul size = xs.size();
  ul lb_size = (ul)lb(size);
  res.assign(size, {});
  for (ul i { 0 }; i < size; i++) {
    ul index = (bitreverse(i) >> (sizeof(ul)*8 - lb_size + 1));
    cd r { xs[i] };
    res[index] = r;
  }
  return res;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x24b0
movq 0x68(%rsp), %rdi
callq 0x2430
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %edi
callq 0x24c0
movl %eax, 0x1c(%rsp)
jmp 0x13e2
movl 0x1c(%rsp), %eax
movl %eax, 0x5c(%rsp)
movl 0x60(%rsp), %eax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x2480
jmp 0x1404
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x24f0
jmp 0x1419
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x60(%rsp), %eax
jae 0x14b9
movl 0x34(%rsp), %edi
callq 0x1310
movl 0x5c(%rsp), %ecx
movl %ecx, %edx
movl $0x20, %ecx
subq %rdx, %rcx
addq $0x1, %rcx
shrl %cl, %eax
movl %eax, 0x30(%rsp)
movq 0x68(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, %esi
callq 0x2520
movq 0x8(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0x2520
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1421
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x2540
jmp 0x14d9
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x14cf
movq 0x8(%rsp), %rdi
callq 0x2540
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x1150
nopw %cs:(%rax,%rax)
// File: henrixh[P]shittydsa/examples/fft.cpp
// Function: main
int main(int, char**) {
  ul len_a, len_b;
  cin >> len_a >> len_b;
  vd a,b;

  fp x;
  for (ul i { 0 }; i < len_a; ++i) {
    cin >> x;
    a.push_back(x);
  }

  for (ul i { 0 }; i < len_b; ++i) {
    cin >> x;
    b.push_back(x);
  }

  vd r { convolve(a,b) };
  r.resize(len_a+len_b);
  for (auto x : r) {
    cout << round(x) << '\n';
  }

}

// Assembly:
subq $0xa8, %rsp
movl $0x0, 0xa4(%rsp)
movl %edi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x6df8(%rip), %rdi      # 0x8fe0
leaq 0x94(%rsp), %rsi
callq 0x1030
movq %rax, %rdi
leaq 0x90(%rsp), %rsi
callq 0x1030
leaq 0x78(%rsp), %rdi
callq 0x2ae0
leaq 0x60(%rsp), %rdi
callq 0x2ae0
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x94(%rsp), %eax
jae 0x2274
movq 0x6dab(%rip), %rdi      # 0x8fe0
leaq 0x58(%rsp), %rsi
callq 0x10b0
jmp 0x2241
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2ca0
jmp 0x2252
jmp 0x2254
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x2221
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x23c3
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x90(%rsp), %eax
jae 0x22bc
movq 0x6d50(%rip), %rdi      # 0x8fe0
leaq 0x58(%rsp), %rsi
callq 0x10b0
jmp 0x229c
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2ca0
jmp 0x22ad
jmp 0x22af
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x227c
leaq 0x28(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x1b00
jmp 0x22d2
movl 0x94(%rsp), %eax
movl 0x90(%rsp), %ecx
addl %ecx, %eax
movl %eax, %esi
leaq 0x28(%rsp), %rdi
callq 0x2d10
jmp 0x22f0
leaq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2a10
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2a40
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2a70
testb $0x1, %al
jne 0x232d
jmp 0x2396
leaq 0x18(%rsp), %rdi
callq 0x2ab0
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x1080
movq 0x6c7d(%rip), %rdi      # 0x8fd0
callq 0x1160
movq %rax, (%rsp)
jmp 0x235e
movq (%rsp), %rdi
movl $0xa, %esi
callq 0x1100
jmp 0x236e
jmp 0x2370
leaq 0x18(%rsp), %rdi
callq 0x2ac0
jmp 0x2318
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2c40
jmp 0x23c3
leaq 0x28(%rsp), %rdi
callq 0x2c40
leaq 0x60(%rsp), %rdi
callq 0x2c40
leaq 0x78(%rsp), %rdi
callq 0x2c40
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x2c40
leaq 0x78(%rsp), %rdi
callq 0x2c40
movq 0x48(%rsp), %rdi
callq 0x1150
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: henrixh[P]shittydsa/examples/../src/fft.h
// Function: lb(int)
ul inline lb(l x) {
  ul res { 0 };
  while(x) {
    x >>= 1;
    res++;
  }
  return res;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0x0, -0x4(%rsp)
je 0x24ea
movl -0x4(%rsp), %eax
sarl %eax
movl %eax, -0x4(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x24cc
movl -0x8(%rsp), %eax
retq
nop
// File: superblocks[P]superblocks/set-nug.cpp
// Function: Superblocks::init()
void Superblocks::init() {

	coin = "NUG"; 
	coin_name = "Nuggets";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 49;

	// superblock (step 1)
	reward[1] = 10045; // superblock reward (step 1)
	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 55;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 1000000;
	luck_type[1] = LUCK_WITH_LESS_THAN_X;
	luck_x[1] = 9723;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
leaq 0xce1(%rip), %rsi       # 0x4b00
callq 0x21c0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
leaq 0xcd1(%rip), %rsi       # 0x4b04
callq 0x21c0
movq -0x10(%rbp), %rax
movl $0x40, 0x58(%rax)
movl $0x31, 0xd4(%rax)
movl $0x273d, 0xd8(%rax)     # imm = 0x273D
movl $0x2, 0x60(%rax)
movl $0x37, 0x68(%rax)
movl $0x7, 0x70(%rax)
movl $0x1, 0x78(%rax)
movl $0xf4240, 0x80(%rax)    # imm = 0xF4240
movl $0x1, 0xc0(%rax)
movl $0x25fb, 0xc8(%rax)     # imm = 0x25FB
addq $0x10, %rsp
popq %rbp
retq
// File: ahupp[P]mural/mural_server.cpp
// Function: enforce(int, char const*)
int enforce(int a, const char* blame) {
  if (a == -1) {
    perror(blame);
    exit(1);
  }
  return a;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x3648
movq 0x8(%rsp), %rdi
callq 0x31e0
movl $0x1, %edi
callq 0x32e0
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ahupp[P]mural/mural_server.cpp
// Function: mural_epoll_add(int, int)
void mural_epoll_add(const int epoll_fd, const int fd) {
  struct epoll_event evt;
  evt.data.fd = fd;
  evt.events = EPOLLIN;
  enforce(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &evt), "mural_add_epoll");
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %edx
movl $0x1, %esi
leaq 0x4(%rsp), %rcx
callq 0x3340
movl %eax, %edi
leaq 0x6687(%rip), %rsi      # 0xa023
callq 0x3620
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ahupp[P]mural/mural_server.cpp
// Function: read_inotify_events(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<TagInfo, std::allocator<TagInfo>>&)
void read_inotify_events(const int inotify_fd,
                         const string& tag_file,
                         vector<TagInfo>& tags) {

  const int EVENT_SIZE = sizeof(struct inotify_event);
  const int BUF_SIZE = 1024 * (EVENT_SIZE + 16);
  char buf[BUF_SIZE];

  // The examples I've read check for EINTR, but its not clear when
  // that would happen, or what I should do about it.  So just fail
  // hard.  They also include a check for len == 0, same thing.
  int len = enforce(read(inotify_fd, buf, BUF_SIZE), "read");

  int i = 0;
  while (i < len) {

    struct inotify_event *event = (struct inotify_event*) &buf[i];

    if (event->mask & IN_CLOSE_WRITE) {
      // it can only be one thing...
      read_tags_file(tag_file, tags);
    }

    i += EVENT_SIZE + event->len;
  }
}

// Assembly:
subq $0x8038, %rsp           # imm = 0x8038
movl %edi, 0x8034(%rsp)
movq %rsi, 0x8028(%rsp)
movq %rdx, 0x8020(%rsp)
movl $0x10, 0x801c(%rsp)
movl $0x8000, 0x8018(%rsp) # imm = 0x8000
movl 0x8034(%rsp), %edi
leaq 0x10(%rsp), %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0x3360
movl %eax, %edi
leaq 0x6630(%rip), %rsi      # 0xa033
callq 0x3620
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x3a67
movslq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rax
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3a53
movq 0x8028(%rsp), %rdi
movq 0x8020(%rsp), %rsi
callq 0x7c10
movq (%rsp), %rax
movl 0xc(%rax), %eax
addl $0x10, %eax
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x3a14
addq $0x8038, %rsp           # imm = 0x8038
retq
nop
// File: ahupp[P]mural/mural_server.cpp
// Function: Timer::elapsedMS()
long elapsedMS() {
    struct timespec end;
    clock_gettime(CLOCK_MONOTONIC, &end);

    return 1000*(end.tv_sec - start.tv_sec) +
      (long)((end.tv_nsec - start.tv_nsec)/(1000*1000));
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x1, %edi
leaq 0x10(%rsp), %rsi
callq 0x3220
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
subq (%rcx), %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
subq 0x8(%rcx), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ahupp[P]mural/search.cpp
// Function: is_fuzzy_match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int*)
bool is_fuzzy_match(const string& symbol, const string& query,
                    int* inter_count_ret) {

  size_t qi = 0;
  size_t si = 0;
  int lastmatch = -1;

  // The number of characters between fuzzy matches.  This is 0 if
  // query is a substring of symbol.  Larger values of inter_count
  // will generally be worse matches than smaller values.
  int inter_count = 0;

  while (qi < query.length() && si < symbol.length()) {
    if (query[qi] == symbol[si]) {
      if (lastmatch != -1) {
        inter_count += si - lastmatch - 1;
      }
      lastmatch = si;
      ++qi;
    }
    ++si;
  }
  *inter_count_ret = inter_count;
  return qi == query.length();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movl $0xffffffff, 0x2c(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3390
movq 0x18(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x27(%rsp)
jae 0x4562
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x3390
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x456f
jmp 0x45f0
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x32c0
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x32c0
movq %rax, %rcx
movl 0xc(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x45dd
cmpl $-0x1, 0x2c(%rsp)
je 0x45c6
movq 0x30(%rsp), %rcx
movslq 0x2c(%rsp), %rax
subq %rax, %rcx
subq $0x1, %rcx
movslq 0x28(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x4515
movl 0x28(%rsp), %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0x3390
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ahupp[P]mural/search.cpp
// Function: is_better_match(std::pair<TagInfo const*, int> const&, std::pair<TagInfo const*, int> const&)
bool is_better_match(const FuzzyMatch& lhs, const FuzzyMatch& rhs) {
  if (lhs.second < rhs.second) {
    return true;
  } else if (lhs.second == rhs.second) {
    if (lhs.first->symbol.length() < rhs.first->symbol.length()) {
      return true;
    }
  }
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4657
movb $0x1, 0x27(%rsp)
jmp 0x46a5
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x469e
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3390
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3390
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x469c
movb $0x1, 0x27(%rsp)
jmp 0x46a5
jmp 0x469e
jmp 0x46a0
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: ahupp[P]mural/search.cpp
// Function: find_all_fuzzy_matches(std::vector<TagInfo, std::allocator<TagInfo>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
vector<FuzzyMatch> find_all_fuzzy_matches(const vector<TagInfo>& tags,
                                          const string& query,
                                          const bool ignore_case) {
  // Searches that don't explicitly look like a method ("::") will
  // never include methods, and vice-versa.
  bool methods_only = is_method_tag(query);

  vector<FuzzyMatch> matches;

  for (size_t i = 0; i < tags.size(); ++i) {
    int inter_count;
    const TagInfo& tag = tags[i];

    if (tag.is_method != methods_only) {
      // could split the tags into method and non-method sets and only
      // search one, but right now it's fast enough.
      continue;
    }

    if (is_fuzzy_match(ignore_case ? tag.symbol_lc : tag.symbol,
                       query, &inter_count)) {
      // Passing &tag here is an important perf optimization to avoid
      // excessive copying when there are many possible results (like
      // "A")
      matches.push_back(make_pair(&tag, inter_count));
    }
  }
  return matches;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x30(%rsp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, 0x28(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
andb $0x1, %al
movb %al, 0x8f(%rsp)
movq 0x90(%rsp), %rdi
callq 0x6fc0
movq 0x30(%rsp), %rdi
andb $0x1, %al
movb %al, 0x8e(%rsp)
movb $0x0, 0x8d(%rsp)
callq 0x4b80
movq $0x0, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rdi
callq 0x3dc0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x4854
movq 0x98(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x4b90
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movb 0x64(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x8e(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x4783
jmp 0x483b
testb $0x1, 0x8f(%rsp)
je 0x479d
movq 0x70(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
jmp 0x47a7
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x90(%rsp), %rsi
leaq 0x7c(%rsp), %rdx
callq 0x44e0
testb $0x1, %al
jne 0x47c4
jmp 0x4839
movq 0x70(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x7c(%rsp), %rsi
callq 0x4be0
movl %edx, 0xc(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x47e8
movq 0x30(%rsp), %rdi
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x68(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x4bb0
jmp 0x481d
jmp 0x4839
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x4c10
jmp 0x487d
jmp 0x483b
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x471b
movb $0x1, 0x8d(%rsp)
testb $0x1, 0x8d(%rsp)
jne 0x4870
movq 0x30(%rsp), %rdi
callq 0x4c10
movq 0x28(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x33f0
nopw (%rax,%rax)
// File: ahupp[P]mural/tags.cpp
// Function: lowercase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string lowercase(const string& s) {
  string ret = s;
  for (size_t i = 0; i < ret.length(); ++i) {
    ret[i] = tolower(ret[i]);
  }
  return ret;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
movq 0x58(%rsp), %rsi
callq 0x30f0
movq $0x0, 0x48(%rsp)
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x3390
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x70b6
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x3490
movq %rax, 0x18(%rsp)
jmp 0x705a
movq 0x18(%rsp), %rax
movsbl (%rax), %edi
callq 0x3370
movq 0x28(%rsp), %rdi
movb %al, 0xf(%rsp)
movq 0x48(%rsp), %rsi
callq 0x3490
movq %rax, 0x10(%rsp)
jmp 0x7081
movq 0x10(%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, (%rax)
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x7023
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x3170
jmp 0x70d6
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x70cc
movq 0x28(%rsp), %rdi
callq 0x3170
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x33f0
// File: ahupp[P]mural/tags.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> split(const string& line, char delim) {

  vector<string> result;

  size_t i = 0;
  while (1) {

    size_t next = line.find(delim, i);
    if (next == string::npos) {
      break;
    }

    result.push_back(line.substr(i, next - i));

    i = next + 1;
  }
  result.push_back(line.substr(i, line.length() - i));

  return result;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movb %al, 0x87(%rsp)
movb $0x0, 0x86(%rsp)
callq 0x7dc0
movq $0x0, 0x78(%rsp)
jmp 0x7125
movq 0x88(%rsp), %rdi
movb 0x87(%rsp), %al
movq 0x78(%rsp), %rdx
movsbl %al, %esi
callq 0x3330
movq %rax, 0x70(%rsp)
cmpq $-0x1, 0x70(%rsp)
jne 0x7150
jmp 0x71cc
movq 0x88(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x70(%rsp), %rcx
subq %rdx, %rcx
leaq 0x50(%rsp), %rdi
callq 0x3260
jmp 0x7171
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x7dd0
jmp 0x7182
leaq 0x50(%rsp), %rdi
callq 0x3170
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0x7123
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x7267
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x3170
jmp 0x7267
movq 0x88(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3390
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
movq 0x78(%rsp), %rax
subq %rax, %rcx
leaq 0x20(%rsp), %rdi
callq 0x3260
jmp 0x7207
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x7dd0
jmp 0x7218
leaq 0x20(%rsp), %rdi
callq 0x3170
movb $0x1, 0x86(%rsp)
testb $0x1, 0x86(%rsp)
jne 0x725a
jmp 0x7250
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3170
jmp 0x7267
movq 0x10(%rsp), %rdi
callq 0x7e00
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x7e00
movq 0x48(%rsp), %rdi
callq 0x33f0
nopl (%rax,%rax)
// File: ahupp[P]mural/tags.cpp
// Function: read_tags_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<TagInfo, std::allocator<TagInfo>>&)
void read_tags_file(const string& tags_file, vector<TagInfo>& tags) {

  if (0 != access(tags_file.c_str(), R_OK)) {
    cerr << "error: " << tags_file << " not readable" << endl;
    exit(1);
  }

  tags.clear();

  ifstream tags_stream(tags_file.c_str());

  string line;
  getline(tags_stream, line);
  tags_stream.seekg(0);

  if (line.length() && line[0] == '!') {
    read_ctags_file(tags_stream, tags);
  } else {
    read_etags_file(tags_stream, tags);
  }
}

// Assembly:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq 0x270(%rsp), %rdi
callq 0x30e0
movq %rax, %rdi
movl $0x4, %esi
callq 0x33d0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x7c94
movq 0x63a0(%rip), %rdi      # 0xdff0
leaq 0x2496(%rip), %rsi      # 0xa0ed
callq 0x3230
movq %rax, %rdi
movq 0x270(%rsp), %rsi
callq 0x3210
movq %rax, %rdi
leaq 0x247f(%rip), %rsi      # 0xa0f5
callq 0x3230
movq %rax, %rdi
movq 0x6333(%rip), %rsi      # 0xdfb8
callq 0x3280
movl $0x1, %edi
callq 0x32e0
movq 0x268(%rsp), %rdi
callq 0x80e0
movq 0x270(%rsp), %rdi
callq 0x30e0
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x8, %edx
callq 0x3440
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3350
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3070
jmp 0x7ce5
xorl %eax, %eax
movl %eax, %esi
leaq 0x20(%rsp), %rdi
callq 0x8100
jmp 0x7cf5
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x3310
jmp 0x7d0b
leaq 0x40(%rsp), %rdi
callq 0x3390
cmpq $0x0, %rax
je 0x7d77
xorl %eax, %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0x3490
movq %rax, 0x8(%rsp)
jmp 0x7d30
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
jne 0x7d77
movq 0x268(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x7280
jmp 0x7d51
jmp 0x7d8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3170
leaq 0x60(%rsp), %rdi
callq 0x3090
jmp 0x7da9
movq 0x268(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x77c0
jmp 0x7d8b
jmp 0x7d8d
leaq 0x40(%rsp), %rdi
callq 0x3170
leaq 0x60(%rsp), %rdi
callq 0x3090
addq $0x278, %rsp            # imm = 0x278
retq
movq 0x38(%rsp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jsteemann[P]jshund/src/jshund.cpp
// Function: Bark()
static void Bark () {
  std::cout << "   _     _                     _  " << std::endl;
  std::cout << "  (_)___| |__  _   _ _ __   __| | " << std::endl;
  std::cout << "  | / __| '_ \\| | | | '_ \\ / _` | " << std::endl;
  std::cout << "  | \\__ \\ | | | |_| | | | | (_| | " << std::endl;
  std::cout << " _/ |___/_| |_|\\__,_|_| |_|\\__,_| " << std::endl;
  std::cout << "|__/                              " << std::endl;
  std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x145c5(%rip), %rdi     # 0x17fd0
leaq 0xd64e(%rip), %rsi      # 0x11060
callq 0x3240
movq %rax, %rdi
movq 0x1459f(%rip), %rsi     # 0x17fc0
callq 0x32a0
movq 0x145a3(%rip), %rdi     # 0x17fd0
leaq 0xd64f(%rip), %rsi      # 0x11083
callq 0x3240
movq %rax, %rdi
movq 0x1457d(%rip), %rsi     # 0x17fc0
callq 0x32a0
movq 0x14581(%rip), %rdi     # 0x17fd0
leaq 0xd650(%rip), %rsi      # 0x110a6
callq 0x3240
movq %rax, %rdi
movq 0x1455b(%rip), %rsi     # 0x17fc0
callq 0x32a0
movq 0x1455f(%rip), %rdi     # 0x17fd0
leaq 0xd651(%rip), %rsi      # 0x110c9
callq 0x3240
movq %rax, %rdi
movq 0x14539(%rip), %rsi     # 0x17fc0
callq 0x32a0
movq 0x1453d(%rip), %rdi     # 0x17fd0
leaq 0xd652(%rip), %rsi      # 0x110ec
callq 0x3240
movq %rax, %rdi
movq 0x14517(%rip), %rsi     # 0x17fc0
callq 0x32a0
movq 0x1451b(%rip), %rdi     # 0x17fd0
leaq 0xd653(%rip), %rsi      # 0x1110f
callq 0x3240
movq %rax, %rdi
movq 0x144f5(%rip), %rsi     # 0x17fc0
callq 0x32a0
movq 0x144f9(%rip), %rdi     # 0x17fd0
movq 0x144e2(%rip), %rsi     # 0x17fc0
callq 0x32a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jsteemann[P]jshund/src/jshund.cpp
// Function: AddFiles[abi:cxx11](int, char**)
static std::vector<std::string> AddFiles (int argc, char* argv[]) {
  std::vector<std::string> files;

  DirectoryIterator dir;
  bool separator = false;
  
  // add files/directories specified in argv
  for (int i = 1; i < argc; ++i) {
    const std::string argument(argv[i]);

    if (argument.substr(0, 2) == "--" && ! separator) {
      // option/value separator
      if (argument.size() == 2) {
        separator = true;
      }
      continue;
    }

    dir.addFiles(files, argument);
  }

  return files;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x41a0
leaq -0x1a(%rbp), %rdi
callq 0x41c0
jmp 0x3b2b
movb $0x0, -0x2d(%rbp)
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3cbb
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0xa8(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3470
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4060
jmp 0x3b7e
leaq -0x59(%rbp), %rdi
callq 0x32c0
xorl %eax, %eax
movl %eax, %edx
leaq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movl $0x2, %ecx
callq 0x3280
jmp 0x3b9f
leaq 0xd639(%rip), %rsi      # 0x111df
leaq -0x80(%rbp), %rdi
callq 0x4110
movb %al, -0xa9(%rbp)
jmp 0x3bb7
movb -0xa9(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xaa(%rbp)
jne 0x3bcc
jmp 0x3bd7
movb -0x2d(%rbp), %al
xorb $-0x1, %al
movb %al, -0xaa(%rbp)
movb -0xaa(%rbp), %al
movb %al, -0xab(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3170
movb -0xab(%rbp), %al
testb $0x1, %al
jne 0x3bf8
jmp 0x3c69
leaq -0x58(%rbp), %rdi
callq 0x31b0
cmpq $0x2, %rax
jne 0x3c5d
movb $0x1, -0x2d(%rbp)
jmp 0x3c5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3d01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x32c0
jmp 0x3cda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3cb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3170
jmp 0x3cb0
movl $0x4, -0x84(%rbp)
jmp 0x3c89
movq -0x98(%rbp), %rsi
leaq -0x1a(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x41d0
jmp 0x3c7f
movl $0x0, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3170
movl -0x84(%rbp), %eax
testl %eax, %eax
je 0x3ca0
jmp 0x3c9e
jmp 0x3ca2
jmp 0x3ca2
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3b36
leaq -0x58(%rbp), %rdi
callq 0x3170
jmp 0x3cda
movb $0x1, -0x19(%rbp)
movl $0x1, -0x84(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x4310
testb $0x1, -0x19(%rbp)
jne 0x3cf1
jmp 0x3ce5
leaq -0x1a(%rbp), %rdi
callq 0x4310
jmp 0x3d01
movq -0x98(%rbp), %rdi
callq 0x4140
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x4140
movq -0x28(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: jsteemann[P]jshund/src/./DirectoryIterator.h
// Function: jshund::DirectoryIterator::addFiles(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void addFiles (std::vector<std::string>& files, std::string const& argument) {
        if (isFile(argument)) {
          files.push_back(std::string(argument));
        }
        else if (isDir(argument)) {
          addDir(files, argument);
        }
        else {
          std::cerr << "Ignoring invalid file/directory path '" << argument << "'" << std::endl;
        }
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x43d0
testb $0x1, %al
jne 0x41fe
jmp 0x424e
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3110
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x4430
jmp 0x4226
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x42f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x42ff
movq -0x18(%rbp), %rdi
callq 0x4460
testb $0x1, %al
jne 0x425d
jmp 0x42b7
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3110
movq -0x70(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x44c0
jmp 0x4295
leaq -0x68(%rbp), %rdi
callq 0x3170
jmp 0x42f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3170
jmp 0x42ff
movq 0x13d32(%rip), %rdi     # 0x17ff0
leaq 0xce6d(%rip), %rsi      # 0x11132
callq 0x3240
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3220
movq %rax, %rdi
leaq 0xd05d(%rip), %rsi      # 0x1133d
callq 0x3240
movq %rax, %rdi
movq 0x13cd1(%rip), %rsi     # 0x17fc0
callq 0x32a0
jmp 0x42f6
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3460
nopl (%rax,%rax)
// File: jsteemann[P]jshund/src/./DirectoryIterator.h
// Function: jshund::DirectoryIterator::isFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static bool isFile (std::string const& name) {
        struct stat filestatus;
  
        if (::stat(name.c_str(), &filestatus) != 0 || (filestatus.st_mode & S_IFMT) != S_IFREG) {
          return false;
        }

        return true;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3230
cmpl $0x0, %eax
jne 0x440e
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
je 0x4414
movb $0x0, -0x1(%rbp)
jmp 0x4418
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jsteemann[P]jshund/src/./DirectoryIterator.h
// Function: jshund::DirectoryIterator::isDir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static bool isDir (std::string const& name) {
        struct stat filestatus;
  
        if (::stat(name.c_str(), &filestatus) != 0 || (filestatus.st_mode & S_IFMT) != S_IFDIR) {
          return false;
        }

        return true;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3230
cmpl $0x0, %eax
jne 0x449e
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x44a4
movb $0x0, -0x1(%rbp)
jmp 0x44a8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jsteemann[P]jshund/src/./FileReader.h
// Function: jshund::FileReader::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
char* read (const std::string& fileName) {
        std::ifstream f;

        f.open(fileName.c_str(), std::ifstream::in | std::ifstream::binary);

        if (! f.is_open()) {
          return 0;
        }

        // get filesize
        f.seekg(0, std::ios::end);
        int fileSize = f.tellg();
        f.seekg(0, std::ios::beg);

        // allocate buffer plus some extra bytes
        char* buffer = new char[fileSize + 5];

        if (buffer != 0) {
          // initialise buffer with 0s
          memset(buffer + fileSize, 0, 5);

          // read contents
          f.read(buffer, fileSize);
          f.close();
        }

        return buffer;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x3300
movq -0x18(%rbp), %rdi
callq 0x3100
movq %rax, -0x260(%rbp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x99f0
movl %eax, -0x254(%rbp)
jmp 0x53a6
movl -0x254(%rbp), %edx
movq -0x260(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x3180
jmp 0x53c1
leaq -0x220(%rbp), %rdi
callq 0x33f0
movb %al, -0x261(%rbp)
jmp 0x53d5
movb -0x261(%rbp), %al
testb $0x1, %al
jne 0x541b
jmp 0x53e1
movq $0x0, -0x8(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0x552b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x30b0
jmp 0x5544
xorl %eax, %eax
movl %eax, %esi
leaq -0x220(%rbp), %rdi
movl $0x2, %edx
callq 0x3380
jmp 0x5432
leaq -0x220(%rbp), %rdi
callq 0x3440
movq %rdx, -0x278(%rbp)
movq %rax, -0x270(%rbp)
jmp 0x544e
movq -0x278(%rbp), %rax
movq -0x270(%rbp), %rcx
movq %rcx, -0x248(%rbp)
movq %rax, -0x240(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x9a10
movq %rax, -0x280(%rbp)
jmp 0x547f
movq -0x280(%rbp), %rax
movl %eax, -0x234(%rbp)
xorl %edx, %edx
movl %edx, %esi
leaq -0x220(%rbp), %rdi
callq 0x3380
jmp 0x549e
movl -0x234(%rbp), %eax
addl $0x5, %eax
movslq %eax, %rdi
callq 0x3030
movq %rax, -0x288(%rbp)
jmp 0x54b8
movq -0x288(%rbp), %rax
movq %rax, -0x250(%rbp)
cmpq $0x0, -0x250(%rbp)
je 0x5516
movq -0x250(%rbp), %rax
movslq -0x234(%rbp), %rcx
movb $0x0, 0x4(%rax,%rcx)
movl $0x0, (%rax,%rcx)
movq -0x250(%rbp), %rsi
movslq -0x234(%rbp), %rdx
leaq -0x220(%rbp), %rdi
callq 0x3350
jmp 0x5506
leaq -0x220(%rbp), %rdi
callq 0x3080
jmp 0x5514
jmp 0x5516
movq -0x250(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x30b0
movq -0x8(%rbp), %rax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x3460
// File: jsteemann[P]jshund/src/./Validator.h
// Function: jshund::Validator::Validator(bool, bool)
Validator (bool colors, bool globals) :
        _globals(globals) {

        if (colors && ::isatty(STDOUT_FILENO)) {
          _colorGlobal   = "\x1b[0;33m";
          _colorLocal    = "\x1b[0;31m";
          _colorEnd      = "\x1b[0m";
        }
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x33a0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0x33a0
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x38(%rbp)
callq 0x33a0
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x30(%rbp)
callq 0x33a0
movq -0x28(%rbp), %rax
movb -0xa(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x80(%rax)
testb $0x1, -0x9(%rbp)
je 0x89a7
movl $0x1, %edi
callq 0x3450
cmpl $0x0, %eax
je 0x89a7
movq -0x28(%rbp), %rdi
leaq 0x899a(%rip), %rsi      # 0x112da
callq 0x3390
jmp 0x8947
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
leaq 0x898c(%rip), %rsi      # 0x112e2
callq 0x3390
jmp 0x895d
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
leaq 0x897e(%rip), %rsi      # 0x112ea
callq 0x3390
jmp 0x8973
jmp 0x89a7
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3170
movq -0x38(%rbp), %rdi
callq 0x3170
movq -0x40(%rbp), %rdi
callq 0x3170
movq -0x28(%rbp), %rdi
callq 0x3170
jmp 0x89ad
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::tokenize(char const*)
const std::vector<Token>& tokenize (char const* input) {
        _input    = input;
        _length   = ::strlen(input);
        _position = 0;
        _line     = 1; 
        _last     = TOKEN_UNKNOWN;

        _tokens.clear();

        doTokenize();

        if (_debug) {
          for (size_t i = 0; i < _tokens.size(); ++i) {
            _tokens[i].dump();
          }
        }

        return _tokens;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rdi
callq 0x3120
movq -0x20(%rbp), %rdi
movq %rax, 0x88(%rdi)
movq $0x0, 0x90(%rdi)
movq $0x1, 0x98(%rdi)
movl $0x0, 0x78(%rdi)
addq $0x60, %rdi
callq 0xe100
movq -0x20(%rbp), %rdi
callq 0xe120
movq -0x20(%rbp), %rax
testb $0x1, 0xa0(%rax)
je 0x9935
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x60, %rdi
callq 0xb410
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x9933
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
callq 0xe240
movq %rax, %rdi
callq 0xe260
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x98eb
jmp 0x9935
movq -0x20(%rbp), %rax
addq $0x60, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jsteemann[P]jshund/src/./Validator.h
// Function: jshund::Validator::reportError(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void reportError (int line, std::string const& name, bool global) {
        std::cout << _filename << ':' << line << ':'  
                  << (global ? _colorGlobal : _colorLocal) << " unused " << (global ? "global" : "local") 
                  << " variable '" << name << '\'' << _colorEnd  
                  << std::endl;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
addq $0x60, %rsi
movq 0xc783(%rip), %rdi      # 0x17fd0
callq 0x3220
movq %rax, %rdi
movl $0x3a, %esi
callq 0x3320
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3430
movq %rax, %rdi
movl $0x3a, %esi
callq 0x3320
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0xb88b
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xb897
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3220
movq %rax, %rdi
leaq 0x5a6f(%rip), %rsi      # 0x1131d
callq 0x3240
movq %rax, %rdi
movb -0x19(%rbp), %cl
leaq 0x5a6d(%rip), %rsi      # 0x1132d
leaq 0x5a5f(%rip), %rax      # 0x11326
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x3240
movq %rax, %rdi
leaq 0x5a56(%rip), %rsi      # 0x11333
callq 0x3240
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3220
movq %rax, %rdi
movl $0x27, %esi
callq 0x3320
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x40, %rsi
callq 0x3220
movq %rax, %rdi
movq 0xc6ab(%rip), %rsi      # 0x17fc0
callq 0x32a0
addq $0x40, %rsp
popq %rbp
retq
// File: jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::doTokenize()
void doTokenize () {
        while (true) {
          Token token = getNext();
          if (token.type == TOKEN_EOF || token.type == TOKEN_UNKNOWN) {
            break;
          }

          addToken(token);
        }

        addToken(makeToken(TOKEN_EOF));
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xe370
cmpl $0x72, -0x38(%rbp)
je 0xe156
cmpl $0x0, -0x38(%rbp)
jne 0xe15f
movl $0x3, -0x3c(%rbp)
jmp 0xe190
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb5b0
jmp 0xe16e
movq -0xb8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xe6e0
jmp 0xe180
leaq -0x70(%rbp), %rdi
callq 0xb120
movl $0x0, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb120
movl -0x3c(%rbp), %eax
testl %eax, %eax
je 0xe1a4
jmp 0xe1a2
jmp 0xe1d4
jmp 0xe13a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xe1c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xb120
leaq -0x38(%rbp), %rdi
callq 0xb120
jmp 0xe235
movq -0xb8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movl $0x72, %edx
callq 0xe720
movq -0xb8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0xe6e0
jmp 0xe208
leaq -0xb0(%rbp), %rdi
callq 0xb120
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xb120
movq -0x78(%rbp), %rdi
callq 0x3460
nop
// File: jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::makeToken(jshund::TokenType)
Token makeToken (TokenType type) {
        Token token;
        token.type  = type;
        token.line  = _line;
        token.value = "";

        ++_position;

        return token;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xf5a0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl %ecx, (%rdi)
movq 0x98(%rax), %rax
movq %rax, 0x28(%rdi)
addq $0x8, %rdi
leaq 0x2be1(%rip), %rsi      # 0x11353
callq 0x3390
jmp 0xe779
movq -0x38(%rbp), %rax
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xe7bb
jmp 0xe7b2
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xb120
jmp 0xe7c5
movq -0x30(%rbp), %rdi
callq 0xb120
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3460
nop
// File: jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::skipWhitespace()
bool skipWhitespace () {
        while (true) {
          const char c = _input[_position];
          
          if (c == '\0') {
            return false;
          }

          if (c != ' ' && c != '\r' && c != '\n' && c != '\t' && c != '\f' && c != '\b') {
            return true;
          }

          if (c == '\r') {
            if (_input[_position + 1] == '\n') {
              ++_position;
              ++_line;
            }
          }
          else if (c == '\n') {
            ++_line;
          }

          _position++;
        }
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq 0x80(%rcx), %rax
movq 0x90(%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0xe80a
movb $0x0, -0x1(%rbp)
jmp 0xe8d4
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
je 0xe849
movsbl -0x11(%rbp), %eax
cmpl $0xd, %eax
je 0xe849
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
je 0xe849
movsbl -0x11(%rbp), %eax
cmpl $0x9, %eax
je 0xe849
movsbl -0x11(%rbp), %eax
cmpl $0xc, %eax
je 0xe849
movsbl -0x11(%rbp), %eax
cmpl $0x8, %eax
je 0xe849
movb $0x1, -0x1(%rbp)
jmp 0xe8d4
movsbl -0x11(%rbp), %eax
cmpl $0xd, %eax
jne 0xe898
movq -0x20(%rbp), %rcx
movq 0x80(%rcx), %rax
movq 0x90(%rcx), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xe896
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
jmp 0xe8b9
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0xe8b7
movq -0x20(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
jmp 0xe8b9
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
jmp 0xe7e0
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleString(char)
Token handleString (const char terminator) {
        size_t now = _position + 1;

        while (true) {
          char n = _input[now];
          if (n == '\\') {
            ++now;
          }
          else if (n == terminator) {
            return makeToken(TOKEN_STRING_LITERAL, until(now + 1));
          }
          else if (n == '\0') {
            return makeToken(TOKEN_UNKNOWN);
          }
          ++now;
        }
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x90(%rax), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x60(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x5c, %eax
jne 0xe946
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xe9c2
movsbl -0x21(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xe9a4
movq -0x60(%rbp), %rsi
movq -0x20(%rbp), %rdx
incq %rdx
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xf420
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x78(%rbp), %rcx
movl $0x1, %edx
callq 0xf330
jmp 0xe982
leaq -0x48(%rbp), %rdi
callq 0x3170
jmp 0xe9d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3170
jmp 0xe9e0
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0xe9be
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
xorl %edx, %edx
callq 0xe720
jmp 0xe9d3
jmp 0xe9c0
jmp 0xe9c2
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xe91a
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleNumber()
Token handleNumber () {
        size_t now = _position;
        bool dotFound = false;
        bool expFound = false;
        
        while (true) {
          char n = _input[now];
          if (n >= '0' && n <= '9') {
            ++now;
          }
          else if (n == '.' && ! dotFound) {
            dotFound = true;
            ++now;
          }
          else if ((n == 'e' || n == 'E') && ! expFound) {
            // exponent
            expFound = true;
            ++now;
          }
          else {
            break;
          }
        }

        return makeToken(TOKEN_NUMBER, until(now));
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
movq -0x58(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1b(%rbp)
movsbl -0x1b(%rbp), %eax
cmpl $0x30, %eax
jl 0xee0b
movsbl -0x1b(%rbp), %eax
cmpl $0x39, %eax
jg 0xee0b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xee5c
movsbl -0x1b(%rbp), %eax
cmpl $0x2e, %eax
jne 0xee2c
testb $0x1, -0x19(%rbp)
jne 0xee2c
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xee5a
movsbl -0x1b(%rbp), %eax
cmpl $0x65, %eax
je 0xee3e
movsbl -0x1b(%rbp), %eax
cmpl $0x45, %eax
jne 0xee56
testb $0x1, -0x1a(%rbp)
jne 0xee56
movb $0x1, -0x1a(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xee58
jmp 0xee61
jmp 0xee5a
jmp 0xee5c
jmp 0xedd6
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xf420
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x70(%rbp), %rcx
movl $0x2, %edx
callq 0xf330
jmp 0xee8e
leaq -0x40(%rbp), %rdi
callq 0x3170
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3170
movq -0x48(%rbp), %rdi
callq 0x3460
nop