LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nyorain[P]bintoheader/./flags.hpp
// Function: flags::detail::parser::on_option(std::basic_string_view<char, std::char_traits<char>> const&)
void on_option(const std::string_view& option) {
    // Consume the current_option and reassign it to the new option while
    // removing all leading dashes.
    flush();
    current_option_ = option;
    current_option_->remove_prefix(current_option_->find_first_not_of('-'));

    // Handle a packed argument (--arg_name=value).
    const auto delimiter = current_option_->find_first_of('=');
    if (delimiter != std::string_view::npos) {
      auto value = *current_option_;
      value.remove_prefix(delimiter + 1 /* skip '=' */);
      current_option_->remove_suffix(current_option_->size() - delimiter);
      on_value(value);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x7100
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x75f0
movq -0x48(%rbp), %rdi
callq 0x7650
movq -0x48(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x7650
movq %rax, %rdi
movl $0x2d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x76b0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x7670
movq -0x48(%rbp), %rdi
callq 0x7650
movq %rax, %rdi
movl $0x3d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x7720
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x7563
movq -0x48(%rbp), %rdi
callq 0x7750
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
leaq -0x28(%rbp), %rdi
callq 0x7670
movq -0x48(%rbp), %rdi
callq 0x7650
movq -0x48(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x7650
movq %rax, %rdi
callq 0x6420
movq -0x58(%rbp), %rdi
movq %rax, %rsi
subq -0x18(%rbp), %rsi
callq 0x7770
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7790
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7570
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: nyorain[P]bintoheader/./flags.hpp
// Function: flags::detail::parser::on_value(std::optional<std::basic_string_view<char, std::char_traits<char>>> const&)
void on_value(const std::optional<std::string_view>& value = std::nullopt) {
    // If there's not an option preceding the value, it's a positional argument.
    if (!current_option_) {
      positional_arguments_.emplace_back(*value);
      return;
    }
    // Consume the preceding option and assign its value.
    options_.emplace(*current_option_, value);
    current_option_.reset();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x5370
testb $0x1, %al
jne 0x75b4
movq -0x28(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5390
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x7b20
jmp 0x75e8
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
callq 0x7750
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x7ba0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movb %dl, -0x18(%rbp)
callq 0x7bf0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: nyorain[P]bintoheader/./flags.hpp
// Function: std::optional<unsigned int> flags::detail::get<unsigned int>(std::unordered_map<std::basic_string_view<char, std::char_traits<char>>, std::optional<std::basic_string_view<char, std::char_traits<char>>>, std::hash<std::basic_string_view<char, std::char_traits<char>>>, std::equal_to<std::basic_string_view<char, std::char_traits<char>>>, std::allocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, std::optional<std::basic_string_view<char, std::char_traits<char>>>>>> const&, std::basic_string_view<char, std::char_traits<char>> const&)
std::optional<T> get(const argument_map& options,
                     const std::string_view& option) {
  if (const auto view = get_value(options, option)) {
    T value;
    if (std::istringstream(std::string(*view)) >> value) return value;
  }
  return std::nullopt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x52f0
leaq -0x30(%rbp), %rdi
callq 0x5370
testb $0x1, %al
jne 0xa6a6
jmp 0xa7d7
leaq -0x30(%rbp), %rdi
callq 0x5390
movq %rax, -0x200(%rbp)
leaq -0x1d9(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x3480
movq -0x200(%rbp), %rsi
movq -0x1f8(%rbp), %rdx
leaq -0x1d8(%rbp), %rdi
callq 0x53b0
jmp 0xa6e5
leaq -0x1b8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
movl $0x8, %edx
callq 0x3440
jmp 0xa6ff
leaq -0x1b8(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xa800
movq %rax, -0x208(%rbp)
jmp 0xa718
movq -0x208(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3330
movb %al, -0x209(%rbp)
jmp 0xa736
leaq -0x1b8(%rbp), %rdi
callq 0x3160
leaq -0x1d8(%rbp), %rdi
callq 0x31b0
leaq -0x1d9(%rbp), %rdi
callq 0x32b0
movb -0x209(%rbp), %al
testb $0x1, %al
jne 0xa766
jmp 0xa7d5
leaq -0x8(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xa830
jmp 0xa7e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e8(%rbp)
movl %eax, -0x1ec(%rbp)
jmp 0xa7c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e8(%rbp)
movl %eax, -0x1ec(%rbp)
jmp 0xa7bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e8(%rbp)
movl %eax, -0x1ec(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x3160
leaq -0x1d8(%rbp), %rdi
callq 0x31b0
leaq -0x1d9(%rbp), %rdi
callq 0x32b0
jmp 0xa7ed
jmp 0xa7d7
leaq -0x8(%rbp), %rdi
callq 0xa860
movq -0x8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1e8(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: sonnyit[P]profiler/profiler.cpp
// Function: Profiler::getInstance()
Profiler& Profiler::getInstance() {
    static Profiler instance;
    if (_destroyed) {
        throw std::runtime_error("Profiler: Dead reference access");
    }
    return instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpb $0x0, 0x5ca1(%rip)      # 0x81f0
jne 0x2596
leaq 0x5c98(%rip), %rdi      # 0x81f0
callq 0x22c0
cmpl $0x0, %eax
je 0x2596
leaq 0x5c2f(%rip), %rdi      # 0x8198
callq 0x27a0
jmp 0x2570
leaq 0x259(%rip), %rdi       # 0x27d0
leaq 0x5c1a(%rip), %rsi      # 0x8198
leaq 0x5bf3(%rip), %rdx      # 0x8178
callq 0x2190
leaq 0x5c5f(%rip), %rdi      # 0x81f0
callq 0x2110
testb $0x1, 0x5bf3(%rip)      # 0x8190
je 0x2609
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x18(%rbp)
leaq 0x2a4a(%rip), %rsi      # 0x5004
callq 0x2090
jmp 0x25c1
movq -0x18(%rbp), %rdi
movq 0x5a24(%rip), %rsi      # 0x7ff0
movq 0x59f5(%rip), %rdx      # 0x7fc8
callq 0x2290
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq 0x5c05(%rip), %rdi      # 0x81f0
callq 0x2100
jmp 0x2616
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
callq 0x2140
jmp 0x2616
leaq 0x5b88(%rip), %rax      # 0x8198
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x22a0
nop
// File: sonnyit[P]profiler/profiler.cpp
// Function: Profiler::addProfiler(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long)
void Profiler::addProfiler(const std::string& task_name, long ms) {
    lock_guard<mutex> lock(_mutex);
    if (_map_table.find(task_name) != _map_table.end()) {
        ++_map_table[task_name].count;
        _map_table[task_name].time_pass += ms;
        _map_table[task_name].last_time_pass = ms;
    } else {
        ProfilerTask task;
        ++task.count;
        task.time_pass += ms;
        task.last_time_pass = ms;
        _map_table[task_name] = task;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x68(%rbp)
addq $0x30, %rsi
leaq -0x20(%rbp), %rdi
callq 0x2ba0
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2c00
movq %rax, -0x60(%rbp)
jmp 0x265f
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2c30
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2bd0
testb $0x1, %al
jne 0x268a
jmp 0x2724
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2c90
movq %rax, -0x70(%rbp)
jmp 0x269d
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rcx
incq %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2c90
movq %rax, -0x78(%rbp)
jmp 0x26c7
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rdx
movq (%rax), %rcx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2c90
movq %rax, -0x88(%rbp)
jmp 0x26f9
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2d70
jmp 0x2797
leaq -0x58(%rbp), %rdi
callq 0x2c60
jmp 0x272f
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rax
incq %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2c90
movq %rax, -0x98(%rbp)
jmp 0x2767
movq -0x98(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x20(%rbp), %rdi
callq 0x2d70
addq $0xa0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x22a0
// File: sonnyit[P]profiler/profiler.cpp
// Function: Profiler::reset(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Profiler::reset(const std::string& task_name) {
    lock_guard<mutex> lock(_mutex);
    if (_map_table.find(task_name) != _map_table.end()) { /* found -> reset task */
        ProfilerTask task;
        _map_table[task_name] = task;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x60(%rbp)
addq $0x30, %rsi
leaq -0x18(%rbp), %rdi
callq 0x2ba0
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2c00
movq %rax, -0x58(%rbp)
jmp 0x2838
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2c30
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2bd0
testb $0x1, %al
jne 0x2860
jmp 0x28b2
leaq -0x50(%rbp), %rdi
callq 0x2c60
jmp 0x286b
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2c90
movq %rax, -0x68(%rbp)
jmp 0x287e
movq -0x68(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x28b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2d70
jmp 0x28c1
leaq -0x18(%rbp), %rdi
callq 0x2d70
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22a0
nopw (%rax,%rax)
// File: sonnyit[P]profiler/profiler.cpp
// Function: Profiler::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
ProfilerTask Profiler::get(const std::string& task_name) {
    lock_guard<mutex> lock(_mutex);
    if (_map_table.find(task_name) != _map_table.end()) {
        return _map_table[task_name];
    }
    return ProfilerTask();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x50(%rbp)
addq $0x30, %rsi
leaq -0x18(%rbp), %rdi
callq 0x2ba0
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2c00
movq %rax, -0x48(%rbp)
jmp 0x2920
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2c30
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2bd0
testb $0x1, %al
jne 0x2948
jmp 0x2999
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2c90
movq %rax, -0x68(%rbp)
jmp 0x295b
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, -0x3c(%rbp)
jmp 0x29ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2d70
jmp 0x29be
movq -0x60(%rbp), %rdi
callq 0x2c60
jmp 0x29a4
movl $0x1, -0x3c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2d70
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x22a0
nopw (%rax,%rax)
// File: sonnyit[P]profiler/example.cpp
// Function: func1()
void func1() {
  PROFILER_TASK(func1);

  float f = 0;
  for (int i = 0; i < 100000; ++i) {
    f += cosf(static_cast<float>(rand()));
  }
  cout << "fun1 output: " << fixed << setprecision(2) << f << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x22b0
movq -0x70(%rbp), %rdx
leaq 0xb72(%rip), %rsi       # 0x5025
leaq -0x48(%rbp), %rdi
callq 0x2230
jmp 0x44be
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2420
jmp 0x44cd
leaq -0x48(%rbp), %rdi
callq 0x20f0
leaq -0x49(%rbp), %rdi
callq 0x2210
xorps %xmm0, %xmm0
movss %xmm0, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
cmpl $0x186a0, -0x64(%rbp)   # imm = 0x186A0
jge 0x454b
callq 0x2050
cvtsi2ss %eax, %xmm0
callq 0x2150
addss -0x60(%rbp), %xmm0
movss %xmm0, -0x60(%rbp)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x44ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x453d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20f0
leaq -0x49(%rbp), %rdi
callq 0x2210
jmp 0x4600
movq 0x3a7e(%rip), %rdi      # 0x7fd0
leaq 0xad2(%rip), %rsi       # 0x502b
callq 0x21d0
movq %rax, -0x78(%rbp)
jmp 0x4564
movq -0x78(%rbp), %rdi
leaq 0x7e1(%rip), %rsi       # 0x4d50
callq 0x2070
movq %rax, -0x80(%rbp)
jmp 0x457a
movl $0x2, %edi
callq 0x4d80
movl %eax, -0x84(%rbp)
jmp 0x458c
movq -0x80(%rbp), %rdi
movl -0x84(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %esi
callq 0x2270
movq %rax, -0x90(%rbp)
jmp 0x45aa
movq -0x90(%rbp), %rdi
movss -0x60(%rbp), %xmm0
callq 0x2160
movq %rax, -0x98(%rbp)
jmp 0x45c4
movq -0x98(%rbp), %rdi
movq 0x39e6(%rip), %rsi      # 0x7fb8
callq 0x2200
jmp 0x45d9
leaq -0x28(%rbp), %rdi
callq 0x24a0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x24a0
movq -0x58(%rbp), %rdi
callq 0x22a0
nopl (%rax)
// File: sonnyit[P]profiler/example.cpp
// Function: func2()
void func2() {
  PROFILER_TASK(func2);

  float f = 0;
  for (int i = 0; i < 500000; ++i) {
    f += cosf(static_cast<float>(rand()));
  }
  cout << "fun2 output: " << fixed << setprecision(2) << f << endl;

  func1();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x22b0
movq -0x70(%rbp), %rdx
leaq 0xa06(%rip), %rsi       # 0x5039
leaq -0x48(%rbp), %rdi
callq 0x2230
jmp 0x463e
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2420
jmp 0x464d
leaq -0x48(%rbp), %rdi
callq 0x20f0
leaq -0x49(%rbp), %rdi
callq 0x2210
xorps %xmm0, %xmm0
movss %xmm0, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
cmpl $0x7a120, -0x64(%rbp)   # imm = 0x7A120
jge 0x46cb
callq 0x2050
cvtsi2ss %eax, %xmm0
callq 0x2150
addss -0x60(%rbp), %xmm0
movss %xmm0, -0x60(%rbp)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x466e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x46bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20f0
leaq -0x49(%rbp), %rdi
callq 0x2210
jmp 0x4787
movq 0x38fe(%rip), %rdi      # 0x7fd0
leaq 0x966(%rip), %rsi       # 0x503f
callq 0x21d0
movq %rax, -0x78(%rbp)
jmp 0x46e4
movq -0x78(%rbp), %rdi
leaq 0x661(%rip), %rsi       # 0x4d50
callq 0x2070
movq %rax, -0x80(%rbp)
jmp 0x46fa
movl $0x2, %edi
callq 0x4d80
movl %eax, -0x84(%rbp)
jmp 0x470c
movq -0x80(%rbp), %rdi
movl -0x84(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %esi
callq 0x2270
movq %rax, -0x90(%rbp)
jmp 0x472a
movq -0x90(%rbp), %rdi
movss -0x60(%rbp), %xmm0
callq 0x2160
movq %rax, -0x98(%rbp)
jmp 0x4744
movq -0x98(%rbp), %rdi
movq 0x3866(%rip), %rsi      # 0x7fb8
callq 0x2200
jmp 0x4759
callq 0x4490
jmp 0x4760
leaq -0x28(%rbp), %rdi
callq 0x24a0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x24a0
movq -0x58(%rbp), %rdi
callq 0x22a0
// File: pixlark[P]Badge/src/string-builder.cc
// Function: String_Builder::final_string()
char * String_Builder::final_string()
{
	char * str = (char*) malloc(sizeof(char) * (builder.size + 1));
	strncpy(str, builder.arr, builder.size);
	str[builder.size] = '\0';
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x11f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x10b0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pixlark[P]Badge/src/intern.cc
// Function: Intern::intern(char const*)
Symbol intern(const char * s)
	{
		for (int i = 0; i < interns.size; i++) {
			if (strcmp(s, interns[i]) == 0) {
				return interns[i];
			}
		}
		interns.push(strdup(s));
		return interns[interns.size - 1];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq 0x15ac2(%rip), %rax     # 0x17220
jae 0x17af
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rsi
leaq 0x15aa5(%rip), %rdi     # 0x17218
callq 0x6e80
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
callq 0x1160
cmpl $0x0, %eax
jne 0x17a2
movslq -0x14(%rbp), %rsi
leaq 0x15a84(%rip), %rdi     # 0x17218
callq 0x6e80
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x17e5
jmp 0x17a4
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1753
movq -0x10(%rbp), %rdi
callq 0x11d0
movq %rax, %rsi
leaq 0x15a56(%rip), %rdi     # 0x17218
callq 0x6f20
movq 0x15a52(%rip), %rsi     # 0x17220
subq $0x1, %rsi
leaq 0x15a3f(%rip), %rdi     # 0x17218
callq 0x6e80
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: pixlark[P]Badge/src/utility.cc
// Function: load_string_from_file(char const*)
char * load_string_from_file(const char * path)
{
	FILE * file = fopen(path, "r");
	if (file == NULL) return NULL;
	defer { fclose(file); };
	
	int file_len = 0;
	while (fgetc(file) != EOF) file_len++;
	char * str = (char*) Global_Alloc::alloc(file_len + 1);
	str[file_len] = '\0';
	fseek(file, 0, SEEK_SET);
	for (int i = 0; i < file_len; i++) str[i] = fgetc(file);

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xf1d2(%rip), %rsi      # 0x109f9
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1844
movq $0x0, -0x8(%rbp)
jmp 0x191a
leaq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1930
movl $0x0, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1190
movl %eax, -0x58(%rbp)
jmp 0x186e
movl -0x58(%rbp), %eax
cmpl $-0x1, %eax
je 0x189b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1860
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1970
jmp 0x1924
movl -0x34(%rbp), %eax
incl %eax
movslq %eax, %rdi
callq 0x1400
movq %rax, -0x60(%rbp)
jmp 0x18ae
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x1120
jmp 0x18d1
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x1909
movq -0x18(%rbp), %rdi
callq 0x1190
movl %eax, -0x64(%rbp)
jmp 0x18ee
movl -0x64(%rbp), %eax
movb %al, %dl
movq -0x50(%rbp), %rax
movslq -0x54(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x18d8
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1970
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x11c0
nopl (%rax)
// File: pixlark[P]Badge/src/utility.cc
// Function: itoa(int)
char * itoa(int integer)
{
	size_t size = snprintf(NULL, 0, "%d", integer);
	char * buf = (char*) malloc(sizeof(char) * (size + 1));
	sprintf(buf, "%d", integer);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
xorl %eax, %eax
movl %eax, %esi
leaq 0xf6a2(%rip), %rdx      # 0x1105b
movq %rsi, %rdi
movb $0x0, %al
callq 0x11a0
cltq
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x11f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x4(%rbp), %edx
leaq 0xf66f(%rip), %rsi      # 0x1105b
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/error.cc
// Function: error(char const*, ...)
void error(const char * fmt, ...)
{
	va_list args;
	va_start(args, fmt);

	fprintf(stderr, RED(BOLD("encountered error")) ":\n");
	vfprintf(stderr, fmt, args);
	printf("\n");

	va_end(args);
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x1bb5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x153d9(%rip), %rax     # 0x16fe0
movq (%rax), %rdi
leaq 0xe852(%rip), %rsi      # 0x10463
movb $0x0, %al
callq 0x1180
movq 0x153c1(%rip), %rax     # 0x16fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1150
leaq 0xe850(%rip), %rdi      # 0x10486
movb $0x0, %al
callq 0x1030
leaq -0x20(%rbp), %rax
callq 0x10c0
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/error.cc
// Function: fatal(char const*, ...)
void fatal(const char * fmt, ...)
{
	va_list args;
	va_start(args, fmt);

	fprintf(stderr, RED(BOLD("encountered error")) ":\n");
	vfprintf(stderr, fmt, args);
	printf("\n");

	va_end(args);
	//exit(1);
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x1c85
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x15309(%rip), %rax     # 0x16fe0
movq (%rax), %rdi
leaq 0xe782(%rip), %rsi      # 0x10463
movb $0x0, %al
callq 0x1180
movq 0x152f1(%rip), %rax     # 0x16fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1150
leaq 0xe780(%rip), %rdi      # 0x10486
movb $0x0, %al
callq 0x1030
leaq -0x20(%rbp), %rax
callq 0x10c0
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/error.cc
// Function: print_assoc(Assoc)
void print_assoc(Assoc assoc)
{
	printf(DIM(":%zu\n"), assoc.line);
	size_t start = assoc.position;
	while (true) {
		if (start == 0) {
			break;
		}
		if (assoc.source[start - 1] == '\n') {
			break;
		}
		start--;
	}
	size_t end = assoc.position;
	while (true) {
		if (end == assoc.source_length - 1) {
			break;
		}
		if (assoc.source[end + 1] == '\n') {
			break;
		}
		end++;
	}
	// Line itself
	const char * selection = assoc.source + start;
	size_t selection_length = end - start + 1;
	printf(DIM("  %.*s\n"), (int) selection_length, selection);
	// Pointer char
	printf("  ");
	for (int i = 0; i < assoc.position - start; i++) {
		if (selection[i] == '\t') {
			printf("\t");
		} else {
			printf(" ");
		}
	}
	for (int i = 0; i < assoc.extents; i++) {
		printf(RED("^"));
	}
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x20(%rax), %rsi
leaq 0xe74d(%rip), %rdi      # 0x10488
movb $0x0, %al
callq 0x1030
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1d57
jmp 0x1d7f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1d71
jmp 0x1d7f
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1d4e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x1da2
jmp 0x1dc7
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1db9
jmp 0x1dc7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1d8b
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
subq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x18(%rbp), %rdx
leaq 0xe69f(%rip), %rdi      # 0x10496
movb $0x0, %al
callq 0x1030
leaq 0xe6a1(%rip), %rdi      # 0x104a6
movb $0x0, %al
callq 0x1030
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
movq 0x10(%rcx), %rcx
subq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jae 0x1e64
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x1e49
leaq 0xe669(%rip), %rdi      # 0x104a9
movb $0x0, %al
callq 0x1030
jmp 0x1e57
leaq 0xe657(%rip), %rdi      # 0x104a7
movb $0x0, %al
callq 0x1030
jmp 0x1e59
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1e13
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x28(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x1e92
leaq 0xe62b(%rip), %rdi      # 0x104ab
movb $0x0, %al
callq 0x1030
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1e6b
leaq 0xe5ed(%rip), %rdi      # 0x10486
movb $0x0, %al
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/error.cc
// Function: v_fatal_assoc(int, char const*, __va_list_tag*)
void v_fatal_assoc(Assoc_Ptr assoc, const char * fmt, va_list args)
{
	fprintf(stderr, RED(BOLD("encountered error")) ":\n");
	vfprintf(stderr, fmt, args);
	printf("\n");
	if (assoc != -1) {
		print_assoc(Assoc_Allocator::get(assoc));
	}
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x15116(%rip), %rax     # 0x16fe0
movq (%rax), %rdi
leaq 0xe58f(%rip), %rsi      # 0x10463
movb $0x0, %al
callq 0x1180
movq 0x150fe(%rip), %rax     # 0x16fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1150
leaq 0xe58d(%rip), %rdi      # 0x10486
movb $0x0, %al
callq 0x1030
cmpl $-0x1, -0x4(%rbp)
je 0x1f31
movl -0x4(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x1b10
movq -0x20(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x1d20
callq 0x10c0
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/files.cc
// Function: Files::destroy()
void destroy()
	{
		free((void*) stdlib_dir);
		free((void*) running_dir);
		free((void*) cwd);
		free((void*) first_file);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x14fd5(%rip), %rdi     # 0x17280
callq 0x11e8
movq 0x14fc1(%rip), %rdi     # 0x17278
callq 0x11e8
movq 0x14fad(%rip), %rdi     # 0x17270
callq 0x11e8
movq 0x14f99(%rip), %rdi     # 0x17268
callq 0x11e8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/files.cc
// Function: Files::stdlib_file(char const*)
const char * stdlib_file(const char * name)
	{
		String_Builder builder;
		builder.append(stdlib_dir);
		builder.append(name);
		builder.append(".bdg");
		return builder.final_string();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1450
movq -0x48(%rbp), %rdi
movq 0x14f7c(%rip), %rsi     # 0x17280
callq 0x14f0
jmp 0x230b
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x14f0
jmp 0x231a
leaq 0xe1c6(%rip), %rsi      # 0x104e7
leaq -0x30(%rbp), %rdi
callq 0x14f0
jmp 0x232c
leaq -0x30(%rbp), %rdi
callq 0x15c0
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1490
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1490
movq -0x38(%rbp), %rdi
callq 0x11c0
nopw (%rax,%rax)
// File: pixlark[P]Badge/src/files.cc
// Function: Files::path_for_file(char const*)
const char * path_for_file(const char * filename)
	{
		String_Builder builder;
		builder.append(running_dir);
		builder.append(filename);
		return builder.final_string();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1450
movq -0x48(%rbp), %rdi
movq 0x14ee4(%rip), %rsi     # 0x17278
callq 0x14f0
jmp 0x239b
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x14f0
jmp 0x23aa
leaq -0x30(%rbp), %rdi
callq 0x15c0
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1490
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1490
movq -0x38(%rbp), %rdi
callq 0x11c0
nopl (%rax,%rax)
// File: pixlark[P]Badge/src/lexer.cc
// Function: Token::type_to_string(Token_Kind)
char * Token::type_to_string(Token_Kind kind)
{
	if (kind < 256) {
		return Token::with_kind(kind).to_string();
	}
	
	if (kind >= RESERVED_WORDS_BEGIN && kind < RESERVED_WORDS_END) {
		return strdup(reserved_words[kind - RESERVED_WORDS_BEGIN]);
	}
	
	switch (kind) {
	case TOKEN_EOF:
		return strdup("EOF");
	case TOKEN_SYMBOL:
		return strdup("<symbol>");
	case TOKEN_INTEGER_LITERAL:
		return strdup("<integer>");
	case TOKEN_STRING_LITERAL:
		return strdup("<string>");
	default:
		fatal("Token::type_to_string() switch incomplete");
	}
	return NULL; // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x2426
movl -0xc(%rbp), %edi
callq 0x70d0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x24f0
movq %rax, -0x8(%rbp)
jmp 0x24e1
cmpl $0x105, -0xc(%rbp)      # imm = 0x105
jl 0x245c
cmpl $0x116, -0xc(%rbp)      # imm = 0x116
jge 0x245c
movl -0xc(%rbp), %eax
subl $0x105, %eax            # imm = 0x105
movslq %eax, %rcx
leaq 0x14cb6(%rip), %rax     # 0x17100
movq (%rax,%rcx,8), %rdi
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x24e1
movl -0xc(%rbp), %eax
addl $0xffffff00, %eax       # imm = 0xFFFFFF00
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x18, %eax
ja 0x24cb
movq -0x28(%rbp), %rax
leaq 0xdb8a(%rip), %rcx      # 0x10004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe062(%rip), %rdi      # 0x104ec
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x24e1
leaq 0xe054(%rip), %rdi      # 0x104f0
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x24e1
leaq 0xe04b(%rip), %rdi      # 0x104f9
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x24e1
leaq 0xe043(%rip), %rdi      # 0x10503
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x24e1
leaq 0xe03a(%rip), %rdi      # 0x1050c
movb $0x0, %al
callq 0x1c50
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pixlark[P]Badge/src/lexer.cc
// Function: Token::to_string()
char * Token::to_string()
{
	if (kind >= 0 && kind < 256) {
		char buf[2];
		buf[0] = kind;
		buf[1] = '\0';
		return strdup(buf);
	}
	switch (kind) {
	case TOKEN_SYMBOL: {
		return strdup(values.symbol);
	}
	case TOKEN_INTEGER_LITERAL: {
		return itoa(values.integer);
	}
	case TOKEN_STRING_LITERAL: {
		String_Builder builder;
		builder.append("string \"");
		builder.append(values.string);
		builder.append("\"");
		return builder.final_string();
	}
	default:
		return Token::type_to_string(kind);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, (%rax)
jl 0x2534
movq -0x58(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jge 0x2534
movq -0x58(%rbp), %rax
movl (%rax), %eax
movb %al, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x260e
movq -0x58(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
subl $0x116, %eax            # imm = 0x116
je 0x2561
jmp 0x2546
movl -0x5c(%rbp), %eax
subl $0x117, %eax            # imm = 0x117
je 0x2577
jmp 0x2552
movl -0x5c(%rbp), %eax
subl $0x118, %eax            # imm = 0x118
je 0x258c
jmp 0x25ff
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x260e
movq -0x58(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x19a0
movq %rax, -0x8(%rbp)
jmp 0x260e
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1450
movq -0x68(%rbp), %rdi
leaq 0xdf92(%rip), %rsi      # 0x10536
callq 0x14f0
jmp 0x25ab
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x14f0
jmp 0x25be
leaq 0xdf78(%rip), %rsi      # 0x1053d
leaq -0x40(%rbp), %rdi
callq 0x14f0
jmp 0x25d0
leaq -0x40(%rbp), %rdi
callq 0x15c0
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1490
jmp 0x260e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1490
jmp 0x2618
movq -0x58(%rbp), %rax
movl (%rax), %edi
callq 0x23f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x11c0
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/lexer.cc
// Function: Lexer::init(char const*)
void Lexer::init(const char * source)
{
	this->source = source;
	source_length = strlen(source);
	cursor = 0;
	line = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1080
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x1, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/lexer.cc
// Function: Lexer::advance()
void Lexer::advance()
{
	if (cursor >= source_length) {
		return;
	}
	if (source[cursor] == '\n') {
		line++;
	}
	cursor++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rcx), %rax
cmpq 0x8(%rcx), %rax
jb 0x276c
jmp 0x27a0
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq 0x10(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x2790
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/lexer.cc
// Function: Lexer::read_double_token(char, char, Token_Kind)
Token_Kind Lexer::read_double_token(char left, char right, Token_Kind double_type)
{
	assert(peek() == left);
	advance();
	if (peek() == right) {
		advance();
		return double_type;
	} else {
		return (Token_Kind) left;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %dl
movq %rdi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x2710
movsbl %al, %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3224
jmp 0x3243
leaq 0xd358(%rip), %rdi      # 0x10583
leaq 0xd360(%rip), %rsi      # 0x10592
movl $0x12b, %edx            # imm = 0x12B
leaq 0xd361(%rip), %rcx      # 0x1059f
callq 0x10d0
movq -0x20(%rbp), %rdi
callq 0x2750
movq -0x20(%rbp), %rdi
callq 0x2710
movsbl %al, %eax
movsbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3271
movq -0x20(%rbp), %rdi
callq 0x2750
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3278
movsbl -0x11(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/ast.cc
// Function: Expr_Binary::destroy()
void Expr_Binary::destroy()
{
	left->destroy();
	free(left);
	right->destroy();
	free(right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x70f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x11e8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70f0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11e8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pixlark[P]Badge/src/ast.cc
// Function: Expr_Scope::destroy()
void Expr_Scope::destroy()
{
	for (int i = 0; i < body.size; i++) {
		body[i]->destroy();
		free(body[i]);
	}
	body.dealloc();
	if (terminator) {
		terminator->destroy();
		free(terminator);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x336e
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x71e0
movq (%rax), %rdi
callq 0x33b0
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x71e0
movq (%rax), %rdi
callq 0x11e8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x332b
movq -0x18(%rbp), %rdi
callq 0x7240
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x339c
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x70f0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x11e8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/ast.cc
// Function: Stmt::destroy()
void Stmt::destroy()
{
	switch (kind) {
	case STMT_LET:
		let.destroy();
		break;
	case STMT_SET:
		set.destroy();
		break;
	case STMT_RETURN:
		_return.destroy();
		break;
	case STMT_EXPR:
		expr->destroy();
		free(expr);
		break;
	case STMT_BREAK:
		_break->destroy();
		free(_break);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x4, %rax
ja 0x3447
movq -0x10(%rbp), %rax
leaq 0xce01(%rip), %rcx      # 0x101dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3790
jmp 0x3447
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x37c0
jmp 0x3447
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3810
jmp 0x3447
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70f0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11e8
jmp 0x3447
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70f0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11e8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/ast.cc
// Function: Expr_Funcall::destroy()
void Expr_Funcall::destroy()
{
	func->destroy();
	free(func);
	
	for (int i = 0; i < args.size; i++) {
		args[i]->destroy();
		free(args[i]);
	}
	args.dealloc();
	
	for (int i = 0; i < flags.size; i++) {
		flags[i].expr->destroy();
		free(flags[i].expr);
	}
	flags.dealloc();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
callq 0x70f0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x11e8
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x350a
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x7280
movq (%rax), %rdi
callq 0x70f0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x7280
movq (%rax), %rdi
callq 0x11e8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x34bf
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x72e0
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movslq -0x10(%rbp), %rax
cmpq 0x38(%rcx), %rax
jae 0x356b
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0x7320
movq 0x8(%rax), %rdi
callq 0x70f0
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movslq -0x10(%rbp), %rsi
callq 0x7320
movq 0x8(%rax), %rdi
callq 0x11e8
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x351e
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x7380
addq $0x20, %rsp
popq %rbp
retq
nop
// File: pixlark[P]Badge/src/ast.cc
// Function: Expr_If::destroy()
void Expr_If::destroy()
{
	for (int i = 0; i < conditions.size; i++) {
		conditions[i]->destroy();
		free(conditions[i]);
	}
	conditions.dealloc();
	
	for (int i = 0; i < expressions.size; i++) {
		expressions[i]->destroy();
		free(expressions[i]);
	}
	expressions.dealloc();

	if (else_expr) {
		else_expr->destroy();
		free(else_expr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x35de
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x7280
movq (%rax), %rdi
callq 0x70f0
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x7280
movq (%rax), %rdi
callq 0x11e8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x359b
movq -0x18(%rbp), %rdi
callq 0x72e0
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movslq -0x10(%rbp), %rax
cmpq 0x30(%rcx), %rax
jae 0x3639
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x7280
movq (%rax), %rdi
callq 0x70f0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movslq -0x10(%rbp), %rsi
callq 0x7280
movq (%rax), %rdi
callq 0x11e8
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x35ee
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x72e0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x366b
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x70f0
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x11e8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/ast.cc
// Function: Expr_Directive::destroy()
void Expr_Directive::destroy()
{
	for (int i = 0; i < arguments.size; i++) {
		arguments[i]->destroy();
		free(arguments[i]);
	}
	arguments.dealloc();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x36e6
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x7280
movq (%rax), %rdi
callq 0x70f0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x7280
movq (%rax), %rdi
callq 0x11e8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x369b
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x72e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/ast.cc
// Function: Stmt_Set::destroy()
void Stmt_Set::destroy()
{
	left->destroy();
	free(left);
	right->destroy();
	free(right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x70f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x11e8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11e8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pixlark[P]Badge/src/ast.cc
// Function: Stmt::with_kind(Stmt_Kind, int)
Stmt * Stmt::with_kind(Stmt_Kind kind, Assoc_Ptr assoc)
{
	Stmt * stmt = (Stmt*) malloc(sizeof(Stmt));
	stmt->kind = kind;
	stmt->assoc = assoc;
	return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x18, %edi
callq 0x11f0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_atom()
Expr * Parser::parse_atom()
{
	if (match('(')) {
		auto expr = parse_expr();
		expect(')');
		return expr;
	}
	switch (peek.kind) {
	case TOKEN_NOTHING: {
		auto atom = create_expr(EXPR_NOTHING);
		advance();
		return atom;
	} break;
	case TOKEN_INTEGER_LITERAL: {
		auto atom = create_expr(EXPR_INTEGER);
		atom->integer = peek.values.integer;
		advance();
		return atom;
	} break;
	case TOKEN_STRING_LITERAL: {
		auto atom = create_expr(EXPR_STRING);
		atom->string = peek.values.string;
		advance();
		return atom;
	} break;
	case TOKEN_SYMBOL: {
		auto atom = create_expr(EXPR_VARIABLE);
		atom->variable = peek.values.symbol;
		advance();
		return atom;
	} break;
	case TOKEN_THIS: {
		auto atom = create_expr(EXPR_THIS);
		advance();
		return atom;
	} break;
	default:
		fatal_assoc(peek.assoc, "Expected <int>, <symbol>; got %s", peek.to_string());
	}
	return NULL; // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x28, %esi
callq 0x73c0
testb $0x1, %al
jne 0x38a4
jmp 0x38d4
movq -0x58(%rbp), %rdi
callq 0x3a20
movq -0x58(%rbp), %rdi
movq %rax, -0x18(%rbp)
movl $0x29, %esi
callq 0x73f0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a13
movq -0x58(%rbp), %rax
movl 0x8(%rax), %eax
addl $0xfffffef7, %eax       # imm = 0xFFFFFEF7
movl %eax, %ecx
movq %rcx, -0x60(%rbp)
subl $0xf, %eax
ja 0x39e4
movq -0x60(%rbp), %rax
leaq 0xc8f6(%rip), %rcx      # 0x101f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x3a40
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x3a70
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a13
movq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0x3a40
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl 0x10(%rdi), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
callq 0x3a70
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a13
movq -0x58(%rbp), %rdi
movl $0x2, %esi
callq 0x3a40
movq -0x58(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq 0x10(%rdi), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x3a70
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a13
movq -0x58(%rbp), %rdi
movl $0x3, %esi
callq 0x3a40
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq 0x10(%rdi), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x3a70
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a13
movq -0x58(%rbp), %rdi
movl $0xb, %esi
callq 0x3a40
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x3a70
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a13
movq -0x58(%rbp), %rdi
movl 0xc(%rdi), %eax
movl %eax, -0x64(%rbp)
addq $0x8, %rdi
callq 0x24f0
movl -0x64(%rbp), %edi
movq %rax, %rdx
leaq 0xcbd7(%rip), %rsi      # 0x105db
movb $0x0, %al
callq 0x1f40
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_field_access()
Expr * Parser::parse_field_access()
{
	auto left = parse_atom();
	while (match('\'')) {
		auto expr = create_expr(EXPR_FIELD);
		expr->field.left = left;
		weak_expect(TOKEN_SYMBOL);
		expr->field.right = peek.values.symbol;
		advance();
		left = expr;
	}
	return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3880
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
movl $0x27, %esi
callq 0x73c0
testb $0x1, %al
jne 0x3af1
jmp 0x3b44
movq -0x30(%rbp), %rdi
movl $0xc, %esi
callq 0x3a40
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x116, %esi            # imm = 0x116
callq 0x3b50
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq 0x10(%rdi), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x3a70
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3add
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop