LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/syntax.cpp
// Function: ExprStatement::parse(Tokenizer*, std::vector<std::shared_ptr<FunctionToken>, std::allocator<std::shared_ptr<FunctionToken>>> const&, std::vector<std::shared_ptr<GlobalVarToken>, std::allocator<std::shared_ptr<GlobalVarToken>>> const&, std::vector<std::shared_ptr<ParamToken>, std::allocator<std::shared_ptr<ParamToken>>> const&, std::vector<std::shared_ptr<LocalVarToken>, std::allocator<std::shared_ptr<LocalVarToken>>> const&)
bool ExprStatement::parse(
      Tokenizer *tokenizer,
      const std::vector<std::shared_ptr<FunctionToken>>& functions,
      const std::vector<std::shared_ptr<GlobalVarToken>>& globals,
      const std::vector<std::shared_ptr<ParamToken>>& parameters,
      const std::vector<std::shared_ptr<LocalVarToken>>& localVars) {
  _lineNum = tokenizer->peekNext().line();
  // An expression statement is just an expression followed by a semicolon.
  if (!_expr.parse(tokenizer, functions, globals, parameters, localVars)) {
    return false;
  }
  if (!_expect(tokenizer, ";")) {
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %rbp
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x279a6
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbp)
movq %r14, %rdi
callq 0x7b20
addq $0x10, %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
callq 0xe5a8
testb %al, %al
je 0x16d7c
leaq 0x12e73(%rip), %rsi     # 0x29bc1
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x9502
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x286c3
movl %eax, %ebx
leaq 0x18(%rsp), %rdi
callq 0x75c8
jmp 0x16d7e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x75c8
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/tokenizer.cpp
// Function: Tokenizer::Tokenizer(char*)
Tokenizer::Tokenizer(char *filename) : _offset(0), _lineNum(1),
                                       _hasNext(false) {
  std::ifstream inputStream(filename);
  inputStream.seekg(0, std::ios::end);
  _data.reserve(inputStream.tellg());
  inputStream.seekg(0, std::ios::beg);
  _data.assign(std::istreambuf_iterator<char>(inputStream),
               std::istreambuf_iterator<char>());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, (%rdi)
xorl %eax, %eax
movb %al, 0x8(%rdi)
orl $-0x1, 0x18(%rdi)
leaq 0x166b4(%rip), %rcx     # 0x3dd10
movq %rcx, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %r14
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x7540
leaq 0x8(%rsp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x73d0
leaq 0x8(%rsp), %rdi
callq 0x74f0
movq %r14, %rdi
movq %rax, %rsi
callq 0x7470
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x73d0
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
movq 0xf0(%rsp,%rax), %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x279fa
leaq 0x8(%rsp), %rdi
callq 0x70b0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x2770f
jmp 0x27702
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x70b0
addq $0x10, %rbx
movq %r14, %rdi
callq 0x75c8
movq %rbx, %rdi
callq 0x7b20
movq %r15, %rdi
callq 0x7510
nop
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/util.cpp
// Function: operandValueToReg(Parser*, Operand const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string toHexStr(uint16_t value, int digits) {
  std::string str;
  for (int i = 0; i < digits; i++) {
    uint8_t next = value & 0xf;
    value >>= 4;
    str = (char)(next <= 9 ? '0' + next : 'a' - 10 + next) + str;
  }
  return "0x" + str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl (%rsi), %eax
cmpq $0x3, %rax
ja 0x27e34
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3936(%rip), %rcx      # 0x2b5d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x147a(%rip), %rsi      # 0x29124
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x9980
movq %rbx, %rdi
movq %r15, %rsi
callq 0x914a
leaq 0x8(%rsp), %rdi
callq 0x75c8
leaq 0x390a(%rip), %rsi      # 0x2b5e0
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x9980
leaq 0x1448(%rip), %rdx      # 0x29135
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x9ad4
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x9ab5
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x914a
leaq 0x8(%rsp), %rdi
jmp 0x27e1b
leaq 0x13fa(%rip), %rsi      # 0x29124
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x9980
movq %rbx, %rdi
movq %r15, %rsi
callq 0x914a
leaq 0x8(%rsp), %rdi
jmp 0x27e2f
leaq 0x3890(%rip), %rsi      # 0x2b5e6
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0x9980
leaq 0x13c8(%rip), %rdx      # 0x29135
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x9ad4
movzwl 0x28(%r15), %esi
leaq 0x68(%rsp), %rdi
pushq $0x4
popq %rdx
callq 0x27ea7
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x18714
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x914a
jmp 0x27e0c
leaq 0x1373(%rip), %rsi      # 0x29129
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0x9980
leaq 0x1368(%rip), %rdx      # 0x29135
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x9ad4
addq $0x8, %r15
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x73e0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x18714
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x914a
leaq 0x8(%rsp), %rdi
callq 0x75c8
leaq 0x68(%rsp), %rdi
callq 0x75c8
leaq 0x28(%rsp), %rdi
callq 0x75c8
leaq 0x48(%rsp), %rdi
callq 0x75c8
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x27e4f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x27e6a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x75c8
jmp 0x27e65
jmp 0x27e62
jmp 0x27e75
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x75c8
jmp 0x27e78
jmp 0x27e75
jmp 0x27e88
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x75c8
jmp 0x27e8b
jmp 0x27e88
jmp 0x27e9d
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x75c8
movq %rbx, %rdi
callq 0x7510
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x27e90
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/util.cpp
// Function: otherParen(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string otherParen(const std::string& paren) {
  if ("(" == paren) {
    return ")";
  } else if (")" == paren) {
    return "(";
  } else if ("[" == paren) {
    return "]";
  } else if ("]" == paren) {
    return "[";
  } else if ("{" == paren) {
    return "}";
  } else if ("}" == paren) {
    return "{";
  }
  return "";
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x113f(%rip), %rdi      # 0x290a9
callq 0x97dd
testb %al, %al
je 0x27f84
leaq 0x2964(%rip), %rsi      # 0x2a8de
leaq 0x7(%rsp), %rdx
jmp 0x28038
leaq 0x2953(%rip), %rdi      # 0x2a8de
movq %r14, %rsi
callq 0x97dd
testb %al, %al
je 0x27fa8
leaq 0x110b(%rip), %rsi      # 0x290a9
leaq 0x6(%rsp), %rdx
jmp 0x28038
leaq 0x1645(%rip), %rdi      # 0x295f4
movq %r14, %rsi
callq 0x97dd
testb %al, %al
je 0x27fc9
leaq 0x18e0(%rip), %rsi      # 0x298a2
leaq 0x5(%rsp), %rdx
jmp 0x28038
leaq 0x18d2(%rip), %rdi      # 0x298a2
movq %r14, %rsi
callq 0x97dd
testb %al, %al
je 0x27fea
leaq 0x1611(%rip), %rsi      # 0x295f4
leaq 0x4(%rsp), %rdx
jmp 0x28038
leaq 0x19e2(%rip), %rdi      # 0x299d3
movq %r14, %rsi
callq 0x97dd
testb %al, %al
je 0x2800b
leaq 0x19d1(%rip), %rsi      # 0x299d5
leaq 0x3(%rsp), %rdx
jmp 0x28038
leaq 0x19c3(%rip), %rdi      # 0x299d5
movq %r14, %rsi
callq 0x97dd
testb %al, %al
je 0x2802c
leaq 0x19ae(%rip), %rsi      # 0x299d3
leaq 0x2(%rsp), %rdx
jmp 0x28038
leaq 0x209c(%rip), %rsi      # 0x2a0cf
leaq 0x1(%rsp), %rdx
movq %rbx, %rdi
callq 0x9502
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/util.cpp
// Function: getParameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<ParamToken>, std::allocator<std::shared_ptr<ParamToken>>> const&)
std::shared_ptr<ParamToken> getParameter(
      const std::string& name,
      const std::vector<std::shared_ptr<ParamToken>>& parameters) {
  for (auto param : parameters) {
    if (param->name() == name) {
      return param;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq 0x8(%rdx), %r15
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %r13
cmpq %r15, %r12
je 0x2832c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9d16
movq (%rbx), %rsi
addq $0x70, %rsi
movq %r13, %rdi
callq 0x73e0
movq %r13, %rdi
movq %r14, %rsi
callq 0xb1d0
movl %eax, %ebp
movq %r13, %rdi
callq 0x75c8
testb %bpl, %bpl
jne 0x28332
movq (%rsp), %rdi
callq 0x7a34
addq $0x10, %r12
jmp 0x282e4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x7a34
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/util.cpp
// Function: getLocal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<LocalVarToken>, std::allocator<std::shared_ptr<LocalVarToken>>> const&)
std::shared_ptr<LocalVarToken> getLocal(
      const std::string& name,
      const std::vector<std::shared_ptr<LocalVarToken>>& locals) {
  for (auto local : locals) {
    if (local->name() == name) {
      return local;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq 0x8(%rdx), %r15
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %r13
cmpq %r15, %r12
je 0x283c8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x18ee0
movq (%rbx), %rsi
addq $0x70, %rsi
movq %r13, %rdi
callq 0x73e0
movq %r13, %rdi
movq %r14, %rsi
callq 0xb1d0
movl %eax, %ebp
movq %r13, %rdi
callq 0x75c8
testb %bpl, %bpl
jne 0x283ce
movq (%rsp), %rdi
callq 0x7a34
addq $0x10, %r12
jmp 0x28380
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x7a34
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/util.cpp
// Function: getFunction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<FunctionToken>, std::allocator<std::shared_ptr<FunctionToken>>> const&)
std::shared_ptr<FunctionToken> getFunction(
      const std::string& name,
      const std::vector<std::shared_ptr<FunctionToken>>& functions) {
  for (auto func : functions) {
    if (func->name() == name) {
      return func;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq 0x8(%rdx), %r15
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %r13
cmpq %r15, %r12
je 0x28464
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa23e
movq (%rbx), %rsi
addq $0x58, %rsi
movq %r13, %rdi
callq 0x73e0
movq %r13, %rdi
movq %r14, %rsi
callq 0xb1d0
movl %eax, %ebp
movq %r13, %rdi
callq 0x75c8
testb %bpl, %bpl
jne 0x2846a
movq (%rsp), %rdi
callq 0x7a34
addq $0x10, %r12
jmp 0x2841c
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x7a34
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/util.cpp
// Function: getGlobal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<GlobalVarToken>, std::allocator<std::shared_ptr<GlobalVarToken>>> const&)
std::shared_ptr<GlobalVarToken> getGlobal(
     const std::string& name,
     const std::vector<std::shared_ptr<GlobalVarToken>>& globals) {
  for (auto global : globals) {
    if (global->name() == name) {
      return global;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq 0x8(%rdx), %r15
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %r13
cmpq %r15, %r12
je 0x28500
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa22a
movq (%rbx), %rsi
addq $0x70, %rsi
movq %r13, %rdi
callq 0x73e0
movq %r13, %rdi
movq %r14, %rsi
callq 0xb1d0
movl %eax, %ebp
movq %r13, %rdi
callq 0x75c8
testb %bpl, %bpl
jne 0x28506
movq (%rsp), %rdi
callq 0x7a34
addq $0x10, %r12
jmp 0x284b8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x7a34
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/util.cpp
// Function: getLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<LabelStatement>, std::allocator<std::shared_ptr<LabelStatement>>> const&)
std::shared_ptr<LabelStatement> getLabel(
      const std::string& name,
      const std::vector<std::shared_ptr<LabelStatement>>& labels) {
  for (auto label : labels) {
    if (label->name() == name) {
      return label;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r12
movq 0x8(%rdx), %r15
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %r13
cmpq %r15, %r12
je 0x2859c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x18ef4
movq (%rbx), %rsi
addq $0x10, %rsi
movq %r13, %rdi
callq 0x73e0
movq %r13, %rdi
movq %r14, %rsi
callq 0xb1d0
movl %eax, %ebp
movq %r13, %rdi
callq 0x75c8
testb %bpl, %bpl
jne 0x285a2
movq (%rsp), %rdi
callq 0x7a34
addq $0x10, %r12
jmp 0x28554
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x7a34
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/util.cpp
// Function: error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void _error(const std::string& msg, int lineNum) {
  // TODO: It would be nice to have error messages that showed you
  // the source line and pointed to the token causing an error.
  std::cerr << "Error:";
  if (0 < lineNum) {
    std::cerr << lineNum << ":";
  }
  std::cerr << " " << msg << std::endl;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x169e6(%rip), %rdi     # 0x3efe8
leaq 0x3019(%rip), %rsi      # 0x2b622
callq 0x72a0
testl %ebp, %ebp
jle 0x2862f
movq 0x169cf(%rip), %rdi     # 0x3efe8
movl %ebp, %esi
callq 0x74e0
leaq 0x3009(%rip), %rsi      # 0x2b630
movq %rax, %rdi
callq 0x72a0
movq 0x169b2(%rip), %rdi     # 0x3efe8
leaq 0xaf8(%rip), %rsi       # 0x29135
callq 0x72a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7280
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7170
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/util.cpp
// Function: warn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void _warn(const std::string& msg, int lineNum) {
  std::cerr << "Warning:";
  if (0 < lineNum) {
    std::cerr << lineNum << ":";
  }
  std::cerr << " " << msg << std::endl;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x1697e(%rip), %rdi     # 0x3efe8
leaq 0x2fb8(%rip), %rsi      # 0x2b629
callq 0x72a0
testl %ebp, %ebp
jle 0x28697
movq 0x16967(%rip), %rdi     # 0x3efe8
movl %ebp, %esi
callq 0x74e0
leaq 0x2fa1(%rip), %rsi      # 0x2b630
movq %rax, %rdi
callq 0x72a0
movq 0x1694a(%rip), %rdi     # 0x3efe8
leaq 0xa90(%rip), %rsi       # 0x29135
callq 0x72a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7280
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7170
// File: /workspace/github_cpp_makefile_star2_O2/rfotino[P]consolite-compiler/src/util.cpp
// Function: expect(Tokenizer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
bool _expect(Tokenizer *tokenizer, const std::string& str, bool errors) {
  AtomToken t = tokenizer->getNext();
  if (t.str().empty()) {
    if (errors) {
      _error("Unexpected EOF, expected '" + str + "'.", t.line());
    }
    return false;
  } else if (str != t.str()) {
    if (errors) {
      _error("Unexpected token '" + t.str() + "', expected '" + str + "'.",
             t.line());
    }
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0xa0(%rsp), %rdi
callq 0x2772c
leaq 0xb0(%rsp), %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x73e0
movq %rsp, %rdi
movq 0x8(%rdi), %r15
callq 0x75c8
testq %r15, %r15
je 0x287e4
movq %rsp, %rdi
movq %r14, %rsi
callq 0x73e0
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9aab
movl %eax, %r15d
movq %r12, %rdi
callq 0x75c8
andb %r15b, %bpl
cmpb $0x1, %bpl
jne 0x28837
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x73e0
leaq 0x1153(%rip), %rsi      # 0x298a7
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x1832f
leaq 0x2ee3(%rip), %rdx      # 0x2b64d
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x9ad4
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq %rbx, %rdx
callq 0x9ab5
leaq 0x15aa(%rip), %rdx      # 0x29d42
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x9ad4
movl 0xa8(%rsp), %esi
movq %rsp, %rdi
callq 0x285f3
movq %rsp, %rdi
callq 0x75c8
leaq 0x20(%rsp), %rdi
callq 0x75c8
leaq 0x80(%rsp), %rdi
callq 0x75c8
leaq 0x60(%rsp), %rdi
callq 0x75c8
leaq 0x40(%rsp), %rdi
jmp 0x2882d
testb %bpl, %bpl
je 0x28832
leaq 0x2e42(%rip), %rsi      # 0x2b632
leaq 0x20(%rsp), %rdi
movq %rbx, %rdx
callq 0x9980
leaq 0x153e(%rip), %rdx      # 0x29d42
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x9ad4
movl 0xa8(%rsp), %esi
movq %rsp, %rdi
callq 0x285f3
movq %rsp, %rdi
callq 0x75c8
leaq 0x20(%rsp), %rdi
callq 0x75c8
xorl %r15d, %r15d
jmp 0x2883b
xorb $0x1, %r15b
leaq 0xa0(%rsp), %rdi
callq 0x7b20
movl %r15d, %eax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x75c8
jmp 0x2886b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x288b9
jmp 0x288c4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x75c8
jmp 0x28884
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x75c8
jmp 0x28893
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x75c8
jmp 0x288a5
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x75c8
jmp 0x288b4
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x75c8
jmp 0x288c7
jmp 0x288c4
jmp 0x288c4
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x7b20
movq %rbx, %rdi
callq 0x7510
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/main.cc
// Function: welcome(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void welcome(string input){
  char block;
  ifstream fin;
  fin.open(input.c_str());
  while(!fin.eof()){
    fin>>block;
    if(block == '!')
      cout<<'\xDC';
    else if(block == '#')
      cout<<'\xDB';
    else if (block == '@')
      cout<<'\xB2';
    else if(block == '-')
      cout<<' ';
    else if(block == '^')
      cout<<'\xB1';
    else if(block =='%')
      cout<<'\xB0';
    else if(block == '$')
      cout<<'\xDF';
    else if(block ==',')
      cout<<'\xB3';
    else if (block == 'e')
      cout<<'\n';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq -0x230(%rbp), %r14
movq %r14, %rdi
callq 0x21f0
movq (%rbx), %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2150
leaq -0x230(%rbp), %rbx
leaq -0x21(%rbp), %r14
movq 0xb69b(%rip), %r15      # 0xdfd0
leaq 0x66c8(%rip), %r12      # 0x9004
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x210(%rbp,%rax)
jne 0x29af
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
movzbl -0x21(%rbp), %eax
leal -0x21(%rax), %ecx
cmpl $0xc, %ecx
ja 0x2975
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
jmpq *%rax
movb $-0x24, %al
jmp 0x29a2
cmpl $0x40, %eax
je 0x29a0
cmpl $0x5e, %eax
je 0x299c
cmpl $0x65, %eax
jne 0x293c
movb $0xa, %al
jmp 0x29a2
movb $-0x4d, %al
jmp 0x29a2
movb $-0x21, %al
jmp 0x29a2
movb $-0x50, %al
jmp 0x29a2
movb $-0x25, %al
jmp 0x29a2
movb $0x20, %al
jmp 0x29a2
movb $-0x4f, %al
jmp 0x29a2
movb $-0x4e, %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x2200
jmp 0x293c
leaq -0x230(%rbp), %rdi
callq 0x2080
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29cd
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::Unit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int, int, int, int, int, int, int, int, int, int, bool, bool, bool, bool, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Unit::Unit(string Name,int Level, int Health,int MaxHealth,int Attack,int Range,int Defence,
	int Exp, int MaxExp, int Gold, int Stam, int Dice, int xpos, int ypos,
bool lEquip, bool rEquip, bool hEquip,bool tEquip, bool legEquip, bool ftEquip,
 string cWorld){
  name=Name;
  level = Level;

  health=Health;
  maxHealth=MaxHealth;

  attack=Attack;
  range=Range;
  defence=Defence;

  gold=Gold;

  experience=Exp;
  maxExperience = MaxExp;
  stamina = Stam;
  dice = Dice;

  posX = xpos;
  posY = ypos;


//need to pass in or else will always spawn with empty items, thus will enable equiping multiple items.
	leftHandEquipped = lEquip;
	rightHandEquipped =rEquip;
  torsoEquipped = tEquip;
	headEquipped =hEquip;
	legsEquipped =legEquip;
	feetEquipped =ftEquip;

  currentWorld = cWorld;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r12d
movl %r8d, %r13d
movl %ecx, %r15d
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, -0x30(%rbp)
movb %al, 0x68(%rdi)
leaq 0x80(%rdi), %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rdi)
andq $0x0, 0x90(%rdi)
callq 0x2130
movl %r14d, 0x44(%rbx)
movl %r15d, 0x20(%rbx)
movl %r13d, 0x24(%rbx)
movl %r12d, 0x2c(%rbx)
movl 0x10(%rbp), %eax
movl %eax, 0x30(%rbx)
movl 0x18(%rbp), %eax
movl %eax, 0x34(%rbx)
movl 0x30(%rbp), %eax
movl %eax, 0x38(%rbx)
movl 0x20(%rbp), %eax
movl %eax, 0x40(%rbx)
movl 0x28(%rbp), %eax
movl %eax, 0x3c(%rbx)
movl 0x38(%rbp), %eax
movl %eax, 0x28(%rbx)
movl 0x40(%rbp), %eax
movl %eax, 0x48(%rbx)
movl 0x48(%rbp), %eax
movl %eax, 0x78(%rbx)
movl 0x50(%rbp), %eax
movl %eax, 0x7c(%rbx)
movb 0x80(%rbp), %al
movb 0x58(%rbp), %cl
movb %cl, 0x98(%rbx)
movb 0x60(%rbp), %cl
movb %cl, 0x99(%rbx)
movb 0x70(%rbp), %cl
movb %cl, 0x9b(%rbx)
movb 0x68(%rbp), %cl
movb %cl, 0x9a(%rbx)
movb 0x78(%rbp), %cl
movb %cl, 0x9c(%rbx)
movb %al, 0x9d(%rbx)
movq 0x88(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x2130
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x2e80
movq -0x30(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::levelUp()
void Unit::levelUp(){
  if(experience >= maxExperience){
    //increases level
    level++;
    //resets exp starting from 0+excess experience
    experience -= maxExperience;
    //increase maxExperience with equation y=(x^2)+(22x)+22
    maxExperience = ( ((level)*(level)) + (22*(level)) +(22) );

    maxHealth++;
    if(level %3 ==0){
      maxHealth++;
    }
    if(level%5 == 0){
      maxHealth++;
    }
    if(level%10 == 0){
      attack++;
      defence++;
      dice++;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x40(%rdi), %eax
subl 0x3c(%rdi), %eax
jl 0x325c
movl 0x44(%rdi), %edx
leal 0x1(%rdx), %ecx
movl %ecx, 0x44(%rdi)
movl %eax, 0x40(%rdi)
addl $0x17, %edx
imull %ecx, %edx
addl $0x16, %edx
movl %edx, 0x3c(%rdi)
movl $0x3, %esi
movl %ecx, %eax
cltd
idivl %esi
xorl %esi, %esi
testl %edx, %edx
sete %sil
movl $0x5, %r8d
movl %ecx, %eax
cltd
idivl %r8d
cmpl $0x1, %edx
adcl 0x24(%rdi), %esi
incl %esi
movl %esi, 0x24(%rdi)
movl $0xa, %esi
movl %ecx, %eax
cltd
idivl %esi
testl %edx, %edx
jne 0x325c
incl 0x2c(%rdi)
incl 0x34(%rdi)
incl 0x48(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::displayStats()
void Unit::displayStats(){
  cout<<"==============STATS=============="<<endl;
  cout<<setfill(' ');
  cout<<"NAME:"<<name<<" x:"<<posX<<" y:"<< posY<<endl;
  cout<<"Health:"<<health<<'/'<<left<<setw(14)<<maxHealth<<"Experience:"<<experience<<endl;
  cout<<"Attack:"<<left<<setw(17)<<attack<<"Defence:"<<defence<<endl;
  cout<<setfill('=')<<setw(35)<<"==";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xad5e(%rip), %rbx      # 0xdfd0
leaq 0x5e72(%rip), %rsi      # 0x90eb
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x2110
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x22b0
leaq 0x5e72(%rip), %rsi      # 0x910d
movq %rbx, %rdi
callq 0x21c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21b0
leaq 0x5e5e(%rip), %rsi      # 0x9113
movq %rax, %rdi
callq 0x21c0
movl 0x78(%r14), %esi
movq %rax, %rdi
callq 0x22f0
leaq 0x5e47(%rip), %rsi      # 0x9117
movq %rax, %rdi
callq 0x21c0
movl 0x7c(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x2110
leaq 0x5e28(%rip), %rsi      # 0x911b
movq %rbx, %rdi
callq 0x21c0
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x22f0
pushq $0x2f
popq %rsi
movq %rax, %rdi
callq 0x2200
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl $0xffffff4f, %r15d      # imm = 0xFFFFFF4F
movl 0x18(%rax,%rdx), %esi
andl %r15d, %esi
orl $0x20, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq $0xe, 0x10(%rax,%rcx)
movl 0x24(%r14), %esi
movq %rax, %rdi
callq 0x22f0
leaq 0x5dd6(%rip), %rsi      # 0x9123
movq %rax, %rdi
callq 0x21c0
movl 0x40(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x2110
leaq 0x5dbf(%rip), %rsi      # 0x912f
movq %rbx, %rdi
callq 0x21c0
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
andl 0x18(%rax,%rdx), %r15d
orl $0x20, %r15d
movl %r15d, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq $0x11, 0x10(%rax,%rcx)
movl 0x2c(%r14), %esi
movq %rax, %rdi
callq 0x22f0
leaq 0x5d8a(%rip), %rsi      # 0x9137
movq %rax, %rdi
callq 0x21c0
movl 0x34(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x2110
pushq $0x3d
popq %rsi
movq %rbx, %rdi
callq 0x22b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x23, 0x10(%rax,%rcx)
leaq 0x63ce(%rip), %rsi      # 0x97b9
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::distanceTo(int, int)
int Unit::distanceTo(const int targetX, const int targetY){
  int dist;
  //distance between 2 points
  dist = sqrt( ( (targetX - this->getPosX())*(targetX - this->getPosX()) )
    +  ( targetY - this->getPosY())*(targetY - this->getPosY()) );
  //because distance cannot be negative
  if(dist< 0)
    return -(dist);
  else
    return dist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subl 0x78(%rdi), %esi
imull %esi, %esi
subl 0x7c(%rdi), %edx
imull %edx, %edx
addl %esi, %edx
cvtsi2sd %edx, %xmm0
sqrtsd %xmm0, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::saveUnit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Unit::saveUnit(string file){
  this->name = file;
  ofstream fout;
  fout.open(("./saves/" + file).c_str());
  fout<<*this;
  fout.close();
  inv.saveInventory(file);
  cout<<"unit saved\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2130
leaq -0x250(%rbp), %rdi
callq 0x22e0
leaq 0x5b1e(%rip), %rsi      # 0x9322
leaq -0x50(%rbp), %rdi
movq %r14, %rdx
callq 0x47d2
movq -0x50(%rbp), %rsi
leaq -0x250(%rbp), %rdi
pushq $0x10
popq %rdx
callq 0x2050
leaq -0x50(%rbp), %rdi
callq 0x2100
leaq -0x250(%rbp), %rdi
movq %rbx, %rsi
callq 0x446b
leaq -0x250(%rbp), %rdi
callq 0x2260
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x2250
subq $-0x80, %rbx
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x7570
leaq -0x30(%rbp), %rdi
callq 0x2100
movq 0xa75d(%rip), %rdi      # 0xdfd0
leaq 0x5add(%rip), %rsi      # 0x9357
callq 0x21c0
leaq -0x250(%rbp), %rdi
callq 0x2280
addq $0x240, %rsp            # imm = 0x240
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x38a7
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2100
jmp 0x38b3
jmp 0x38b0
movq %rax, %rbx
leaq -0x250(%rbp), %rdi
callq 0x2280
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::loadUnit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Unit::loadUnit(string file){
  ifstream fin;
	string temp ="./saves/" + file;
  fin.open(temp.c_str());
  while(fin.fail()){
    cout<<"invalid player, enter a name>> ";
    cin>>file;
    fin.open(("./saves/" + file).c_str());
  }
  fin>>*this;
  fin.close();
  inv.loadInventory(file);
  cout<<"unit Loaded";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x298(%rbp), %rdi
callq 0x21f0
leaq 0x512e(%rip), %rsi      # 0x9322
leaq -0x70(%rbp), %rdi
movq %r14, %rdx
callq 0x47d2
movq -0x70(%rbp), %rsi
leaq -0x298(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2150
leaq 0x5108(%rip), %rbx      # 0x9322
leaq -0x90(%rbp), %r15
leaq -0x298(%rbp), %r12
pushq $0x8
popq %r13
movq -0x298(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x278(%rbp,%rax)
je 0x428d
movq 0x9d88(%rip), %rdi      # 0xdfd0
leaq 0x50dc(%rip), %rsi      # 0x932b
callq 0x21c0
movq 0x9d85(%rip), %rdi      # 0xdfe0
movq %r14, %rsi
callq 0x2220
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x47d2
movq -0x90(%rbp), %rsi
movq %r12, %rdi
movl %r13d, %edx
callq 0x2150
movq %r15, %rdi
callq 0x2100
jmp 0x422c
leaq -0x298(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x434c
leaq -0x298(%rbp), %rdi
callq 0x2070
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x2250
movq -0x30(%rbp), %rdi
subq $-0x80, %rdi
leaq -0x50(%rbp), %rsi
callq 0x7776
leaq -0x50(%rbp), %rdi
callq 0x2100
movq 0x9cfa(%rip), %rdi      # 0xdfd0
leaq 0x506e(%rip), %rsi      # 0x934b
callq 0x21c0
leaq -0x70(%rbp), %rdi
callq 0x2100
leaq -0x298(%rbp), %rdi
callq 0x2080
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x4325
movq %rax, %rbx
jmp 0x4338
jmp 0x432c
jmp 0x432c
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x2100
jmp 0x432f
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2100
leaq -0x298(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/unit.cc
// Function: operator>>(std::istream&, Unit&)
istream& operator >> (istream& iStr, Unit& i){
  iStr>>i.name>>i.level>>i.health>>i.maxHealth>>i.stamina>>i.attack>>i.range>>i.defence>>i.gold>>i.experience>>i.maxExperience>>i.dice;
  iStr>>i.leftHandEquipped>>i.rightHandEquipped>>i.headEquipped>>i.torsoEquipped>>i.legsEquipped>>i.feetEquipped;
  iStr>>i.posX>>i.posY;
  iStr>>i.currentWorld;
  return iStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2220
leaq 0x44(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x24(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x2c(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x30(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x34(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x38(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x3c(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x48(%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x98(%r14), %rsi
movq %rbx, %rdi
callq 0x2190
leaq 0x99(%r14), %rsi
movq %rax, %rdi
callq 0x2190
leaq 0x9a(%r14), %rsi
movq %rax, %rdi
callq 0x2190
leaq 0x9b(%r14), %rsi
movq %rax, %rdi
callq 0x2190
leaq 0x9c(%r14), %rsi
movq %rax, %rdi
callq 0x2190
leaq 0x9d(%r14), %rsi
movq %rax, %rdi
callq 0x2190
leaq 0x78(%r14), %rsi
movq %rbx, %rdi
callq 0x2140
leaq 0x7c(%r14), %rsi
movq %rax, %rdi
callq 0x2140
addq $0x58, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2220
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/unit.cc
// Function: operator<<(std::ostream&, Unit const&)
ostream& operator << (ostream& oStr, const Unit& i){
  oStr<<i.name<<' '<<i.level<<' '<<i.health<<' '<<i.maxHealth<<' '<<i.stamina<<' '<<i.attack<<' '<<i.range<<' '<<i.defence<<' '<<i.gold<<' '<<i.experience<<' '<<i.maxExperience<<' '<<i.dice<<' ';
  oStr<<i.leftHandEquipped<<' '<<i.rightHandEquipped<<' '<<i.headEquipped<<' '<<i.torsoEquipped<<' '<<i.legsEquipped<<' '<<i.feetEquipped<<' ';
  oStr<<i.posX<<' '<<i.posY<<' ';
  oStr<<i.currentWorld<<' ';
  return oStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x21b0
pushq $0x20
popq %r15
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x44(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x24(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x28(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x2c(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x30(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x34(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x38(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x40(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x3c(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x48(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movzbl 0x98(%r14), %esi
movq %rbx, %rdi
callq 0x22d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movzbl 0x99(%r14), %esi
movq %rax, %rdi
callq 0x22d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movzbl 0x9a(%r14), %esi
movq %rax, %rdi
callq 0x22d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movzbl 0x9b(%r14), %esi
movq %rax, %rdi
callq 0x22d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movzbl 0x9c(%r14), %esi
movq %rax, %rdi
callq 0x22d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movzbl 0x9d(%r14), %esi
movq %rax, %rdi
callq 0x22d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x78(%r14), %esi
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x7c(%r14), %esi
movq %rax, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
addq $0x58, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21b0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/unit.cc
// Function: Unit::operator=(Unit const&)
Unit& Unit::operator= (const Unit& i){
  name = i.name;
  health = i.health;
  maxHealth = i.maxHealth;
  stamina = i.stamina;
  attack = i.attack;
  range = i.range;
  defence = i.defence;
  gold = i.gold;
  experience = i.experience;
  maxExperience = i.maxExperience;
  dice = i.dice;
  leftHandEquipped = i.leftHandEquipped;
  rightHandEquipped = i.rightHandEquipped;
  torsoEquipped = i.torsoEquipped;
  legsEquipped = i.legsEquipped;
  feetEquipped = i.feetEquipped;
  posX = i.posX;
  posY = i.posY;
  currentWorld = i.currentWorld;
  inv = i.inv;
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2130
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movl 0x24(%r14), %eax
movl %eax, 0x24(%rbx)
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movl 0x2c(%r14), %eax
movl %eax, 0x2c(%rbx)
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movl 0x34(%r14), %eax
movl %eax, 0x34(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
movl 0x40(%r14), %eax
movl %eax, 0x40(%rbx)
movl 0x3c(%r14), %eax
movl %eax, 0x3c(%rbx)
movl 0x48(%r14), %eax
movl %eax, 0x48(%rbx)
movb 0x98(%r14), %al
movb %al, 0x98(%rbx)
movb 0x99(%r14), %al
movb %al, 0x99(%rbx)
movb 0x9b(%r14), %al
movb %al, 0x9b(%rbx)
movb 0x9c(%r14), %al
movb %al, 0x9c(%rbx)
movb 0x9d(%r14), %al
movb %al, 0x9d(%rbx)
movl 0x78(%r14), %eax
movl %eax, 0x78(%rbx)
movl 0x7c(%r14), %eax
movl %eax, 0x7c(%rbx)
leaq 0x58(%r14), %rsi
leaq 0x58(%rbx), %rdi
callq 0x2130
movl $0x80, %edi
addq %rdi, %r14
addq %rbx, %rdi
movq %r14, %rsi
callq 0x7bf8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/item.cc
// Function: Item::Item(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int, int, bool)
Item::Item(string n , string type,int ran, int dam, int def, int val,int dur, bool held){
  itemName=n;
  itemType = type;
  itemRange = ran;
  itemDamage=dam;
  itemDefence=def;
  itemWorth=val;
  itemIsEquipped = held;
  itemDurability= dur;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x2c(%rbp)
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r13
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
callq 0x2130
movq %r13, %rdi
movq %r14, %rsi
callq 0x2130
movb 0x20(%rbp), %al
movl 0x18(%rbp), %ecx
movl 0x10(%rbp), %edx
movl %r12d, 0x40(%rbx)
movl %r15d, 0x44(%rbx)
movl -0x2c(%rbp), %esi
movl %esi, 0x48(%rbx)
movl %edx, 0x4c(%rbx)
movb %al, 0x54(%rbx)
movl %ecx, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/item.cc
// Function: Item::viewItem()
void Item::viewItem(){
  cout<<itemName<<' ';
  cout<<itemType<<' ';
  if(itemRange != 0)
    cout<<"RANGE["<<itemRange<<"] ";
  if(itemDamage != 0)
    cout<<"DAMAGE:["<<itemDamage<<"] ";
  if(itemDefence != 0)
    cout<<"DEFENCE:["<<itemDefence<<"] ";
  if(itemWorth != 0)
    cout<<"WORTH:["<<itemWorth<<"] ";
  cout<<"Durability:["<<itemDurability<<"] ";
  if(itemIsEquipped == true)
    cout<<" [EQUIPPED]";
  cout<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x95ba(%rip), %r14      # 0xdfd0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21b0
pushq $0x20
popq %r15
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x21b0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
cmpl $0x0, 0x40(%rbx)
je 0x4a7a
movq 0x957c(%rip), %rdi      # 0xdfd0
leaq 0x4908(%rip), %rsi      # 0x9363
callq 0x21c0
movl 0x40(%rbx), %esi
movq %rax, %rdi
callq 0x22f0
leaq 0x48f8(%rip), %rsi      # 0x936a
movq %rax, %rdi
callq 0x21c0
cmpl $0x0, 0x44(%rbx)
je 0x4aad
movq 0x9549(%rip), %rdi      # 0xdfd0
leaq 0x48df(%rip), %rsi      # 0x936d
callq 0x21c0
movl 0x44(%rbx), %esi
movq %rax, %rdi
callq 0x22f0
leaq 0x48c5(%rip), %rsi      # 0x936a
movq %rax, %rdi
callq 0x21c0
cmpl $0x0, 0x48(%rbx)
je 0x4ae0
movq 0x9516(%rip), %rdi      # 0xdfd0
leaq 0x48b5(%rip), %rsi      # 0x9376
callq 0x21c0
movl 0x48(%rbx), %esi
movq %rax, %rdi
callq 0x22f0
leaq 0x4892(%rip), %rsi      # 0x936a
movq %rax, %rdi
callq 0x21c0
cmpl $0x0, 0x4c(%rbx)
je 0x4b13
movq 0x94e3(%rip), %rdi      # 0xdfd0
leaq 0x488c(%rip), %rsi      # 0x9380
callq 0x21c0
movl 0x4c(%rbx), %esi
movq %rax, %rdi
callq 0x22f0
leaq 0x485f(%rip), %rsi      # 0x936a
movq %rax, %rdi
callq 0x21c0
movq 0x94b6(%rip), %rdi      # 0xdfd0
leaq 0x4867(%rip), %rsi      # 0x9388
callq 0x21c0
movl 0x50(%rbx), %esi
movq %rax, %rdi
callq 0x22f0
leaq 0x4832(%rip), %rsi      # 0x936a
movq %rax, %rdi
callq 0x21c0
cmpb $0x1, 0x54(%rbx)
jne 0x4b59
movq 0x9483(%rip), %rdi      # 0xdfd0
leaq 0x4841(%rip), %rsi      # 0x9395
callq 0x21c0
movq 0x9470(%rip), %rdi      # 0xdfd0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/item.cc
// Function: Item::operator=(Item const&)
Item& Item::operator = (const Item& i){
  itemName = i.itemName;
  itemType = i.itemType;
  itemRange = i.itemRange;
  itemDamage = i.itemDamage;
  itemDefence = i.itemDefence;
  itemWorth = i.itemWorth;
  itemIsEquipped = i.itemIsEquipped;
  itemDurability = i.itemDurability;
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2130
leaq 0x20(%rbx), %rsi
leaq 0x20(%r14), %rdi
callq 0x2130
movl 0x40(%rbx), %eax
movl %eax, 0x40(%r14)
movl 0x44(%rbx), %eax
movl %eax, 0x44(%r14)
movl 0x48(%rbx), %eax
movl %eax, 0x48(%r14)
movl 0x4c(%rbx), %eax
movl %eax, 0x4c(%r14)
movb 0x54(%rbx), %al
movb %al, 0x54(%r14)
movl 0x50(%rbx), %eax
movl %eax, 0x50(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/item.cc
// Function: operator<<(std::ostream&, Item const&)
ostream& operator<<(ostream& oStr,const Item& i){
  oStr<<i.itemName<<' ';
  oStr<<i.itemType<<' ';
  oStr<<i.itemRange<<' ';
  oStr<<i.itemDamage<<' ';
  oStr<<i.itemDefence<<' ';
  oStr<<i.itemWorth<<' ';
  oStr<<i.itemDurability<<' ';
  oStr<<i.itemIsEquipped;
  return oStr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x21b0
pushq $0x20
popq %r15
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x40(%r14), %esi
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x44(%r14), %esi
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x48(%r14), %esi
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x4c(%r14), %esi
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movl 0x50(%r14), %esi
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2200
movzbl 0x54(%r14), %esi
movq %rbx, %rdi
callq 0x22d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/turn.cc
// Function: Turn::welcomeBanner(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Turn::welcomeBanner(string input){
char block;
ifstream fin;
fin.open(input.c_str());
	while(!fin.eof()){
	fin>>block;
		if(block == '!')
			cout<<'\xDC';
		else if(block == '#')
			cout<<'\xDB';
		else if (block == '@')
			cout<<'\xB2';
		else if(block == '-')
			cout<<' ';
		else if(block == '^')
			cout<<'\xB1';
		else if(block =='%')
			cout<<'\xB0';
		else if(block == '$')
			cout<<'\xDF';
		else if(block ==',')
			cout<<'\xB3';
		else if (block == 'e')
			cout<<'\n';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
leaq -0x230(%rbp), %r14
movq %r14, %rdi
callq 0x21f0
movq (%rbx), %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2150
leaq -0x230(%rbp), %rbx
leaq -0x21(%rbp), %r14
movq 0x85ac(%rip), %r15      # 0xdfd0
leaq 0x3981(%rip), %r12      # 0x93ac
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x210(%rbp,%rax)
jne 0x5a9e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
movzbl -0x21(%rbp), %eax
leal -0x21(%rax), %ecx
cmpl $0xc, %ecx
ja 0x5a64
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
jmpq *%rax
movb $-0x24, %al
jmp 0x5a91
cmpl $0x40, %eax
je 0x5a8f
cmpl $0x5e, %eax
je 0x5a8b
cmpl $0x65, %eax
jne 0x5a2b
movb $0xa, %al
jmp 0x5a91
movb $-0x4d, %al
jmp 0x5a91
movb $-0x21, %al
jmp 0x5a91
movb $-0x50, %al
jmp 0x5a91
movb $-0x25, %al
jmp 0x5a91
movb $0x20, %al
jmp 0x5a91
movb $-0x4f, %al
jmp 0x5a91
movb $-0x4e, %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x2200
jmp 0x5a2b
leaq -0x230(%rbp), %rdi
callq 0x2080
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5abc
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::Chart(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, bool)
Chart::Chart(string ChartName,int ChartWidth, int ChartHeight, bool FoW){
  chartWidth = ChartWidth;
  chartHeight = ChartHeight;
  fogOfWar = FoW;
  worldName = ChartName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rdi), %r14
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
xorl %eax, %eax
movb %al, 0x28(%rdi)
leaq 0x48(%rdi), %r15
addq $0x58, %rdi
movq %rdi, 0x48(%rbx)
andq $0x0, 0x50(%rbx)
movb %al, 0x58(%rbx)
movl %edx, 0x3c(%rbx)
movl %ecx, 0x40(%rbx)
movb %r8b, 0x38(%rbx)
movq %r14, %rdi
callq 0x2130
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x5f8c
movq %r12, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/hobbitsyfeet[P]Turn/chart.cc
// Function: Chart::displayWorld()
void Chart::displayWorld(){
  vector<vector<container> >::iterator row;
  vector<container>::iterator col;
  for(row = world.begin(); row < world.end() ; row++){
    for(col = row->begin(); col < row->end(); col++){

      if(col->getGeoType()=='-' || col->getGeoType() =='O')
	cout<<"  ";
      else{
	        col->displayType();
	        cout<<' ';
      }
      //cout<<col->getOccupance();
      //	cout<<col->getLink();
    }
    cout<<endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
movq (%rdi), %rbx
movq 0x791e(%rip), %r14      # 0xdfd0
leaq 0x3062(%rip), %r15      # 0x971b
pushq $0x20
popq %r12
movq -0x30(%rbp), %rax
cmpq 0x8(%rax), %rbx
jae 0x6713
movq (%rbx), %r13
cmpq 0x8(%rbx), %r13
jae 0x6705
movzbl 0x9(%r13), %eax
cmpl $0x4f, %eax
je 0x66df
cmpl $0x2d, %eax
jne 0x66ec
movq %r14, %rdi
movq %r15, %rsi
callq 0x21c0
jmp 0x66ff
movq %r13, %rdi
callq 0x672c
movq %r14, %rdi
movl %r12d, %esi
callq 0x2200
addq $0x30, %r13
jmp 0x66ca
movq %r14, %rdi
callq 0x2110
addq $0x18, %rbx
jmp 0x66bd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq