LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AshOlogn[P]ash-language-interpreter/src/errors.cpp
// Function: LexerError::what() const
const char* LexerError::what() const throw() {
  
  std::string str  = "LexerError on line ";
  str.append(std::to_string(lineNumber));
  str.append(":\n\t");
  str.append(context);
  str.append("with token ");
  str.append(lexeme);
  str.append("\n");
  str.append(message);
  
  return copyString(str.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4430
movq -0x68(%rbp), %rdx
leaq 0x38d7f(%rip), %rsi     # 0x3f01e
leaq -0x28(%rbp), %rdi
callq 0x4350
jmp 0x62aa
leaq -0x29(%rbp), %rdi
callq 0x4290
movq -0x70(%rbp), %rax
movl 0x20(%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x6e40
jmp 0x62c5
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4470
jmp 0x62d4
leaq -0x60(%rbp), %rdi
callq 0x4170
leaq 0x38d4e(%rip), %rsi     # 0x3f032
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x62ef
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x6302
leaq 0x38d2d(%rip), %rsi     # 0x3f036
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x6314
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x6327
leaq 0x3e1f6(%rip), %rsi     # 0x44524
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x6339
movq -0x70(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x634c
leaq -0x28(%rbp), %rdi
callq 0x40e0
movq %rax, %rdi
callq 0x2fb10
movq %rax, -0x78(%rbp)
jmp 0x6363
leaq -0x28(%rbp), %rdi
callq 0x4170
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x4290
jmp 0x63bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x63b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4170
leaq -0x28(%rbp), %rdi
callq 0x4170
movq -0x38(%rbp), %rdi
callq 0x42e0
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/errors.cpp
// Function: StaticVariableScopeError::what() const
const char* StaticVariableScopeError::what() const throw() {

  std::string str = "StaticVariableScopeError on line ";
  str.append(std::to_string(lineNumber));
  str.append("\n");
  str.append(context);

  str.append("The variable ");
  str.append(variable);
  str.append(" ");

  if(isDeclaredError) {
    str.append("is already declared in this scope. It cannot be re-declared in the same scope.");
  } else {
    str.append("is not yet declared in this or enclosing scopes.\nIt has to be declared with a type before"
                " being accessed or assigned a value.");
  }

  return copyString(str.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4430
movq -0x68(%rbp), %rdx
leaq 0x3875b(%rip), %rsi     # 0x3f11a
leaq -0x28(%rbp), %rdi
callq 0x4350
jmp 0x69ca
leaq -0x29(%rbp), %rdi
callq 0x4290
movq -0x70(%rbp), %rax
movl 0x34(%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x6e40
jmp 0x69e5
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4470
jmp 0x69f4
leaq -0x60(%rbp), %rdi
callq 0x4170
leaq 0x3db20(%rip), %rsi     # 0x44524
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x6a0f
movq -0x70(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x6a22
leaq 0x38713(%rip), %rsi     # 0x3f13c
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x6a34
movq -0x70(%rbp), %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x4470
jmp 0x6a47
leaq 0x3991c(%rip), %rsi     # 0x4036a
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x6a59
movq -0x70(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x6ab3
leaq 0x386e0(%rip), %rsi     # 0x3f14a
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x6a75
jmp 0x6ac7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x4290
jmp 0x6afd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6af4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4170
jmp 0x6af4
leaq 0x386df(%rip), %rsi     # 0x3f199
leaq -0x28(%rbp), %rdi
callq 0x4460
jmp 0x6ac5
jmp 0x6ac7
leaq -0x28(%rbp), %rdi
callq 0x40e0
movq %rax, %rdi
callq 0x2fb10
movq %rax, -0x78(%rbp)
jmp 0x6ade
leaq -0x28(%rbp), %rdi
callq 0x4170
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x4170
movq -0x38(%rbp), %rdi
callq 0x42e0
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/token.cpp
// Function: makeToken(TokenType, unsigned int, char const*, Data)
Token makeToken(TokenType typ, uint32_t lin, const char* lex, Data val) {
  Token tokenPtr;
  tokenPtr.type = typ;
  tokenPtr.line = lin;
  tokenPtr.lexeme = copyString(lex);
  tokenPtr.value = val;
  return tokenPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %r8, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x10(%rdi)
movq -0x18(%rbp), %rdi
callq 0x2fb10
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rdi)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/token.cpp
// Function: makeToken(TokenType, unsigned int, char const*)
Token makeToken(TokenType typ, uint32_t lin, const char* lex) {
  Token tokenPtr;
  tokenPtr.type = typ;
  tokenPtr.line = lin;
  tokenPtr.lexeme = copyString(lex);
  return tokenPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, (%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x10(%rdi)
movq -0x10(%rbp), %rdi
callq 0x2fb10
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/token.cpp
// Function: varOrKeywordTokenType(char*)
TokenType varOrKeywordTokenType(char* lexeme) {

  //determine if keyword, if not then identifier
  std::size_t len = strlen(lexeme);

  for(uint8_t i = 0; i < NUM_RESERVED_WORDS; i++) {
    const char* keyword = RESERVED_WORDS[i];
    if(strncmp(lexeme, keyword, std::max(len, strlen(keyword))) == 0) {
      return RESERVED_WORD_TOKENS[i];
    }
  }

  return VARIABLE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4100
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x1f, %eax
jge 0x7d0b
movzbl -0x19(%rbp), %eax
movl %eax, %ecx
leaq 0x4c5cd(%rip), %rax     # 0x54270
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4100
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5f10
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq (%rax), %rdx
callq 0x4120
cmpl $0x0, %eax
jne 0x7cff
movzbl -0x19(%rbp), %eax
movl %eax, %ecx
leaq 0x378a9(%rip), %rax     # 0x3f5a0
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x7d12
jmp 0x7d01
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x7c8d
movl $0x3b, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/token.cpp
// Function: isSingleCharToken(char)
bool isSingleCharToken(char c) {  
  
  return c == '+' || c == '-' || c == '*' || c == '/' ||
         c == '%' || c == '&' || c == '|' || c == '^' ||
         c == '!' || c == '=' || c == '<' || c == '>' ||
         c == '?' || c == ':' || c == '.' || c == ',' || 
         c == ';' || c == '(' || c == ')' || c == '[' || 
         c == ']' || c == '{' || c == '}';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2b, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2f, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x25, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x26, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7c, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5e, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x21, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3d, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3c, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3e, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3f, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3a, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2e, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x2c, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x3b, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x28, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x29, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5b, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x5d, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x7b, %ecx
movb %al, -0x2(%rbp)
je 0x7e9f
movsbl -0x1(%rbp), %eax
cmpl $0x7d, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/token.cpp
// Function: isTypeTokenType(TokenType)
bool isTypeTokenType(TokenType tt) { 
  return tt == INT8 || tt == INT16 || tt == INT32 || 
         tt == INT64 || tt == UINT8 || tt == UINT16 || 
         tt == UINT32 || tt == UINT64 || tt == CHAR ||
         tt == DOUBLE || tt == BOOL || tt == STRING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x1, %al
cmpl $0x2e, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
movb $0x1, %al
cmpl $0x2f, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
movb $0x1, %al
cmpl $0x30, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
movb $0x1, %al
cmpl $0x31, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
movb $0x1, %al
cmpl $0x32, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
movb $0x1, %al
cmpl $0x33, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
movb $0x1, %al
cmpl $0x34, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
movb $0x1, %al
cmpl $0x35, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
movb $0x1, %al
cmpl $0x36, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
movb $0x1, %al
cmpl $0x37, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
movb $0x1, %al
cmpl $0x38, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x7f8a
cmpl $0x39, -0x4(%rbp)
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/token.cpp
// Function: isBinaryOperatorTokenType(TokenType)
bool isBinaryOperatorTokenType(TokenType tt) {
  return tt == ADD || tt == SUBTRACT ||

        tt == EXPONENT ||
        tt == MULTIPLY || tt == DIVIDE || tt == MOD ||
        tt == BIT_LEFT || tt == BIT_RIGHT ||

        tt == BIT_AND || tt == BIT_XOR || tt == BIT_OR ||  
        tt == AND || tt == XOR || tt == OR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x1, %al
cmpl $0x7, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0x8, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0xb, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0xc, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0xd, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0xe, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0xf, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0x10, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0x17, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0x18, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0x19, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0x1a, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
movb $0x1, %al
cmpl $0x1b, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x82d8
cmpl $0x1c, -0x4(%rbp)
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: AshOlogn[P]ash-language-interpreter/src/lexer.cpp
// Function: stringToInt(char*, unsigned int, unsigned int)
uint64_t stringToInt(char* str, uint32_t start, uint32_t end) {

  uint64_t ans = 0;
  for(uint32_t i = start; i <= end; i++) {
    ans = ans*10 + (str[i] - '0');
  }  

  return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
ja 0x852c
imulq $0xa, -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x1c(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
subl $0x30, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x84fc
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/lexer.cpp
// Function: stringToDouble(char*, unsigned int, unsigned int)
double stringToDouble(char* str, uint32_t start, uint32_t end) {

  double whole = 0;
  double decimal = 0;
  double exp = 0.1;
  bool isDecimalMode = false;

  for(uint32_t i = start; i <= end; i++) {

    if(str[i] == '.') {
      isDecimalMode = true;
    } else if(isDecimalMode) {
      decimal += exp*(str[i]-'0');
      exp *= 0.1;      
    } else {
      whole = whole*10 + (str[i]-'0');      
    }
  }

  return whole + decimal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x37352(%rip), %xmm0    # 0x3f8b8
movsd %xmm0, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x10(%rbp), %eax
ja 0x8618
movq -0x8(%rbp), %rax
movl -0x30(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x8597
movb $0x1, -0x29(%rbp)
jmp 0x8608
testb $0x1, -0x29(%rbp)
je 0x85da
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movl -0x30(%rbp), %ecx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x372ea(%rip), %xmm0    # 0x3f8b8
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x8606
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movl -0x30(%rbp), %ecx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm1
movsd 0x372c7(%rip), %xmm2    # 0x3f8c0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x8608
jmp 0x860a
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x8575
movsd -0x18(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsetoken.cpp
// Function: copyParseData(ParseData)
ParseData copyParseData(ParseData d) {

	ParseDataType type = d.type;
	ParseData d2;
	d2.type = type;

	//string deep copy
	if(type == STRING_T) {

		d2.value.allocated = (void*) copyString((char*) d.value.allocated);

	} else if(type == ARRAY_T) {

		//array deep copy
		Array* arr = (Array*) d.value.allocated;
		uint32_t length = arr->length;
		ParseData* values = arr->values;

		Array* arr2 = (Array*) malloc(sizeof(Array));
		arr2->length = length;
		arr2->subtype = arr->subtype;

		ParseData* values2 = (ParseData*) malloc(sizeof(ParseData)*std::max((int32_t)length, 1));
		for(uint32_t i = 0; i < length; i++) {
			values2[i] = copyParseData(values[i]);
		}
		arr2->values = values2;
		d2.value.allocated = (void*) arr2;

	} else if(type == DOUBLE_T) {
		d2.value.floatingPoint = d.value.floatingPoint;
	} else {
		d2.value.integer = d.value.integer;
	}

	return d2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0xb, -0x24(%rbp)
jne 0xb096
movq -0x18(%rbp), %rdi
callq 0x2fb10
movq %rax, -0x8(%rbp)
jmp 0xb1a7
cmpl $0xc, -0x24(%rbp)
jne 0xb189
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x10, %edi
callq 0x4310
movq %rax, -0x48(%rbp)
movl -0x34(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movq -0x48(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
movl $0x1, -0x58(%rbp)
leaq -0x54(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xc5c0
movslq (%rax), %rdi
shlq $0x4, %rdi
callq 0x4310
movq %rax, -0x50(%rbp)
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0xb173
movq -0x40(%rbp), %rax
movl -0x5c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movl -0x80(%rbp), %edi
movq -0x78(%rbp), %rsi
callq 0xb060
movl %eax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x50(%rbp), %rax
movl -0x5c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0xb113
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb1a5
cmpl $0xa, -0x24(%rbp)
jne 0xb19b
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xb1a3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb1a5
jmp 0xb1a7
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsetoken.cpp
// Function: typeTokenConversion(TokenType)
ParseDataType typeTokenConversion(TokenType tt) {
  switch(tt) {
    case INT8: return INT8_T;
    case INT16: return INT16_T;
    case INT32: return INT32_T;
    case INT64: return INT64_T;
    case UINT8: return UINT8_T;
    case UINT16: return UINT16_T;
    case UINT32: return UINT32_T;
    case UINT64: return UINT64_T;
    case CHAR: return CHAR_T;
    case BOOL: return BOOL_T;
    case DOUBLE: return DOUBLE_T;
    case STRING: return STRING_T;
		case VOID: return VOID_T;
    default: return INVALID_T;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x2e, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xc, %eax
ja 0xb685
movq -0x10(%rbp), %rax
leaq 0x34749(%rip), %rcx     # 0x3fd50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0xb68c
movl $0x1, -0x4(%rbp)
jmp 0xb68c
movl $0x2, -0x4(%rbp)
jmp 0xb68c
movl $0x3, -0x4(%rbp)
jmp 0xb68c
movl $0x4, -0x4(%rbp)
jmp 0xb68c
movl $0x5, -0x4(%rbp)
jmp 0xb68c
movl $0x6, -0x4(%rbp)
jmp 0xb68c
movl $0x7, -0x4(%rbp)
jmp 0xb68c
movl $0x8, -0x4(%rbp)
jmp 0xb68c
movl $0x9, -0x4(%rbp)
jmp 0xb68c
movl $0xa, -0x4(%rbp)
jmp 0xb68c
movl $0xb, -0x4(%rbp)
jmp 0xb68c
movl $0xf, -0x4(%rbp)
jmp 0xb68c
movl $0x11, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsetoken.cpp
// Function: unaryTokenConversion(TokenType)
ParseOperatorType unaryTokenConversion(TokenType tt) {
  switch(tt) {
    case ADD: return POSITIVE_OP;
    case SUBTRACT: return NEGATIVE_OP;
    case NOT: return NOT_OP;
    case BIT_NOT: return BIT_NOT_OP;
    default: return INVALID_OP;    
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0xb6f0
movq -0x10(%rbp), %rax
leaq 0x346c1(%rip), %rcx     # 0x3fd84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x7, -0x4(%rbp)
jmp 0xb6f7
movl $0x8, -0x4(%rbp)
jmp 0xb6f7
movl $0x9, -0x4(%rbp)
jmp 0xb6f7
movl $0xa, -0x4(%rbp)
jmp 0xb6f7
movl $0x2b, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsetoken.cpp
// Function: binaryTokenConversion(TokenType)
ParseOperatorType binaryTokenConversion(TokenType tt) {

  switch(tt) {

    case EXPONENT: return EXPONENT_OP; 
    case MULTIPLY: return MULTIPLY_OP;
    case DIVIDE: return DIVIDE_OP; 
    case MOD: return MOD_OP;
    case ADD: return ADD_OP;
    case SUBTRACT: return SUBTRACT_OP;
 
    case BIT_LEFT: return BIT_LEFT_OP;
    case BIT_RIGHT: return BIT_RIGHT_OP;
    
    case GREATER: return GREATER_OP; 
    case LESS: return LESS_OP; 
    case GREATER_EQ: return GREATER_EQ_OP; 
    case LESS_EQ: return LESS_EQ_OP;
    case EQ_EQ: return EQ_EQ_OP; 
    case NOT_EQ: return NOT_EQ_OP;

    case BIT_AND: return BIT_AND_OP;
    case BIT_XOR: return BIT_XOR_OP;
    case BIT_OR: return BIT_OR_OP;  

    case AND: return AND_OP;
    case XOR: return XOR_OP;
    case OR: return OR_OP;

    case EQ: return EQ_OP; 
    case ADD_EQ: return ADD_EQ_OP;
    case SUBTRACT_EQ: return SUBTRACT_EQ_OP;
    case EXPONENT_EQ: return EXPONENT_EQ_OP;
    case MULTIPLY_EQ: return MULTIPLY_EQ_OP;
    case DIVIDE_EQ: return DIVIDE_EQ_OP;
    case MOD_EQ: return MOD_EQ_OP; 
    case AND_EQ: return AND_EQ_OP;
    case XOR_EQ: return XOR_EQ_OP;
    case OR_EQ: return OR_EQ_OP;
    case BIT_LEFT_EQ: return BIT_LEFT_EQ_OP;
    case BIT_RIGHT_EQ: return BIT_RIGHT_EQ_OP;

    default: return INVALID_OP;
  }  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x23, %eax
ja 0xb886
movq -0x10(%rbp), %rax
leaq 0x3466d(%rip), %rcx     # 0x3fd94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xb, -0x4(%rbp)
jmp 0xb88d
movl $0xc, -0x4(%rbp)
jmp 0xb88d
movl $0xd, -0x4(%rbp)
jmp 0xb88d
movl $0xe, -0x4(%rbp)
jmp 0xb88d
movl $0xf, -0x4(%rbp)
jmp 0xb88d
movl $0x10, -0x4(%rbp)
jmp 0xb88d
movl $0x11, -0x4(%rbp)
jmp 0xb88d
movl $0x12, -0x4(%rbp)
jmp 0xb88d
movl $0x13, -0x4(%rbp)
jmp 0xb88d
movl $0x14, -0x4(%rbp)
jmp 0xb88d
movl $0x15, -0x4(%rbp)
jmp 0xb88d
movl $0x16, -0x4(%rbp)
jmp 0xb88d
movl $0x17, -0x4(%rbp)
jmp 0xb88d
movl $0x18, -0x4(%rbp)
jmp 0xb88d
movl $0x19, -0x4(%rbp)
jmp 0xb88d
movl $0x1a, -0x4(%rbp)
jmp 0xb88d
movl $0x1b, -0x4(%rbp)
jmp 0xb88d
movl $0x1c, -0x4(%rbp)
jmp 0xb88d
movl $0x1d, -0x4(%rbp)
jmp 0xb88d
movl $0x1e, -0x4(%rbp)
jmp 0xb88d
movl $0x1f, -0x4(%rbp)
jmp 0xb88d
movl $0x20, -0x4(%rbp)
jmp 0xb88d
movl $0x21, -0x4(%rbp)
jmp 0xb88d
movl $0x22, -0x4(%rbp)
jmp 0xb88d
movl $0x23, -0x4(%rbp)
jmp 0xb88d
movl $0x24, -0x4(%rbp)
jmp 0xb88d
movl $0x25, -0x4(%rbp)
jmp 0xb88d
movl $0x26, -0x4(%rbp)
jmp 0xb88d
movl $0x27, -0x4(%rbp)
jmp 0xb88d
movl $0x28, -0x4(%rbp)
jmp 0xb88d
movl $0x29, -0x4(%rbp)
jmp 0xb88d
movl $0x2a, -0x4(%rbp)
jmp 0xb88d
movl $0x2b, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsetoken.cpp
// Function: toStringParseDataType(ParseDataType)
const char* toStringParseDataType(ParseDataType p) {
 
  switch(p) {
    case INT32_T: return "int32";
		case INT64_T: return "int64";
		case UINT32_T: return "uint32";
    case UINT64_T: return "uint64";
    case CHAR_T: return "char";
    case BOOL_T: return "bool"; 
    case DOUBLE_T: return "double"; 
    case STRING_T: return "string";
		case ARRAY_T: return "array";
		case VOID_T: return "void";
		case FUN_T: return "fun";
    default: return "invalid";
  } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xd, %eax
ja 0xb965
movq -0x18(%rbp), %rax
leaq 0x3455d(%rip), %rcx     # 0x3fe24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x33fa7(%rip), %rax     # 0x3f87e
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x33f9e(%rip), %rax     # 0x3f885
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x33f86(%rip), %rax     # 0x3f87d
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x33f80(%rip), %rax     # 0x3f884
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x33f7f(%rip), %rax     # 0x3f890
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x33f7e(%rip), %rax     # 0x3f89c
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x33f6a(%rip), %rax     # 0x3f895
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x33af6(%rip), %rax     # 0x3f42e
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x33ae3(%rip), %rax     # 0x3f428
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x33f4f(%rip), %rax     # 0x3f8a1
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x33ef4(%rip), %rax     # 0x3f853
movq %rax, -0x8(%rbp)
jmp 0xb970
leaq 0x346b4(%rip), %rax     # 0x40020
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: AssignmentExpressionNode::AssignmentExpressionNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseDataType, AbstractExpressionNode*, SymbolTable*, unsigned int)
AssignmentExpressionNode::AssignmentExpressionNode(std::string var, ParseDataType varType, AbstractExpressionNode* val, SymbolTable* table, uint32_t varLine) {

  variable = var;
  variableType = varType;
  value = val;
  symbolTable = table;
  
  evalType = varType;
	subType = (varType == STRING_T) ? CHAR_T :
						(varType == ARRAY_T) ? val->subType :
						INVALID_T;
	
  startLine = varLine;
  endLine = val->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xe5a0
movq -0x58(%rbp), %rdi
leaq 0x469c5(%rip), %rax     # 0x537d0
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x50(%rbp)
callq 0x4360
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x4040
jmp 0xce2a
movq -0x58(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x48(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0xb, -0x14(%rbp)
jne 0xce5a
movl $0x8, %eax
movl %eax, -0x5c(%rbp)
jmp 0xce7c
cmpl $0xc, -0x14(%rbp)
jne 0xce6c
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x60(%rbp)
jmp 0xce76
movl $0x11, %eax
movl %eax, -0x60(%rbp)
jmp 0xce76
movl -0x60(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4170
movq -0x38(%rbp), %rdi
callq 0x4420
nopw (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayAssignmentExpressionNode::ArrayAssignmentExpressionNode(AbstractExpressionNode*, AbstractExpressionNode*, AbstractExpressionNode*, char*, SymbolTable*)
ArrayAssignmentExpressionNode::ArrayAssignmentExpressionNode(AbstractExpressionNode* arr, AbstractExpressionNode* ind, AbstractExpressionNode* val, char* context, SymbolTable* symbolTable) {
	array = arr;
	index = ind;
	value = val;
  this->context = context;
	this->symbolTable = symbolTable;
	startLine = arr->startLine;
	endLine = value->endLine;
	evalType = arr->subType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xe5a0
movq -0x38(%rbp), %rax
leaq 0x468a8(%rip), %rcx     # 0x537e0
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x28(%rax), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: UnaryOperatorNode::UnaryOperatorNode(ParseOperatorType, AbstractExpressionNode*, unsigned int)
UnaryOperatorNode::UnaryOperatorNode(ParseOperatorType op, AbstractExpressionNode* l, uint32_t operatorLine) {
  operation = op;
  leftArg = l;
  evalType = getTypeUnaryExpression(op, l->evalType); 
  startLine = std::min(operatorLine, l->startLine);
  endLine = std::max(operatorLine, l->endLine);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xe5c0
movq -0x28(%rbp), %rax
leaq 0x46802(%rip), %rcx     # 0x53800
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x2b9c0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq -0x1c(%rbp), %rdi
callq 0xe600
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
leaq -0x1c(%rbp), %rdi
callq 0xe640
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: UnaryOperatorNode::UnaryOperatorNode(ParseOperatorType, AbstractExpressionNode*, SymbolTable*, unsigned int)
UnaryOperatorNode::UnaryOperatorNode(ParseOperatorType op, AbstractExpressionNode* l, SymbolTable* table, uint32_t operatorLine) {
  operation = op;
  leftArg = l;
  symbolTable = table;
  evalType = getTypeUnaryExpression(op, l->evalType);
	subType = (evalType == STRING_T) ? CHAR_T : INVALID_T; 
  startLine = std::min(operatorLine, l->startLine);
  endLine = std::max(operatorLine, l->endLine);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xe5c0
movq -0x30(%rbp), %rax
leaq 0x4675d(%rip), %rcx     # 0x53800
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x2b9c0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %esi
movl $0x11, %ecx
movl $0x8, %edx
cmpl $0xb, %esi
cmovel %edx, %ecx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq -0x24(%rbp), %rdi
callq 0xe600
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
leaq -0x24(%rbp), %rdi
callq 0xe640
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: UnaryOperatorNode::toString[abi:cxx11]()
std::string UnaryOperatorNode::toString() {
  std::string str = "(";
  str.append(toStringParseOperatorType(operation));
  str.append(" ");
  str.append(leftArg->toString());
  str.append(")");
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4430
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x329f1(%rip), %rsi     # 0x3fb94
callq 0x4350
jmp 0xd1aa
leaq -0x12(%rbp), %rdi
callq 0x4290
movq -0x60(%rbp), %rax
movl 0x18(%rax), %edi
callq 0xb980
movq %rax, -0x70(%rbp)
jmp 0xd1c5
movq -0x70(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x4460
jmp 0xd1d4
movq -0x58(%rbp), %rdi
leaq 0x3318b(%rip), %rsi     # 0x4036a
callq 0x4460
jmp 0xd1e6
movq -0x60(%rbp), %rax
movq 0x20(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0xd1fd
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4470
jmp 0xd20c
leaq -0x48(%rbp), %rdi
callq 0x4170
movq -0x58(%rbp), %rdi
leaq 0x32b24(%rip), %rsi     # 0x3fd44
callq 0x4460
jmp 0xd227
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xd278
jmp 0xd26f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4290
jmp 0xd28b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xd282
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4170
jmp 0xd282
movq -0x58(%rbp), %rdi
callq 0x4170
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4170
movq -0x20(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: AbstractBinaryOperatorNode::toString[abi:cxx11]()
std::string AbstractBinaryOperatorNode::toString() {
  std::string str = "( ";
  str.append(toStringParseOperatorType(operation));
  str.append(" ");
  str.append(leftArg->toString());
  str.append(" "); 
  str.append(rightArg->toString());
  str.append(")");
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4430
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x33080(%rip), %rsi     # 0x40369
callq 0x4350
jmp 0xd2f0
leaq -0x12(%rbp), %rdi
callq 0x4290
movq -0x80(%rbp), %rax
movl 0x18(%rax), %edi
callq 0xb980
movq %rax, -0x90(%rbp)
jmp 0xd30e
movq -0x90(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x4460
jmp 0xd320
movq -0x78(%rbp), %rdi
leaq 0x3303f(%rip), %rsi     # 0x4036a
callq 0x4460
jmp 0xd332
movq -0x80(%rbp), %rax
movq 0x20(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0xd349
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4470
jmp 0xd358
leaq -0x48(%rbp), %rdi
callq 0x4170
movq -0x78(%rbp), %rdi
leaq 0x32ffe(%rip), %rsi     # 0x4036a
callq 0x4460
jmp 0xd373
movq -0x80(%rbp), %rax
movq 0x28(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x68(%rbp), %rdi
callq *%rax
jmp 0xd38a
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4470
jmp 0xd399
leaq -0x68(%rbp), %rdi
callq 0x4170
movq -0x78(%rbp), %rdi
leaq 0x32997(%rip), %rsi     # 0x3fd44
callq 0x4460
jmp 0xd3b4
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xd41c
jmp 0xd413
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4290
jmp 0xd435
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xd42c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4170
jmp 0xd42c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4170
jmp 0xd42c
movq -0x78(%rbp), %rdi
callq 0x4170
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x4170
movq -0x20(%rbp), %rdi
callq 0x4420
nop
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArithmeticOperatorNode::ArithmeticOperatorNode(ParseOperatorType, AbstractExpressionNode*, AbstractExpressionNode*)
ArithmeticOperatorNode::ArithmeticOperatorNode(ParseOperatorType op, AbstractExpressionNode* l, AbstractExpressionNode* r) {
  operation = op;
  leftArg = l;
  rightArg = r;
  startLine = l->startLine;
  endLine = r->endLine;
  evalType = getTypeArithmeticExpression(op, l->evalType, r->evalType);
	subType = (evalType == STRING_T) ? CHAR_T : INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xe680
movq -0x28(%rbp), %rax
leaq 0x463b1(%rip), %rcx     # 0x53820
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2ba60
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %esi
movl $0x11, %ecx
movl $0x8, %edx
cmpl $0xb, %esi
cmovel %edx, %ecx
movl %ecx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: BitLogicalOperatorNode::BitLogicalOperatorNode(ParseOperatorType, AbstractExpressionNode*, AbstractExpressionNode*)
BitLogicalOperatorNode::BitLogicalOperatorNode(ParseOperatorType op, AbstractExpressionNode* l, AbstractExpressionNode* r) {
  operation = op;
  leftArg = l;
  rightArg = r;
  startLine = l->startLine;
  endLine = r->endLine;
  evalType = getTypeBitLogicalExpression(op, l->evalType, r->evalType);
	subType = (evalType == STRING_T) ? CHAR_T : INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xe680
movq -0x28(%rbp), %rax
leaq 0x46301(%rip), %rcx     # 0x53840
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2bba0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %esi
movl $0x11, %ecx
movl $0x8, %edx
cmpl $0xb, %esi
cmovel %edx, %ecx
movl %ecx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ComparisonOperatorNode::ComparisonOperatorNode(ParseOperatorType, AbstractExpressionNode*, AbstractExpressionNode*)
ComparisonOperatorNode::ComparisonOperatorNode(ParseOperatorType op, AbstractExpressionNode* l, AbstractExpressionNode* r) { 
  operation = op;
  leftArg = l;
  rightArg = r;
  startLine = l->startLine;
  endLine = r->endLine;
  evalType = getTypeComparisonExpression(op, l->evalType, r->evalType);
	subType = (evalType == STRING_T) ? CHAR_T : INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xe680
movq -0x28(%rbp), %rax
leaq 0x46251(%rip), %rcx     # 0x53860
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2bc20
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %esi
movl $0x11, %ecx
movl $0x8, %edx
cmpl $0xb, %esi
cmovel %edx, %ecx
movl %ecx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: CastNode::CastNode(AbstractExpressionNode*, ParseDataType, unsigned int)
CastNode::CastNode(AbstractExpressionNode* e, ParseDataType type, uint32_t startLin) {
  expression = e;
  evalType = finalType = type;
	subType = (evalType == STRING_T) ? CHAR_T : INVALID_T;

  startLine = startLin;
  endLine = e->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xe5a0
movq -0x20(%rbp), %rax
leaq 0x461a2(%rip), %rcx     # 0x53880
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %esi
movl $0x11, %ecx
movl $0x8, %edx
cmpl $0xb, %esi
cmovel %edx, %ecx
movl %ecx, 0x14(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: CastNode::toString[abi:cxx11]()
std::string CastNode::toString() {
  std::string str = "(";
  str.append(toStringParseDataType(finalType));
  str.append(" ");
  str.append(expression->toString());
  str.append(")");
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4430
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x32421(%rip), %rsi     # 0x3fb94
callq 0x4350
jmp 0xd77a
leaq -0x12(%rbp), %rdi
callq 0x4290
movq -0x60(%rbp), %rax
movl 0x20(%rax), %edi
callq 0xb8a0
movq %rax, -0x70(%rbp)
jmp 0xd795
movq -0x70(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x4460
jmp 0xd7a4
movq -0x58(%rbp), %rdi
leaq 0x32bbb(%rip), %rsi     # 0x4036a
callq 0x4460
jmp 0xd7b6
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rsi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0xd7cd
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4470
jmp 0xd7dc
leaq -0x48(%rbp), %rdi
callq 0x4170
movq -0x58(%rbp), %rdi
leaq 0x32554(%rip), %rsi     # 0x3fd44
callq 0x4460
jmp 0xd7f7
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xd848
jmp 0xd83f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4290
jmp 0xd85b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xd852
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4170
jmp 0xd852
movq -0x58(%rbp), %rdi
callq 0x4170
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4170
movq -0x20(%rbp), %rdi
callq 0x4420
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayAccessNode::ArrayAccessNode(AbstractExpressionNode*, AbstractExpressionNode*, char*, unsigned int)
ArrayAccessNode::ArrayAccessNode(AbstractExpressionNode* arr, AbstractExpressionNode* s, char* context, uint32_t endLin) {
	array = arr; start = s; endLine = endLin; isSlice = false;
	startLine = arr->startLine;
	endLine = endLin;
	this->context = context;
	evalType = arr->subType;
	subType = (evalType == STRING_T) ? CHAR_T : INVALID_T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xe5a0
movq -0x30(%rbp), %rax
leaq 0x45fcc(%rip), %rcx     # 0x538a0
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x0, 0x38(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %esi
movl $0x11, %ecx
movl $0x8, %edx
cmpl $0xb, %esi
cmovel %edx, %ecx
movl %ecx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: ArrayAccessNode::ArrayAccessNode(AbstractExpressionNode*, AbstractExpressionNode*, AbstractExpressionNode*, char*, unsigned int)
ArrayAccessNode::ArrayAccessNode(AbstractExpressionNode* arr, AbstractExpressionNode* s, AbstractExpressionNode* e, char* context, uint32_t endLin) {
  array = arr; start = s; end = e; endLine = endLin; isSlice = true;
  startLine = arr->startLine;
  endLine = endLin;
	this->context = context;
	evalType = arr->evalType;
	subType = arr->subType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xe5a0
movq -0x38(%rbp), %rax
leaq 0x45f28(%rip), %rcx     # 0x538a0
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x38(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)