LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/Dictionary.hpp
// Function: (anonymous namespace)::Trie<std::shared_ptr<Object>>::erase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) const
shared_ptr<Trie<T>> erase(const string& str, int i = 0) const {
      shared_ptr<Trie<T>> newNode(new Trie<T>(*this));
      if(i == str.size()){
        newNode->endHere = false;
      }else{
        char c = str[i];
        auto branch = branches.find(c);
        if(branch != branches.end()){
          newNode->branches[c] = branch->second->erase(str, i+1);
        }
      }
      return newNode;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x50, %edi
callq 0x31c0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x3340
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7118
movslq %ebp, %rax
cmpq %rax, 0x8(%r14)
jne 0x7737
movq (%rbx), %rax
movb $0x0, 0x38(%rax)
jmp 0x77be
movq (%r14), %rcx
movsbq (%rcx,%rax), %rcx
movb %cl, 0xf(%rsp)
movq (%r15), %rdi
movq 0x8(%r15), %r8
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x77be
movq (%rax), %r9
cmpb %cl, 0x8(%r9)
je 0x7786
movq %rdx, %rsi
movq (%r9), %r9
testq %r9, %r9
je 0x77be
movsbq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
cmpq %rsi, %rdx
jne 0x77be
cmpb %cl, %dil
jne 0x7767
movq 0x10(%r9), %rsi
incl %ebp
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x76e8
movq (%rbx), %rdi
leaq 0xf(%rsp), %rsi
callq 0x748a
movq 0x8(%rax), %rdi
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rax)
testq %rdi, %rdi
je 0x77be
callq 0x9e7a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x77e2
callq 0x9e7a
jmp 0x77e2
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7802
callq 0x9e7a
jmp 0x7802
movq %rax, %r14
movl $0x50, %esi
movq %r12, %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::Parser::operator[](std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>) const
Parser Parser::operator [] (function<void (const std::string&)> f) const {
  auto parser = this->runParser;
  return Parser([f, parser](Parser::Iterator first, Parser::Iterator last){
    bool good;
    Parser::Iterator second;
    std::tie(good, second) = parser(first, last);
    if(! good) return badParse(second);
    f({first, second});
    return goodParse(second);
  });
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
callq 0xd928
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xd986
leaq 0x48(%rsp), %r14
leaq 0x68(%rsp), %rsi
movq %r14, %rdi
callq 0xd928
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x40, %edi
callq 0x31c0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x38(%rsp), %rcx
testq %rcx, %rcx
je 0xa326
leaq 0x38(%rsp), %rdx
movups -0x10(%rdx), %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x58(%rsp), %rcx
testq %rcx, %rcx
je 0xa35f
movq %rax, %rdx
addq $0x20, %rdx
leaq 0x58(%rsp), %rsi
movups (%r14), %xmm1
movups %xmm1, (%rdx)
movq %rcx, 0x30(%rax)
movups %xmm0, (%rsi)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x25c6(%rip), %rax      # 0xc932
movq %rax, 0x18(%rsi)
leaq 0x2693(%rip), %rax      # 0xca0a
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xd928
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa39a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0xa3b1
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa3ca
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0xa3e3
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
jmp 0xa46a
jmp 0xa46a
jmp 0xa46a
jmp 0xa46a
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa41a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa41a
jmp 0xa46a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa472
jmp 0xa449
movq %rax, %rbx
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xa449
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa449
jmp 0xa46a
movq %rax, %rbx
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0xa462
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rdi
callq 0x9c1b
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::operator|(Parsers::Parser, Parsers::Parser)
Parser operator | (Parser f, Parser g){
  return Parser([f, g](Parser::Iterator first, Parser::Iterator last){
    bool good;
    Parser::Iterator _first;
    std::tie(good, _first) = f.runParser(first, last);
    if(good) return goodParse(_first);
    std::tie(good, first) = g.runParser(first, last);
    if(good) return goodParse(first);
    return badParse(first);
  });
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd928
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xd928
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x40, %edi
callq 0x31c0
movq %rax, %r15
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0xd928
movq %r15, %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0xd928
movq %rsp, %rsi
movq %r15, (%rsi)
leaq 0x2b08(%rip), %rax      # 0xd0da
movq %rax, 0x18(%rsi)
leaq 0x2ba5(%rip), %rax      # 0xd182
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xd928
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa600
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0xa617
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xa630
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xa6e5
jmp 0xa6e5
jmp 0xa6e5
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa6b5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa6b5
jmp 0xa6e5
movq %rax, %rbx
movq 0x10(%r15), %rax
testq %rax, %rax
je 0xa68a
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa68a
jmp 0xa6e5
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x31d0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa6b5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa6b5
jmp 0xa6e5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb02a
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xa6bf
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa6bf
movq %rax, %rdi
callq 0x9c1b
nop
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::say(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>)
Parser say(const std::string& msg, std::function<void (const std::string&)> f){
  return Parser([msg, f](Parser::Iterator _, Parser::Iterator __){
    f(msg);
    return goodParse(_);
  });
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x9f6e
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xd986
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x40, %edi
callq 0x31c0
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x9f6e
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movq $0x0, 0x30(%r15)
movq 0x60(%rsp), %rax
movq %rax, 0x38(%r15)
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0xa891
movq %r15, %rcx
addq $0x20, %rcx
leaq 0x58(%rsp), %rdx
movups (%r14), %xmm1
movups %xmm1, (%rcx)
movq %rax, 0x30(%r15)
movups %xmm0, (%rdx)
movq %rsp, %rsi
movq %r15, (%rsi)
leaq 0x227e(%rip), %rax      # 0xcb1c
movq %rax, 0x18(%rsi)
leaq 0x22a5(%rip), %rax      # 0xcb4e
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xd928
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa8cc
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0xa8e3
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xa8fa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xa954
jmp 0xa954
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa95f
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa95f
jmp 0xa954
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x31d0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xa95f
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xa95f
movq %rax, %rdi
callq 0x9c1b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xa98e
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xa969
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31d0
jmp 0xa969
nop
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::word(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Parser word(const std::string& str){
  Parser accu;
  for(char c : str)
    accu = accu >> charp(c);
  return accu;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x1f23(%rip), %rax      # 0xc90c
movq %rax, 0x18(%rdi)
leaq 0x1f26(%rip), %rax      # 0xc91a
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xaaaf
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x38(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x58(%rsp), %r12
movq 0x8(%rsp), %rax
movb (%rax,%rbp), %r13b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd928
movsbl %r13b, %esi
movq %r15, %rdi
callq 0xa75f
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xab59
movq %rbx, %rdi
movq %r12, %rsi
callq 0xdbca
movq 0x68(%rsp), %rax
testq %rax, %rax
je 0xaa73
movq %r12, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq *%rax
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0xaa8a
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0xaaa1
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
incq %rbp
cmpq %rbp, 0x10(%rsp)
jne 0xaa23
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xab51
jmp 0xab51
jmp 0xab51
movq %rax, %r14
jmp 0xab2d
movq %rax, %r14
jmp 0xab14
movq %rax, %r14
jmp 0xaafb
movq %rax, %r14
movq 0x68(%rsp), %rax
testq %rax, %rax
je 0xaafb
leaq 0x58(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0xab14
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0xab2d
leaq 0x38(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0xab43
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x32d0
jmp 0xab51
jmp 0xab51
jmp 0xab51
movq %rax, %rdi
callq 0x9c1b
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::operator>>(Parsers::Parser, Parsers::Parser)
Parser operator >> (Parser f, Parser g){
  return Parser([f, g](Parser::Iterator first, Parser::Iterator last){
    bool good;
    std::tie(good, first) = f.runParser(first, last);
    if(! good) return badParse(first);
    std::tie(good, first) = g.runParser(first, last);
    if(! good) return badParse(first);
    return goodParse(first);
  });
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0xd928
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xd928
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x40, %edi
callq 0x31c0
movq %rax, %r15
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0xd928
movq %r15, %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0xd928
movq %rsp, %rsi
movq %r15, (%rsi)
leaq 0x2386(%rip), %rax      # 0xcf4a
movq %rax, 0x18(%rsi)
leaq 0x241f(%rip), %rax      # 0xcfee
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xd928
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xabf2
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0xac09
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xac22
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xacd7
jmp 0xacd7
jmp 0xacd7
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaca7
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xaca7
jmp 0xacd7
movq %rax, %rbx
movq 0x10(%r15), %rax
testq %rax, %rax
je 0xac7c
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xac7c
jmp 0xacd7
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x31d0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaca7
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xaca7
jmp 0xacd7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xafec
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xacb1
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xacb1
movq %rax, %rdi
callq 0x9c1b
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::many(Parsers::Parser)
Parser many(Parser parser){
  return Parser([parser](Parser::Iterator first, Parser::Iterator last){
    bool good = true;
    Parser::Iterator second = first;
    while(good){
      std::tie(good, second) = parser.runParser(first, last);
      swap(first, second);
    }
    return goodParse(second);
  });
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0xd928
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x20, %edi
callq 0x31c0
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0xd928
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x2092(%rip), %rax      # 0xce2c
movq %rax, 0x18(%rsi)
leaq 0x2101(%rip), %rax      # 0xcea6
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xd928
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xadc8
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xade1
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0xae5d
jmp 0xae5d
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xae3c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xae3c
jmp 0xae5d
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x31d0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xae3c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xae3c
jmp 0xae5d
movq %rax, %rbx
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xae55
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rdi
callq 0x9c1b
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::some(Parsers::Parser)
Parser some(Parser parser){
  return Parser([parser](Parser::Iterator first, Parser::Iterator last){
    bool good;
    std::tie(good, first) = parser.runParser(first, last);
    if(! good) return badParse(first);
    std::tie(ignore, first) = many(parser).runParser(first, last);
    return goodParse(first);
  });
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0xd928
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x20, %edi
callq 0x31c0
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0xd928
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x1d2c(%rip), %rax      # 0xcc4c
movq %rax, 0x18(%rsi)
leaq 0x1e5d(%rip), %rax      # 0xcd88
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xd928
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xaf4e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xaf67
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0xafe3
jmp 0xafe3
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xafc2
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xafc2
jmp 0xafe3
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x31d0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xafc2
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xafc2
jmp 0xafe3
movq %rax, %rbx
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0xafdb
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rdi
callq 0x9c1b
nop
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::satisfy(std::function<bool (char)>)
Parser satisfy(std::function<bool (char)> f){
  return Parser([f](Parser::Iterator first, Parser::Iterator last){
    if(first == last) return badParse(first);
    if(! f( *first )) return badParse(first);
    return goodParse(++first);
  });
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xda02
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x20, %edi
callq 0x31c0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
je 0xb0c5
leaq 0x10(%rsp), %rdx
movups -0x10(%rdx), %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x23d8(%rip), %rax      # 0xd4ac
movq %rax, 0x18(%rsi)
leaq 0x2415(%rip), %rax      # 0xd4f4
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xd928
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xb104
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb11b
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
jmp 0xb16a
jmp 0xb16a
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xb14b
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xb14b
jmp 0xb16a
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb162
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x32d0
movq %rax, %rdi
callq 0x9c1b
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/Parsers.hpp
// Function: Parsers::oneOf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Parser oneOf(const std::string& sig){
  return Parser([sig](Parser::Iterator first, Parser::Iterator last){
    if(first == last) return badParse(first);
    if(find(sig.begin(), sig.end(), *first) == sig.end())
      return badParse(first);
    return goodParse(++first);
  });
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x9f6e
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq (%r14), %r15
movq 0x8(%r14), %r12
movl $0x20, %edi
callq 0x31c0
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
addq %r15, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x9f6e
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x20b2(%rip), %rax      # 0xd29c
movq %rax, 0x18(%rsi)
leaq 0x20f1(%rip), %rax      # 0xd2e6
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0xd928
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb218
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xb22f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xb289
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb294
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xb294
jmp 0xb289
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x31d0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xb294
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xb294
movq %rax, %rdi
callq 0x9c1b
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xb2ab
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: Scanner::Scanner(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Scanner::Scanner(const string& buffer){
  auto first = buffer.begin(), last = buffer.end();
  Token token;
  while(first != last){
    tie(ignore, first) = spaces.runParser(first, last);
    if(first == last) break;
    tie(ignore, first) = tokenParser(token).runParser(first, last);
    if(token.type != Token::Undefined)
      tokens.push_back(token);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
callq 0xdc30
movq (%r14), %rbx
movq 0x8(%r14), %r14
leaq 0x38(%rsp), %rax
movl $0x0, -0x18(%rax)
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
testq %r14, %r14
je 0xbdfb
addq %rbx, %r14
leaq 0x48(%rsp), %r15
leaq 0x68(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0x20(%rsp), %rbp
movq %rbx, 0x68(%rsp)
movq %r14, 0x10(%rsp)
cmpq $0x0, 0x953f(%rip)      # 0x15290
je 0xbe0a
movq %r15, %rdi
leaq 0x951f(%rip), %rsi      # 0x15280
movq %r12, %rdx
movq %r13, %rcx
callq *0x952b(%rip)           # 0x15298
movq 0x48(%rsp), %rbx
cmpq %rbx, %r14
je 0xbddf
movq %r15, %rdi
movq %rbp, %rsi
callq 0xb3f4
movq %rbx, 0x10(%rsp)
movq %r14, 0x18(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0xbe0f
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
leaq 0x18(%rsp), %rcx
callq *0x60(%rsp)
movq 0x68(%rsp), %rbx
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0xbdc2
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x0, 0x20(%rsp)
je 0xbdd6
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0xda60
cmpq %rbx, %r14
jne 0xbd3f
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xbdfb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31d0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x30b0
callq 0x30b0
jmp 0xbe44
jmp 0xbe3a
jmp 0xbe44
jmp 0xbe1c
movq %rax, %r14
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0xbe47
leaq 0x48(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xbe47
movq %rax, %rdi
callq 0x9c1b
jmp 0xbe44
movq %rax, %r14
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xbe63
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31d0
movq 0x8(%rsp), %rdi
callq 0x9c26
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: Scanner::getToken()
Token Scanner::getToken(){
  if(tokens.empty()) return Token(Token::EndOfFile, "EOF");
  Token token = tokens.front();
  tokens.pop_front();
  return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rsi), %rax
cmpq %rax, 0x30(%rsi)
je 0xbeb9
movq %rsi, %r14
movl (%rax), %ecx
movl %ecx, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
callq 0x9f6e
movq %r14, %rdi
callq 0xdac4
jmp 0xbf12
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3b5e(%rip), %rsi      # 0xfa27
leaq 0x3b5a(%rip), %rdx      # 0xfa2a
movq %rsp, %r14
movq %r14, %rdi
callq 0xa11a
movl $0x7, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x9f6e
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xbf12
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xbf38
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: Expression::print() const
void Expression::print() const {
  switch(type){
    case Constant:
      cout << "[\"int\"," << val << "]";
      break;
    case Var:
      cout << "[\"var\",\"" << name << "\"]";
      break;
    case Lambda:
      cout << "[\"lam\",\"" << name << "\",";
      body->print();
      cout << "]";
      break;
    case Ap:
      cout << "[\"app\",";
      body->print();
      cout << ",";
      arg->print();
      cout << "]";
      break;
    case Nothing:
      cerr << "[Expression] Unexpected expression type: Nothing" << endl;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0xc196
movq %rdi, %rbx
leaq 0x3640(%rip), %rcx      # 0xf670
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8fb0(%rip), %rbx      # 0x14ff0
leaq 0x3a09(%rip), %rsi      # 0xfa50
movl $0x30, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3130
movq 0x8f3f(%rip), %r14      # 0x14fc8
leaq 0x39b8(%rip), %rsi      # 0xfa48
movl $0x7, %edx
movq %r14, %rdi
callq 0x31f0
movq 0x28(%rbx), %rdi
callq 0xc016
leaq 0x39a1(%rip), %rsi      # 0xfa4e
movl $0x1, %edx
movq %r14, %rdi
callq 0x31f0
movq 0x30(%rbx), %rdi
jmp 0xc13a
movq 0x8f01(%rip), %r14      # 0x14fc8
leaq 0x395d(%rip), %rsi      # 0xfa2b
movl $0x7, %edx
movq %r14, %rdi
callq 0x31f0
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x32c0
leaq 0x3950(%rip), %rsi      # 0xfa3d
movl $0x1, %edx
jmp 0xc187
movq 0x8eca(%rip), %r14      # 0x14fc8
leaq 0x393a(%rip), %rsi      # 0xfa3f
movl $0x8, %edx
movq %r14, %rdi
callq 0x31f0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x31f0
leaq 0x3924(%rip), %rsi      # 0xfa4d
movl $0x2, %edx
movq %rax, %rdi
callq 0x31f0
movq 0x28(%rbx), %rdi
callq 0xc016
leaq 0x38f7(%rip), %rsi      # 0xfa3d
movl $0x1, %edx
movq %r14, %rdi
jmp 0xc18a
movq 0x8e71(%rip), %r14      # 0x14fc8
leaq 0x38d5(%rip), %rsi      # 0xfa33
movl $0x8, %edx
movq %r14, %rdi
callq 0x31f0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x31f0
leaq 0x38ba(%rip), %rsi      # 0xfa3c
movl $0x2, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: Expression::prettyPrint() const
void Expression::prettyPrint() const {
  switch(type){
    case Var:
      cout << name;
      return ;
    case Constant:
      cout << val;
      return ;
    case Lambda:
      cout << "\\" << name << " ";
      body->prettyPrint();
      return ;
    case Ap:
      if(body->isLam() || body->isAp()) cout << "(";
      body->prettyPrint();
      if(body->isLam() || body->isAp()) cout << ")";
      cout << " ";
      if(arg->isLam() || arg->isAp()) cout << "(";
      arg->prettyPrint();
      if(arg->isLam() || arg->isAp()) cout << ")";
      return ;
    case Nothing:
      cerr << "[Expression] Unexpected expression type: Nothing" << endl;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8e18(%rip), %r14      # 0x14fc8
leaq 0x38ca(%rip), %r15      # 0xfa81
leaq 0x3205(%rip), %r12      # 0xf3c3
movl (%rbx), %eax
cmpl $0x3, %eax
jne 0xc1fb
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x31f0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %r14, %rdi
callq 0x31f0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x31f0
movq 0x28(%rbx), %rbx
jmp 0xc1be
cmpl $0x4, %eax
ja 0xc35e
movl %eax, %eax
leaq 0x3477(%rip), %rcx      # 0xf684
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8dd3(%rip), %rbx      # 0x14ff0
leaq 0x382c(%rip), %rsi      # 0xfa50
movl $0x30, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3130
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq 0x8d56(%rip), %rdi      # 0x14fc8
jmp 0xc34e
movl 0x4(%rbx), %esi
movq 0x8d47(%rip), %rdi      # 0x14fc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x32c0
movq 0x28(%rbx), %rdi
movl (%rdi), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xc2bb
movq 0x8d22(%rip), %rdi      # 0x14fc8
leaq 0x37d6(%rip), %rsi      # 0xfa83
movl $0x1, %edx
callq 0x31f0
movq 0x28(%rbx), %rdi
callq 0xc19e
movq 0x28(%rbx), %rax
movl (%rax), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xc2e6
movq 0x8cf3(%rip), %rdi      # 0x14fc8
leaq 0x3879(%rip), %rsi      # 0xfb55
movl $0x1, %edx
callq 0x31f0
movq 0x8cdb(%rip), %rdi      # 0x14fc8
leaq 0x30cf(%rip), %rsi      # 0xf3c3
movl $0x1, %edx
callq 0x31f0
movq 0x30(%rbx), %rdi
movl (%rdi), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xc328
movq 0x8cb5(%rip), %rdi      # 0x14fc8
leaq 0x3769(%rip), %rsi      # 0xfa83
movl $0x1, %edx
callq 0x31f0
movq 0x30(%rbx), %rdi
callq 0xc19e
movq 0x30(%rbx), %rax
movl (%rax), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0xc35e
movq 0x8c86(%rip), %rdi      # 0x14fc8
leaq 0x380c(%rip), %rsi      # 0xfb55
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: parseExpression(Scanner&)
Expression * parseExpression(Scanner &scanner){
  Expression * expr(parseExpressionTail(scanner));
  if(expr == nullptr){
    cerr << "[Parse expression] Unexpected token: " << scanner.peekToken().name << endl;
    exit(1);
    return nullptr;
  }
  while(true){
    Expression * expr1(parseExpressionTail(scanner));
    if(expr1 == nullptr){
      return expr;
    }else{
      Expression * expr2(new Expression(Expression::Ap));
      expr2->body = expr;
      expr2->arg  = expr1;
      expr = expr2;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xc46a
testq %rax, %rax
je 0xc3f1
movq %rax, %r14
movq %rbx, %rdi
callq 0xc46a
testq %rax, %rax
je 0xc3df
movq %rax, %r15
movl $0x38, %edi
callq 0x31c0
movq %rax, %r12
movl $0x4, (%rax)
addq $0x18, %rax
movq %rax, 0x8(%r12)
movq $0x0, 0x10(%r12)
movb $0x0, 0x18(%r12)
movq %r14, 0x28(%r12)
movq %r15, 0x30(%r12)
movq %rbx, %rdi
callq 0xc46a
movq %rax, %r15
movq %r12, %r14
testq %rax, %rax
jne 0xc395
jmp 0xc3e2
movq %r14, %r12
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8bf8(%rip), %r14      # 0x14ff0
leaq 0x3686(%rip), %rsi      # 0xfa85
movl $0x25, %edx
movq %r14, %rdi
callq 0x31f0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xbf40
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x30d0
movq %rsp, %rdi
callq 0xdaa8
movl $0x1, %edi
callq 0x3200
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc462
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31d0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/silverneko[P]Lambda-calculus-interpreter/src/ExpressionParser.cpp
// Function: int stringTo<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T stringTo(const string& str){
  istringstream iss(str);
  T res;
  iss >> res;
  return res;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x32b0
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x3110
movl 0xc(%rsp), %ebx
movq 0x7439(%rip), %rsi      # 0x14fb8
leaq 0x10(%rsp), %rdi
callq 0x3240
leaq 0x88(%rsp), %rdi
callq 0x3090
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0x740d(%rip), %rsi      # 0x14fb8
leaq 0x10(%rsp), %rdi
callq 0x3240
leaq 0x88(%rsp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O3/thjaeger[P]bindbutton/bindbutton.cc
// Function: parse_args(int, char**)
void parse_args(int argc, char **argv) {
	if ((argc % 3) != 1 || argc <= 3) {
		usage(argv[0]);
		exit(EXIT_SUCCESS);
	}
	for (int i = 0; 3*i+3 < argc; i++) {
		Commands cmds;
		cmds.press = argv[3*i+2];
		cmds.release = argv[3*i+3];
		int button = atoi(argv[3*i+1]);
		if (!button) {
			usage(argv[0]);
			exit(EXIT_FAILURE);
		}
		commands[button] = cmds;
	}
	debug = !!getenv("DEBUG");
	always_grab = !!getenv("ALWAYS_GRAB");
	device_name = getenv("DEVICE");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x4, %edi
jl 0x2720
movl %edi, %ebp
movslq %edi, %rax
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
cmpl $0x1, %eax
jne 0x2720
movl $0x3, %r12d
leaq 0x4(%rsp), %r15
leal -0x3(%r12), %r13d
movq 0x8(%rbx,%r13,8), %rdi
callq 0x2200
testl %eax, %eax
je 0x270e
movl %r12d, %ecx
movq (%rbx,%rcx,8), %r14
movq 0x10(%rbx,%r13,8), %r13
movl %eax, 0x4(%rsp)
leaq 0x3ad0(%rip), %rdi      # 0x6178
movq %r15, %rsi
callq 0x2c0a
movq %r13, (%rax)
movq %r14, 0x8(%rax)
addq $0x3, %r12
cmpl %ebp, %r12d
jl 0x267e
leaq 0x19c4(%rip), %rdi      # 0x408b
callq 0x21a0
testq %rax, %rax
setne 0x3a7a(%rip)            # 0x6150
leaq 0x19b4(%rip), %rdi      # 0x4091
callq 0x21a0
testq %rax, %rax
setne 0x3a65(%rip)            # 0x6151
leaq 0x19aa(%rip), %rdi      # 0x409d
callq 0x21a0
movq %rax, 0x3a59(%rip)      # 0x6158
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
callq 0x2616
movl $0x1, %edi
callq 0x2190
movq (%rbx), %rdi
callq 0x2616
xorl %edi, %edi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/thjaeger[P]bindbutton/bindbutton.cc
// Function: grab_buttons()
void grab_buttons() {
	if (always_grab) {
		printf("Grabbing XInput devices...\n");
		for (std::list<XiDevice>::iterator j = devices.begin(); j != devices.end(); j++)
			j->grab();
	}
	for (std::map<unsigned int, Commands>::iterator i = commands.begin(); i != commands.end(); i++) {
		XGrabButton(dpy, i->first, AnyModifier, ROOT, False, ButtonPressMask,
				GrabModeSync, GrabModeAsync, None, None);
		if (always_grab)
			continue;
		for (std::list<XiDevice>::iterator j = devices.begin(); j != devices.end(); j++) {
			if (i->first > j->num_buttons)
				continue;
			XGrabDeviceButton(dpy, j->dev, i->first, AnyModifier, NULL,
					ROOT, False, 2, j->classes, GrabModeAsync, GrabModeAsync);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x1, 0x3a12(%rip)      # 0x6151
jne 0x276e
leaq 0x1a43(%rip), %rdi      # 0x418b
callq 0x21f0
movq 0x3a0c(%rip), %rbx      # 0x6160
leaq 0x3a05(%rip), %r14      # 0x6160
cmpq %r14, %rbx
je 0x276e
leaq 0x10(%rbx), %rdi
callq 0x2c70
movq (%rbx), %rbx
jmp 0x275b
movq 0x3a1b(%rip), %rbx      # 0x6190
leaq 0x3a04(%rip), %r14      # 0x6180
cmpq %r14, %rbx
je 0x2860
leaq 0x39d4(%rip), %r15      # 0x6160
movl $0x1, %r12d
movq 0x39af(%rip), %rdi      # 0x6148
movl 0x20(%rbx), %esi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rcx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, (%rsp)
movl $0x8000, %edx           # imm = 0x8000
xorl %r8d, %r8d
movl $0x4, %r9d
callq 0x2230
addq $0x20, %rsp
movq (%r15), %r13
cmpq %r15, %r13
sete %al
orb 0x395d(%rip), %al       # 0x6151
jne 0x284c
movl 0x20(%rbx), %edx
cmpl 0x30(%r13), %edx
ja 0x2843
movq 0x3942(%rip), %rdi      # 0x6148
movq 0x10(%r13), %rsi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %r9
leaq 0x18(%r13), %rax
subq $0x8, %rsp
movl $0x8000, %ecx           # imm = 0x8000
xorl %r8d, %r8d
pushq %r12
pushq %r12
pushq %rax
pushq $0x2
pushq $0x0
callq 0x21c0
addq $0x30, %rsp
movq (%r13), %r13
cmpq %r15, %r13
jne 0x27f6
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rbx
cmpq %r14, %rax
jne 0x2792
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/thjaeger[P]bindbutton/bindbutton.cc
// Function: Event::get()
bool Event::get() {
	XEvent ev;
	XNextEvent(dpy, &ev);

	if (ev.type == ButtonPress) {
		is_press = true;
		button = ev.xbutton.button;
		dev = NULL;
		core = true;
		t = ev.xbutton.time;
		if (debug)
			printf("Button %d pressed (core)\n", button);
		return true;
	}
	for (std::list<XiDevice>::iterator j = devices.begin(); j != devices.end(); j++) {
		if (ev.type == j->press) {
			XDeviceButtonEvent* bev = (XDeviceButtonEvent *)&ev;
			is_press = true;
			button = bev->button;
			dev = &(*j);
			core = false;
			t = bev->time;
			if (debug)
				printf("Button %d pressed (Xi)\n", button);
			return true;
		}
		if (ev.type == j->release) {
			XDeviceButtonEvent* bev = (XDeviceButtonEvent *)&ev;
			is_press = false;
			button = bev->button;
			dev = &(*j);
			core = false;
			t = bev->time;
			if (debug)
				printf("Button %d released (Xi)\n", bev->button);
			return true;
		}
	}
	printf("Unknown event\n");
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %r14
movq 0x38b6(%rip), %rdi      # 0x6148
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x21d0
movl (%rbx), %ecx
cmpl $0x4, %ecx
jne 0x28e0
movb $0x1, %bl
movb %bl, (%r14)
movl 0x5c(%rsp), %esi
movl %esi, 0x4(%r14)
movq $0x0, 0x8(%r14)
movb %bl, 0x10(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%r14)
cmpb %bl, 0x3882(%rip)       # 0x6150
jne 0x297d
leaq 0x17e1(%rip), %rdi      # 0x40bc
jmp 0x2976
leaq 0x3879(%rip), %rdx      # 0x6160
movq %rdx, %rax
movq (%rax), %rax
cmpq %rdx, %rax
je 0x2932
cmpl 0x28(%rax), %ecx
je 0x2942
cmpl 0x2c(%rax), %ecx
jne 0x28ea
addq $0x10, %rax
xorl %ecx, %ecx
movb %cl, (%r14)
movl 0x64(%rsp), %esi
movl %esi, 0x4(%r14)
movq %rax, 0x8(%r14)
movb %cl, 0x10(%r14)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%r14)
movb $0x1, %bl
cmpb $0x1, 0x3829(%rip)      # 0x6150
jne 0x297d
leaq 0x17be(%rip), %rdi      # 0x40ee
jmp 0x2976
leaq 0x18e2(%rip), %rdi      # 0x421b
callq 0x21f0
xorl %ebx, %ebx
jmp 0x297d
addq $0x10, %rax
movb $0x1, (%r14)
movl 0x64(%rsp), %esi
movl %esi, 0x4(%r14)
movq %rax, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%r14)
movb $0x1, %bl
cmpb $0x1, 0x37e3(%rip)      # 0x6150
jne 0x297d
leaq 0x1760(%rip), %rdi      # 0x40d6
xorl %eax, %eax
callq 0x2030
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/thjaeger[P]bindbutton/bindbutton.cc
// Function: Event::handle()
void Event::handle() {
	if (core && is_press) {
		if (dev) {
			XTestFakeButtonEvent(dpy, button, False, CurrentTime);
			XAllowEvents(dpy, AsyncBoth, t);
		} else {
			XAllowEvents(dpy, ReplayPointer, t);
		}
	}

	if (!dev)
		return;

	std::map<unsigned int, Commands>::iterator i = commands.find(button);
	if (i != commands.end())
		run_cmd(is_press ? i->second.press : i->second.release);
	if (always_grab)
		return;
	if (is_press) {
		if (!dev->status.size())
			dev->grab();
		dev->status.insert(button);
	} else {
		dev->status.erase(button);
		if (!dev->status.size())
			dev->ungrab();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x29d7
cmpb $0x1, (%rbx)
jne 0x29d7
cmpq $0x0, 0x8(%rbx)
movq 0x379f(%rip), %rdi      # 0x6148
je 0x29c9
movl 0x4(%rbx), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2180
movq 0x378a(%rip), %rdi      # 0x6148
movq 0x18(%rbx), %rdx
movl $0x6, %esi
jmp 0x29d2
movq 0x18(%rbx), %rdx
movl $0x2, %esi
callq 0x20a0
cmpq $0x0, 0x8(%rbx)
je 0x2a92
leaq 0x4(%rbx), %r14
movq 0x379b(%rip), %rdx      # 0x6188
testq %rdx, %rdx
je 0x2a34
movl (%r14), %ecx
leaq 0x3784(%rip), %rax      # 0x6180
xorl %esi, %esi
cmpl %ecx, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rax
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x29fc
leaq 0x3766(%rip), %rdx      # 0x6180
cmpq %rdx, %rax
je 0x2a34
cmpl 0x20(%rax), %ecx
jb 0x2a34
movzbl (%rbx), %ecx
xorl $0x1, %ecx
movq 0x28(%rax,%rcx,8), %rdi
callq 0x286a
cmpb $0x0, 0x3716(%rip)      # 0x6151
jne 0x2a92
movq 0x8(%rbx), %r15
cmpb $0x1, (%rbx)
jne 0x2a6d
cmpq $0x0, 0x50(%r15)
jne 0x2a59
movq %r15, %rdi
callq 0x2c70
movq 0x8(%rbx), %r15
addq $0x28, %r15
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3234
addq $0x28, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3342
movq %r15, %rdi
movq %rax, %rsi
callq 0x33c0
movq 0x8(%rbx), %rdi
cmpq $0x0, 0x50(%rdi)
je 0x2a98
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0x2d22
// File: /workspace/github_cpp_makefile_star2_O3/thjaeger[P]bindbutton/bindbutton.cc
// Function: Event::combine(Event&)
bool Event::combine(Event &ev) {
	if (is_press != ev.is_press)
		return false;
	if (button != ev.button)
		return false;
	if (t != ev.t)
		return false;
	if (core && !dev && !ev.core && ev.dev) {
		dev = ev.dev;
		return true;
	}
	if (!core && dev && ev.core && !ev.dev) {
		core = ev.core;
		return true;
	}
	return false;
}

// Assembly:
movb (%rdi), %al
cmpb (%rsi), %al
jne 0x2af9
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x2af9
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0x2af9
movq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rdi)
jne 0x2ade
testq %rax, %rax
jne 0x2af9
cmpb $0x0, 0x10(%rsi)
jne 0x2af9
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2af9
movq %rax, 0x8(%rdi)
jmp 0x2af6
testq %rax, %rax
je 0x2af9
xorl %eax, %eax
cmpb $0x1, 0x10(%rsi)
jne 0x2af8
cmpq $0x0, 0x8(%rsi)
jne 0x2af8
movb $0x1, 0x10(%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/thjaeger[P]bindbutton/bindbutton.cc
// Function: main
int main(int argc, char **argv) {
	printf("bindbutton is deprecated.  Its functionality is now available in\neasystroke (version >= 0.4.0)\n\n");
	dpy = XOpenDisplay(NULL);

	parse_args(argc, argv);
	init_xi();
	grab_buttons();

	Event queue[2];
	int queue_size = 0;

	while (1) {
		while (queue_size < 2 && (!queue_size || XPending(dpy))) {
			if (queue[queue_size].get())
				queue_size++;
			else
				continue;
		}
		if (queue_size == 2 && queue[0].combine(queue[1]))
			queue_size = 1;
		for (int i = 0; i < queue_size; i++)
			queue[i].handle();
		queue_size = 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1717(%rip), %rdi      # 0x4229
callq 0x21f0
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x21b0
movq %rax, 0x3620(%rip)      # 0x6148
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2635
callq 0x23ec
callq 0x272f
movq %rsp, %r14
testl %r15d, %r15d
je 0x2b58
movq 0x35fd(%rip), %rdi      # 0x6148
callq 0x2100
testl %eax, %eax
je 0x2bdb
movl %r15d, %eax
shlq $0x5, %rax
leaq (%rsp,%rax), %rdi
callq 0x287e
movzbl %al, %eax
addl %eax, %r15d
cmpl $0x2, %r15d
jb 0x2b3f
movb (%rsp), %al
movl $0x2, %r15d
cmpb 0x20(%rsp), %al
jne 0x2be1
movl 0x4(%rsp), %eax
cmpl 0x24(%rsp), %eax
jne 0x2be1
movq 0x18(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x2be1
movq 0x8(%rsp), %rax
cmpb $0x1, 0x10(%rsp)
jne 0x2bc2
testq %rax, %rax
jne 0x2be1
cmpb $0x0, 0x30(%rsp)
jne 0x2be1
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x2be1
movq %rax, 0x8(%rsp)
jmp 0x2bdb
testq %rax, %rax
je 0x2be1
cmpb $0x1, 0x30(%rsp)
jne 0x2be1
cmpq $0x0, 0x28(%rsp)
jne 0x2be1
movb $0x1, 0x10(%rsp)
movl $0x1, %r15d
movq %r14, %rbx
movq %rbx, %rdi
callq 0x298a
addq $0x20, %rbx
decq %r15
jne 0x2be4
xorl %r15d, %r15d
jmp 0x2b3f
nop
// File: /workspace/github_cpp_makefile_star2_O3/thjaeger[P]bindbutton/bindbutton.cc
// Function: XiDevice::grab()
void grab() {
		if (debug)
			printf("Grabbing device %ld\n", dev->device_id);
		int status = XGrabDevice(dpy, dev, ROOT, False, 2, classes,
				GrabModeAsync, GrabModeAsync, CurrentTime);
		switch (status) {
			case GrabSuccess:
				break;
			case AlreadyGrabbed:
				printf("Grab error: Already grabbed\n");
				break;
			case GrabNotViewable:
				printf("Grab error: Not viewable\n");
				break;
			case GrabFrozen:
				printf("Grab error: Frozen\n");
				break;
			case GrabInvalidTime:
				printf("Grab error: Invalid Time\n");
				break;
			default:
				printf("Grab error: Unknown\n");
		}
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x34d5(%rip)      # 0x6150
jne 0x2c91
movq (%rbx), %rax
movq (%rax), %rsi
leaq 0x147d(%rip), %rdi      # 0x4107
xorl %eax, %eax
callq 0x2030
movq 0x34b0(%rip), %rdi      # 0x6148
movq (%rbx), %rsi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rdx
addq $0x8, %rbx
subq $0x8, %rsp
movl $0x1, %eax
xorl %ecx, %ecx
movl $0x2, %r8d
movq %rbx, %r9
pushq $0x0
pushq %rax
pushq %rax
callq 0x2150
addq $0x20, %rsp
cmpl $0x4, %eax
ja 0x2d14
movl %eax, %eax
leaq 0x133b(%rip), %rcx      # 0x4020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbx
retq
leaq 0x14c8(%rip), %rdi      # 0x41bf
jmp 0x2d1b
leaq 0x14a6(%rip), %rdi      # 0x41a6
jmp 0x2d1b
leaq 0x14c9(%rip), %rdi      # 0x41d2
jmp 0x2d1b
leaq 0x14d9(%rip), %rdi      # 0x41eb
jmp 0x2d1b
leaq 0x14ec(%rip), %rdi      # 0x4207
popq %rbx
jmp 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/individual.cpp
// Function: Individual::isValid(int)
bool Individual::isValid(int tam){
    std::vector <int> freq(chromosome.size(), 0);
    for(int i = 0; i < chromosome.size(); i++){
        freq[chromosome[i]]++;
        if(freq[chromosome[i]] > 1)return false;    
    }
    return tam == chromosome.size();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movl %esi, %ebx
sarq $0x2, %rax
leaq 0x4(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x8(%rsp), %r15
leaq 0x3(%rsp), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq 0x1ab4
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x2, %rax
movq (%r15), %rdi
cmpq %rcx, %rdx
je 0x19a5
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
movslq (%rcx,%rsi,4), %r8
incl (%rdi,%r8,4)
movslq (%rcx,%rsi,4), %r8
cmpl $0x1, (%rdi,%r8,4)
jg 0x19b5
incq %rsi
cmpq %rsi, %rdx
jne 0x197f
movslq %ebx, %rcx
cmpq %rcx, %rax
sete %bl
jmp 0x19b7
movslq %ebx, %rcx
cmpq %rcx, %rax
sete %bl
testq %rdi, %rdi
jne 0x19b7
jmp 0x19c4
xorl %ebx, %ebx
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/population.cpp
// Function: Population::reset()
void Population::reset(){
    if(!resetStatus){
        population.clear();
        weight.clear();
    }
    resetStatus = true;
    currentBest = 1e18;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
jne 0x1c91
leaq 0x10(%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x3008
leaq 0x28(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x3052
movb $0x1, (%rbx)
movabsq $0xde0b6b3a7640000, %rax # imm = 0xDE0B6B3A7640000
movq %rax, 0x8(%rbx)
popq %rbx
retq