LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3220
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x9d2a
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x40
popq %rdi
callq 0x31b0
movq %rax, %r15
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x3220
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
andq $0x0, 0x30(%r15)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%r15)
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x7bf2
movq %r15, %rcx
addq $0x20, %rcx
leaq 0x50(%rsp), %rdx
movups (%r14), %xmm1
movups %xmm1, (%rcx)
movq %rax, 0x30(%r15)
movups %xmm0, (%rdx)
movq %rsp, %rsi
movq %r15, (%rsi)
leaq 0x1643(%rip), %rax      # 0x9242
movq %rax, 0x18(%rsi)
leaq 0x1660(%rip), %rax      # 0x926a
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x9ce4
movq %rsp, %rdi
callq 0x7274
leaq 0x20(%rsp), %rdi
callq 0x7c74
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7c47
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x31c0
jmp 0x7c4a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7274
leaq 0x20(%rsp), %rdi
callq 0x7c74
jmp 0x7c6b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1412(%rip), %rax      # 0x90ba
movq %rax, 0x18(%rdi)
leaq 0x1415(%rip), %rax      # 0x90c8
movq %rax, 0x10(%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
leaq 0x38(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x58(%rsp), %r12
cmpq %r13, 0x10(%rsp)
je 0x7d37
movq 0x8(%rsp), %rax
movb (%rax,%r13), %bpl
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9ce4
movsbl %bpl, %esi
movq %r15, %rdi
callq 0x7b15
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7d89
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9f12
movq %r12, %rdi
callq 0x7274
movq %r15, %rdi
callq 0x7274
movq %r14, %rdi
callq 0x7274
incq %r13
jmp 0x7cda
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x7d79
movq %rax, %r14
jmp 0x7d6f
movq %rax, %r14
jmp 0x7d65
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x7274
leaq 0x18(%rsp), %rdi
callq 0x7274
leaq 0x38(%rsp), %rdi
callq 0x7274
movq %rbx, %rdi
callq 0x7274
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9ce4
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x9ce4
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x40
popq %rdi
callq 0x31b0
movq %rax, %r14
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x9ce4
movq %r14, %rdi
addq $0x20, %rdi
movq %r15, %rsi
callq 0x9ce4
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x1746(%rip), %rax      # 0x9538
movq %rax, 0x18(%rsi)
leaq 0x17b3(%rip), %rax      # 0x95b0
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x9ce4
movq %rsp, %rdi
callq 0x7274
leaq 0x20(%rsp), %rdi
callq 0x805c
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7e47
movq %rax, %rbx
movq %r14, %rdi
callq 0x7274
jmp 0x7e3a
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x31c0
jmp 0x7e4a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7274
leaq 0x20(%rsp), %rdi
callq 0x805c
jmp 0x7e6b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7274
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9ce4
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x20
popq %rdi
callq 0x31b0
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x9ce4
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x1550(%rip), %rax      # 0x9454
movq %rax, 0x18(%rsi)
leaq 0x15a1(%rip), %rax      # 0x94b0
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x9ce4
movq %rsp, %rdi
callq 0x7274
leaq 0x28(%rsp), %rdi
callq 0x7274
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x7f4a
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x31c0
jmp 0x7f4d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7274
leaq 0x28(%rsp), %rdi
callq 0x7274
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9ce4
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x20
popq %rdi
callq 0x31b0
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x9ce4
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x131a(%rip), %rax      # 0x9312
movq %rax, 0x18(%rsi)
leaq 0x13c9(%rip), %rax      # 0x93cc
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x9ce4
movq %rsp, %rdi
callq 0x7274
leaq 0x28(%rsp), %rdi
callq 0x7274
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x803e
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x31c0
jmp 0x8041
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7274
leaq 0x28(%rsp), %rdi
callq 0x7274
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x20(%rsp), %rdi
callq 0x9d76
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x20
popq %rdi
callq 0x31b0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rcx
testq %rcx, %rcx
je 0x80e2
leaq 0x30(%rsp), %rdx
movups -0x10(%rdx), %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x1863(%rip), %rax      # 0x9952
movq %rax, 0x18(%rsi)
leaq 0x188e(%rip), %rax      # 0x9988
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x9ce4
movq %rsp, %rdi
callq 0x7274
leaq 0x20(%rsp), %rdi
callq 0x7274
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x8123
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7274
leaq 0x20(%rsp), %rdi
callq 0x7274
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3220
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x20
popq %rdi
callq 0x31b0
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x3220
movq %rsp, %rsi
movq %r14, (%rsi)
leaq 0x1629(%rip), %rax      # 0x97ae
movq %rax, 0x18(%rsi)
leaq 0x1668(%rip), %rax      # 0x97f8
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x9ce4
movq %rsp, %rdi
callq 0x7274
leaq 0x28(%rsp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x81cb
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x31c0
jmp 0x81ce
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7274
leaq 0x28(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
callq 0x9f60
movq (%r14), %rbx
movq 0x8(%r14), %r15
leaq 0x18(%rsp), %rax
andl $0x0, -0x8(%rax)
addq %rbx, %r15
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8a9c(%rip), %r12      # 0x11270
leaq 0x48(%rsp), %r13
leaq 0x10(%rsp), %rbp
leaq 0x38(%rsp), %r14
cmpq %r15, %rbx
je 0x8842
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x9dbc
movq 0x48(%rsp), %rbx
cmpq %rbx, %r15
je 0x8842
movq %r13, %rdi
movq %rbp, %rsi
callq 0x8290
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x9dbc
movq 0x38(%rsp), %rbx
movq %r13, %rdi
callq 0x7274
cmpl $0x0, 0x10(%rsp)
je 0x87e3
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x9dee
jmp 0x87e3
leaq 0x18(%rsp), %rdi
callq 0x30c0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x886e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x7274
jmp 0x8871
jmp 0x886e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x30c0
movq 0x8(%rsp), %rdi
callq 0x72bc
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
cmpq %rsi, 0x30(%r14)
je 0x88b7
movq %rbx, %rdi
callq 0x9e22
movq %r14, %rdi
callq 0x9e34
jmp 0x88ef
leaq 0x31df(%rip), %rsi      # 0xba9d
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x71cc
movl $0x7, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x3220
leaq 0x8(%rsp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8abe
movq %rdi, %rbx
leaq 0x2ce6(%rip), %rcx      # 0xb6a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8626(%rip), %rdi      # 0x10ff0
leaq 0x30f5(%rip), %rsi      # 0xbac6
callq 0x31a0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x30e0
movq 0x85dc(%rip), %r14      # 0x10fc8
leaq 0x30cb(%rip), %rsi      # 0xbabe
movq %r14, %rdi
callq 0x31a0
movq 0x28(%rbx), %rdi
callq 0x89a0
leaq 0x30b9(%rip), %rsi      # 0xbac4
movq %r14, %rdi
callq 0x31a0
movq 0x30(%rbx), %rdi
jmp 0x8a75
movq 0x85a8(%rip), %rdi      # 0x10fc8
leaq 0x307a(%rip), %rsi      # 0xbaa1
callq 0x31a0
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x32a0
leaq 0x3075(%rip), %rsi      # 0xbab3
jmp 0x8aaf
movq 0x8581(%rip), %r14      # 0x10fc8
leaq 0x3067(%rip), %rsi      # 0xbab5
movq %r14, %rdi
callq 0x31a0
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3180
leaq 0x305a(%rip), %rsi      # 0xbac3
movq %rax, %rdi
callq 0x31a0
movq 0x28(%rbx), %rdi
callq 0x89a0
leaq 0x3032(%rip), %rsi      # 0xbab3
movq %r14, %rdi
jmp 0x8ab2
movq 0x853b(%rip), %rdi      # 0x10fc8
leaq 0x3015(%rip), %rsi      # 0xbaa9
callq 0x31a0
addq $0x8, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3180
leaq 0x3003(%rip), %rsi      # 0xbab2
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x2bdb(%rip), %r13      # 0xb6b4
movq 0x84e8(%rip), %r14      # 0x10fc8
leaq 0x3010(%rip), %r15      # 0xbaf7
leaq 0x2905(%rip), %r12      # 0xb3f3
movl (%rbx), %eax
cmpq $0x4, %rax
ja 0x8bde
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq %r14, %rdi
movq %r15, %rsi
callq 0x31a0
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3180
movq %rax, %rdi
movq %r12, %rsi
callq 0x31a0
movq 0x28(%rbx), %rbx
jmp 0x8aee
movq 0x28(%rbx), %rdi
movl (%rdi), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x8b51
movq 0x8487(%rip), %rdi      # 0x10fc8
leaq 0x2fb1(%rip), %rsi      # 0xbaf9
callq 0x31a0
movq 0x28(%rbx), %rdi
callq 0x8ac6
movq 0x28(%rbx), %rax
movl (%rax), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x8b77
movq 0x845d(%rip), %rdi      # 0x10fc8
leaq 0x3059(%rip), %rsi      # 0xbbcb
callq 0x31a0
movq 0x844a(%rip), %rdi      # 0x10fc8
leaq 0x286e(%rip), %rsi      # 0xb3f3
callq 0x31a0
movq 0x30(%rbx), %rdi
movl (%rdi), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x8baf
movq 0x8429(%rip), %rdi      # 0x10fc8
leaq 0x2f53(%rip), %rsi      # 0xbaf9
callq 0x31a0
movq 0x30(%rbx), %rdi
callq 0x8ac6
movq 0x30(%rbx), %rax
movl (%rax), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x8bde
movq 0x83ff(%rip), %rdi      # 0x10fc8
leaq 0x2ffb(%rip), %rsi      # 0xbbcb
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31a0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq $0x8, %rbx
movq 0x83d5(%rip), %rdi      # 0x10fc8
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3180
movl 0x4(%rbx), %esi
movq 0x83ba(%rip), %rdi      # 0x10fc8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x32a0
movq 0x83cd(%rip), %rdi      # 0x10ff0
leaq 0x2e9c(%rip), %rsi      # 0xbac6
callq 0x31a0
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x30e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8d06
testq %rax, %rax
je 0x8caa
movq %rax, %r14
pushq $0x38
popq %r15
movq %rbx, %rdi
callq 0x8d06
testq %rax, %rax
je 0x8c9b
movq %rax, %r12
movq %r15, %rdi
callq 0x31b0
movl $0x4, (%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
movq %r14, 0x28(%rax)
movq %r12, 0x30(%rax)
movq %rax, %r14
jmp 0x8c5f
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x833f(%rip), %rdi      # 0x10ff0
leaq 0x2e43(%rip), %rsi      # 0xbafb
callq 0x31a0
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x8910
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3180
movq %rax, %rdi
callq 0x30e0
movq %rsp, %rdi
callq 0x9e18
pushq $0x1
popq %rdi
callq 0x31e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x30c0
movq %r14, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x3290
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x3120
movl 0xc(%rsp), %ebx
leaq 0x10(%rsp), %rdi
callq 0x30d0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x32b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
pushq $0x3
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
cmpl $0x4, %edi
jl 0x26c7
cmpl $0x1, %edx
jne 0x26c7
movl %edi, %r12d
pushq $0x3
popq %r13
leaq 0x4b5e(%rip), %r14      # 0x7188
leaq 0xc(%rsp), %r15
cmpq %r12, %r13
jae 0x266a
movq -0x10(%rbx,%r13,8), %rdi
callq 0x2220
testl %eax, %eax
je 0x26b7
movl %eax, 0xc(%rsp)
movups -0x8(%rbx,%r13,8), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b4e
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rax)
addq $0x3, %r13
jmp 0x262f
leaq 0x1a1a(%rip), %rdi      # 0x408b
callq 0x21c0
testq %rax, %rax
setne 0x4ae0(%rip)            # 0x7160
leaq 0x1a0a(%rip), %rdi      # 0x4091
callq 0x21c0
testq %rax, %rax
setne 0x4acb(%rip)            # 0x7161
leaq 0x1a00(%rip), %rdi      # 0x409d
callq 0x21c0
movq %rax, 0x4abf(%rip)      # 0x7168
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%rbx), %rdi
callq 0x25d3
pushq $0x1
popq %rdi
callq 0x21b0
movq (%rbx), %rdi
callq 0x25d3
xorl %edi, %edi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, 0x4a79(%rip)      # 0x7161
jne 0x2713
leaq 0x1a9a(%rip), %rdi      # 0x418b
callq 0x2210
leaq 0x4a73(%rip), %rbx      # 0x7170
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x2713
leaq 0x10(%r14), %rdi
callq 0x2b9c
jmp 0x2700
movq 0x4a86(%rip), %rbx      # 0x71a0
leaq 0x4a6f(%rip), %r14      # 0x7190
pushq $0x4
popq %rbp
leaq 0x4a45(%rip), %r15      # 0x7170
pushq $0x1
popq %r12
cmpq %r14, %rbx
je 0x27f6
movq 0x4a19(%rip), %rdi      # 0x7158
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)
andl $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x8000, %edx           # imm = 0x8000
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x2250
addq $0x20, %rsp
cmpb $0x0, 0x49d5(%rip)      # 0x7161
je 0x279b
movq %rbx, %rdi
callq 0x20e0
movq %rax, %rbx
jmp 0x272f
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x278e
movl 0x20(%rbx), %edx
cmpl 0x30(%r13), %edx
ja 0x279e
movq 0x49a1(%rip), %rdi      # 0x7158
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 0x21e0
addq $0x30, %rsp
jmp 0x279e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4914(%rip), %rdi      # 0x7158
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x21f0
movl (%rbx), %ecx
cmpl $0x4, %ecx
jne 0x288f
movb $0x1, %bl
movb %bl, (%r14)
movl 0x5c(%rsp), %esi
movl %esi, 0x4(%r14)
andq $0x0, 0x8(%r14)
movb %bl, 0x10(%r14)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%r14)
cmpb %bl, 0x48e3(%rip)       # 0x7160
jne 0x292c
leaq 0x1832(%rip), %rdi      # 0x40bc
jmp 0x2925
leaq 0x48da(%rip), %rdx      # 0x7170
movq %rdx, %rax
movq (%rax), %rax
cmpq %rdx, %rax
je 0x28e1
cmpl 0x28(%rax), %ecx
je 0x28f1
cmpl 0x2c(%rax), %ecx
jne 0x2899
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, 0x488a(%rip)      # 0x7160
jne 0x292c
leaq 0x180f(%rip), %rdi      # 0x40ee
jmp 0x2925
leaq 0x1933(%rip), %rdi      # 0x421b
callq 0x2210
xorl %ebx, %ebx
jmp 0x292c
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, 0x4844(%rip)      # 0x7160
jne 0x292c
leaq 0x17b1(%rip), %rdi      # 0x40d6
xorl %eax, %eax
callq 0x2030
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x2981
cmpb $0x1, (%rbx)
jne 0x2981
cmpq $0x0, 0x8(%rbx)
movq 0x4800(%rip), %rdi      # 0x7158
je 0x2975
movl 0x4(%rbx), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x21a0
movq 0x47eb(%rip), %rdi      # 0x7158
movq 0x18(%rbx), %rdx
pushq $0x6
jmp 0x297b
movq 0x18(%rbx), %rdx
pushq $0x2
popq %rsi
callq 0x20b0
cmpq $0x0, 0x8(%rbx)
je 0x2a03
leaq 0x4(%rbx), %r14
leaq 0x47f5(%rip), %rdi      # 0x7188
movq %r14, %rsi
callq 0x32e4
leaq 0x47ee(%rip), %rcx      # 0x7190
cmpq %rcx, %rax
je 0x29b7
movzbl (%rbx), %ecx
xorl $0x1, %ecx
movq 0x28(%rax,%rcx,8), %rdi
callq 0x2805
cmpb $0x0, 0x47a3(%rip)      # 0x7161
jne 0x2a03
movq 0x8(%rbx), %rdi
cmpb $0x1, (%rbx)
jne 0x29ec
cmpq $0x0, 0x50(%rdi)
jne 0x29d9
callq 0x2b9c
movq 0x8(%rbx), %rdi
addq $0x28, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3318
addq $0x28, %rdi
movq %r14, %rsi
callq 0x340e
movq 0x8(%rbx), %rdi
cmpq $0x0, 0x50(%rdi)
je 0x2a0b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2c56
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a6f
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x2a6f
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0x2a6f
movq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rdi)
jne 0x2a54
testq %rax, %rax
jne 0x2a6f
cmpb $0x0, 0x10(%rsi)
jne 0x2a6f
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2a6f
movq %rax, 0x8(%rdi)
jmp 0x2a6c
testq %rax, %rax
je 0x2a6f
xorl %eax, %eax
cmpb $0x1, 0x10(%rsi)
jne 0x2a6e
cmpq $0x0, 0x8(%rsi)
jne 0x2a6e
movb $0x1, 0x10(%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x179d(%rip), %rdi      # 0x4229
callq 0x2210
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x21d0
movq %rax, 0x46b6(%rip)      # 0x7158
movl %ebp, %edi
movq %rbx, %rsi
callq 0x25f2
callq 0x23ec
callq 0x26d6
leaq 0x20(%rsp), %rbx
pushq $0x1
popq %rbp
movq %rsp, %r14
pushq $0x2
popq %r12
cmpl $0x1, %r15d
ja 0x2afa
testl %r15d, %r15d
je 0x2ae2
movq 0x4681(%rip), %rdi      # 0x7158
callq 0x2120
movl %ebp, %ecx
testl %eax, %eax
je 0x2b16
movl %r15d, %eax
shlq $0x5, %rax
leaq (%rsp,%rax), %rdi
callq 0x2830
movzbl %al, %eax
addl %eax, %r15d
jmp 0x2ac5
movl %r15d, %ecx
cmpl $0x2, %r15d
jne 0x2b16
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a18
movzbl %al, %eax
movl %r12d, %ecx
subl %eax, %ecx
movl %ecx, %r13d
movq %r14, %r15
subq $0x1, %r13
jb 0x2b30
movq %r15, %rdi
callq 0x293a
addq $0x20, %r15
jmp 0x2b1c
xorl %r15d, %r15d
jmp 0x2ac5
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x45b5(%rip)      # 0x7160
jne 0x2bc1
movq (%rbx), %rax
movq (%rax), %rsi
leaq 0x154d(%rip), %rdi      # 0x4107
xorl %eax, %eax
callq 0x2030
movq 0x4590(%rip), %rdi      # 0x7158
movq (%rbx), %rsi
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rdx
addq $0x8, %rbx
pushq $0x1
popq %rax
movl %eax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movl %eax, (%rsp)
pushq $0x2
popq %r8
xorl %ecx, %ecx
movq %rbx, %r9
callq 0x2170
cmpl $0x4, %eax
ja 0x2c45
movl %eax, %eax
leaq 0x140e(%rip), %rcx      # 0x4020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x1597(%rip), %rdi      # 0x41bf
jmp 0x2c4c
leaq 0x1575(%rip), %rdi      # 0x41a6
jmp 0x2c4c
leaq 0x1598(%rip), %rdi      # 0x41d2
jmp 0x2c4c
leaq 0x15a8(%rip), %rdi      # 0x41eb
jmp 0x2c4c
leaq 0x15bb(%rip), %rdi      # 0x4207
addq $0x20, %rsp
popq %rbx
jmp 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/main.cpp
// Function: main
int main(int argc, char *argv[]){
    if(argc != 4){
        std::cout << "./run graphSize populationSize epochs" << std::endl;
        exit(0);
    }
    int graphSize = atoi(argv[1]);
    int populationSize = atoi(argv[2]);
    int epochs = atoi(argv[3]);
    srand(time(NULL));
    Population p;
    p.start(graphSize, populationSize);
    std::vector <long long> parcialResults;
    for(int i = 0; i < epochs; i++){
        if(i%100 == 0){
            parcialResults.emplace_back(p.currentBest);
        }
        p.nextGeneration();
    }
    parcialResults.emplace_back(p.currentBest);
    std::cout << "Epochs, bestAnswer, Size" << std::endl;
    for(int i = 1; i < parcialResults.size(); i++){
        std::cout << (i * 100) << ", " << parcialResults[i] << ", " << graphSize << std::endl;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x4, %edi
jne 0x147d
movq %rsi, %r14
movq 0x8(%rsi), %rdi
callq 0x1140
movl %eax, %ebx
movq 0x10(%r14), %rdi
callq 0x1140
movl %eax, %ebp
movq 0x18(%r14), %rdi
callq 0x1140
movl %eax, %r14d
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x10c0
movl %eax, %edi
callq 0x10d0
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x1af0
movq %r12, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x1b40
xorps %xmm0, %xmm0
movq %rsp, %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%rax)
testl %r14d, %r14d
cmovlel %r15d, %r14d
pushq $0x64
popq %rbp
leaq 0x18(%rsp), %r13
xorl %r12d, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl %ebp
subl $0x1, %r14d
jb 0x13c4
imull $0x64, %eax, %eax
addl %r15d, %eax
jne 0x13b4
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x14c6
movq %r13, %rdi
callq 0x24ae
incl %r12d
decl %r15d
jmp 0x1392
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x14c6
movq 0x6c00(%rip), %rdi      # 0x7fd8
leaq 0x2c4b(%rip), %rsi      # 0x402a
callq 0x10e0
movq %rax, %rdi
callq 0x1080
pushq $0x1
popq %r12
movq 0x6be1(%rip), %r14      # 0x7fd8
leaq 0x2c45(%rip), %r15      # 0x4043
movq 0x8(%rsp), %rax
subq (%rsp), %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x145a
movq %r14, %rdi
movl %ebp, %esi
callq 0x1170
movq %rax, %rdi
movq %r15, %rsi
callq 0x10e0
movq (%rsp), %rcx
movq (%rcx,%r12,8), %rsi
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
movq %r15, %rsi
callq 0x10e0
movq %rax, %rdi
movl %ebx, %esi
callq 0x1170
movq %rax, %rdi
callq 0x1080
incq %r12
addl $0x64, %ebp
jmp 0x13fe
movq %rsp, %rdi
callq 0x165c
leaq 0x18(%rsp), %rdi
callq 0x14fc
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6b54(%rip), %rdi      # 0x7fd8
leaq 0x2b79(%rip), %rsi      # 0x4004
callq 0x10e0
movq %rax, %rdi
callq 0x1080
xorl %edi, %edi
callq 0x1110
movq %rax, %rbx
jmp 0x14b3
jmp 0x14a8
jmp 0x14a8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x165c
leaq 0x18(%rsp), %rdi
callq 0x14fc
movq %rbx, %rdi
callq 0x1180
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
subq (%rdi), %rsi
sarq $0x2, %rsi
leaq 0x4(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x8(%rsp), %r15
leaq 0x3(%rsp), %rcx
movq %r15, %rdi
callq 0x19b4
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
sarq $0x2, %rax
xorl %edx, %edx
movq (%r15), %rsi
cmpq %rdx, %rax
je 0x18cb
movslq (%rcx,%rdx,4), %rdi
incl (%rsi,%rdi,4)
movslq (%rcx,%rdx,4), %rdi
incq %rdx
cmpl $0x1, (%rsi,%rdi,4)
jle 0x18ae
xorl %ebx, %ebx
jmp 0x18d4
movslq %ebx, %rcx
cmpq %rcx, %rax
sete %bl
leaq 0x8(%rsp), %rdi
callq 0x1612
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b2d
leaq 0x10(%rbx), %rdi
callq 0x24c0
leaq 0x28(%rbx), %rdi
callq 0x24c8
movb $0x1, (%rbx)
movabsq $0xde0b6b3a7640000, %rax # imm = 0xDE0B6B3A7640000
movq %rax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/population.cpp
// Function: Population::start(int, int)
void Population::start(int k, int size){
    if(!resetStatus)reset();
    resetStatus = false;
    tam = k;
    for(int i = 0; i < size; i++){
        std::vector<int> aux;
        for(int j = 0; j < k; j++){
            aux.emplace_back(j);
        }
        std::random_shuffle(aux.begin(), aux.end());
        population.emplace_back(Individual(aux));
        weight.emplace_back(std::vector<long long>(k, 0));
    }
    for(int i = 0; i < k; i++){
        for(int j = i + 1; j < k; j++){
            weight[i][j] = (rand() % 100000) + 122;
            weight[j][i] = weight[i][j];
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0x1b63
movq %r14, %rdi
callq 0x1b12
movb $0x0, (%r14)
movl %ebx, 0x4(%r14)
leaq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movslq %ebx, %rax
movq %rax, 0x8(%rsp)
addq $0x28, %r14
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
movl %r15d, 0x18(%rsp)
leaq 0x20(%rsp), %r13
leaq 0x48(%rsp), %r15
leaq 0x60(%rsp), %r12
cmpl 0x18(%rsp), %ebp
je 0x1c53
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
xorl %eax, %eax
movl %eax, 0x48(%rsp)
cmpl %ebx, %eax
jge 0x1bd2
movq %r13, %rdi
movq %r15, %rsi
callq 0x24d0
movl 0x48(%rsp), %eax
incl %eax
jmp 0x1bb7
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2504
movq %r12, %rdi
movq %r13, %rsi
callq 0x25ac
movq %r15, %rdi
movq %r12, %rsi
callq 0x17e0
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x2562
movq %r15, %rdi
callq 0x1612
movq %r12, %rdi
callq 0x1612
andq $0x0, 0x40(%rsp)
movq %r15, %rdi
movq 0x8(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x7(%rsp), %rcx
callq 0x2644
movq %r14, %rdi
movq %r15, %rsi
callq 0x25fa
movq %r15, %rdi
callq 0x165c
movq %r13, %rdi
callq 0x1612
incl %ebp
jmp 0x1b9d
xorl %r15d, %r15d
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
movq %rax, 0x8(%rsp)
pushq $0x1
popq %r13
pushq $0x3
popq %rbp
movl $0x186a0, %r12d         # imm = 0x186A0
movq %rbp, 0x10(%rsp)
movq %r13, 0x18(%rsp)
cmpq 0x8(%rsp), %r15
jne 0x1cb2
jmp 0x1ccd
callq 0x1030
cltd
idivl %r12d
addl $0x7a, %edx
movslq %edx, %rax
movq (%r14), %rcx
imulq $0x18, %r15, %rdx
movq (%rcx,%rdx), %rdx
movq %rax, (%rdx,%r13,8)
movq (%rcx,%rbp,8), %rcx
movq %rax, (%rcx,%r15,8)
incq %r13
addq $0x3, %rbp
cmpl %ebx, %r13d
jl 0x1c85
incq %r15
movq 0x18(%rsp), %r13
incq %r13
movq 0x10(%rsp), %rbp
addq $0x3, %rbp
jmp 0x1c72
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1cee
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1612
leaq 0x60(%rsp), %rdi
callq 0x1612
jmp 0x1d12
jmp 0x1d0f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x165c
jmp 0x1d12
jmp 0x1d0f
jmp 0x1d0f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1612
movq %rbx, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/population.cpp
// Function: Population::F(int)
long long Population::F(int x){
    long long ret = 0;
    for(int i = 0; i < population[x].chromosome.size() - 1; i++){
        int u = population[x].chromosome[i];
        int v = population[x].chromosome[i + 1];
        ret += weight[u][v];
    }
    return ret;
}

// Assembly:
movslq %esi, %rax
imulq $0x18, %rax, %rax
movq 0x10(%rdi), %rsi
movq 0x28(%rdi), %rcx
movq (%rsi,%rax), %rdx
movq 0x8(%rsi,%rax), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
pushq $0x1
popq %rdi
xorl %eax, %eax
cmpq %rdi, %rsi
je 0x1d67
movslq -0x4(%rdx,%rdi,4), %r8
movslq (%rdx,%rdi,4), %r9
imulq $0x18, %r8, %r8
movq (%rcx,%r8), %r8
addq (%r8,%r9,8), %rax
incq %rdi
jmp 0x1d48
retq
// File: /workspace/github_cpp_makefile_star2_O2/gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/population.cpp
// Function: Population::reproduce()
void Population::reproduce(){
    std::random_shuffle(population.begin(), population.end());

    int sz = population.size();

    // crossing over
    for(int i = 0; i < sz; i += 2){
        std::pair < Individual, Individual > cross = crossingOver(population[i], population[i + 1]);
        population.emplace_back(cross.first);
        population.emplace_back(cross.second);
    }
    // mutation
    for(int i = 0; i < population.size(); i++){
        double random = ((double)rand()) / RAND_MAX;
        if(random <= 0.1){
            population[i].mutate();
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rsi
callq 0x2718
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
pushq $0x18
popq %r13
cqto
idivq %r13
movslq %eax, %rbp
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
cmpq %rbp, %r15
jge 0x243b
movq (%r14), %rcx
leaq (%rcx,%r13), %rdx
addq $-0x18, %rdx
addq %r13, %rcx
movq %r12, %rdi
callq 0x20c2
movq %r14, %rdi
movq %r12, %rsi
callq 0x26dc
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0x26dc
movq %r12, %rdi
callq 0x28bc
addq $0x2, %r15
addq $0x30, %r13
jmp 0x23f6
xorl %r15d, %r15d
pushq $0x18
popq %r12
xorl %r13d, %r13d
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x248a
callq 0x1030
cvtsi2sd %eax, %xmm0
divsd 0x1c80(%rip), %xmm0     # 0x40e8
movsd 0x1c70(%rip), %xmm1     # 0x40e0
ucomisd %xmm0, %xmm1
jb 0x2481
movq (%r14), %rdi
addq %r15, %rdi
callq 0x1812
incq %r13
addq $0x18, %r15
jmp 0x2445
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x28bc
movq %rbx, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::Shell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
Shell::Shell(string diskName, int numberOfBlocks, int blockSize) : FileSystem(diskName, numberOfBlocks, blockSize)
{
    // Just Some Interesting Styling
    cout << "Interactive DOS Shell Version 0.1" << endl;
    cout << "Copyright 2016 by Ruben Castaneda" << endl;
    cout << "=================================" << endl;
    this->runShell();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x3914
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq 0x680b(%rip), %rdi      # 0x8fc8
leaq 0x3870(%rip), %rsi      # 0x6034
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq 0x67f0(%rip), %rdi      # 0x8fc8
leaq 0x3877(%rip), %rsi      # 0x6056
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq 0x67d5(%rip), %rdi      # 0x8fc8
leaq 0x387e(%rip), %rsi      # 0x6078
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x283e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x20e0
jmp 0x2835
movq %rax, %r14
movq %rbx, %rdi
callq 0x25ca
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::dir()
int Shell::dir(){
    vector<string> tmp = this->ls();

    for (int i = 0; i < tmp.size(); i++)
        cout << tmp[i] << " ";
    cout << endl;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
leaq -0x38(%rbp), %rdi
callq 0x4a2e
xorl %r15d, %r15d
movq 0x63d1(%rip), %rbx      # 0x8fc8
leaq 0x34bd(%rip), %r14      # 0x60bb
xorl %r12d, %r12d
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x2c34
addq %r15, %rsi
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21d0
incq %r12
addq $0x20, %r15
jmp 0x2c01
movq 0x638d(%rip), %rdi      # 0x8fc8
callq 0x20f0
leaq -0x38(%rbp), %rdi
callq 0x25fc
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c5b
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x25fc
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Shell::add(string fileName)
{
    if (this->newFile(fileName)) {
        cout << "Would You Like To Add Data (y/n): ";
        string buffer;
        getline(cin, buffer);
        if (buffer == "y" || buffer == "Y")
            this->append(fileName);
    };
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x78(%rbp), %r15
movq %r15, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4346
movl %eax, %r15d
leaq -0x78(%rbp), %rdi
callq 0x20e0
testl %r15d, %r15d
je 0x2d34
movq 0x6312(%rip), %rdi      # 0x8fc8
leaq 0x33dd(%rip), %rsi      # 0x609a
callq 0x21d0
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x6307(%rip), %rdi      # 0x8fe0
leaq -0x38(%rbp), %rsi
callq 0x2060
leaq 0x34b2(%rip), %rsi      # 0x619b
leaq -0x38(%rbp), %rdi
callq 0x3711
testb %al, %al
jne 0x2d0a
leaq 0x33c0(%rip), %rsi      # 0x60bd
leaq -0x38(%rbp), %rdi
callq 0x3711
testb %al, %al
je 0x2d2b
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x2290
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x2d6e
leaq -0x58(%rbp), %rdi
callq 0x20e0
leaq -0x38(%rbp), %rdi
callq 0x20e0
pushq $0x1
popq %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20e0
jmp 0x2d5c
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
jmp 0x2d60
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Shell::del(string fileName)
{
    int curBlock = this->getFirstBlock(fileName);

    // Return If File Does Not Exist
    if (curBlock == -1) {
        cout << "Cannot Find File To Remove" << endl;
        return 0;
    }

    // Remove All Blocks From File
    while ((curBlock = this->getFirstBlock(fileName)) > 0)
        this->delBlock(fileName, curBlock);

    // Remove File From Root
    this->rmFile(fileName);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x2290
movq %r14, %rdi
movq %rbx, %rsi
callq 0x444a
movl %eax, %r12d
leaq -0x68(%rbp), %rdi
callq 0x20e0
cmpl $-0x1, %r12d
je 0x31cc
leaq -0xa8(%rbp), %rbx
leaq -0x88(%rbp), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2290
movq %r14, %rdi
movq %rbx, %rsi
callq 0x444a
movl %eax, %r13d
movq %rbx, %rdi
callq 0x20e0
testl %r13d, %r13d
jle 0x31a4
movq %r12, %rdi
movq %r15, %rsi
callq 0x2290
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x478c
movq %r12, %rdi
callq 0x20e0
jmp 0x315b
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2290
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44de
leaq -0x48(%rbp), %rdi
callq 0x20e0
pushq $0x1
popq %rax
jmp 0x31e9
movq 0x5df5(%rip), %rdi      # 0x8fc8
leaq 0x2ee5(%rip), %rsi      # 0x60bf
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3207
jmp 0x3207
movq %rax, %r14
movq %r12, %rbx
jmp 0x320a
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2330