LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/parsenode.cpp
// Function: GroupedExpressionNode::toString[abi:cxx11]()
std::string GroupedExpressionNode::toString() {
  std::string str = "(";
  str.append(closedExpression->toString());
  str.append(")");
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x15233(%rip), %rsi     # 0x1e9b0
leaq 0x1522d(%rip), %rdx     # 0x1e9b1
callq 0x5ce4
movq 0x18(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *0x8(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x40a0
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x97b9
callq 0x41e0
leaq 0x153a0(%rip), %rsi     # 0x1eb60
movq %rbx, %rdi
callq 0x43a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x97ef
movq %rax, %r14
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x97f2
callq 0x41e0
jmp 0x97f2
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x97ff
callq 0x41e0
movq %r14, %rdi
callq 0x4380
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, unsigned char>(char*, unsigned char, ParseDataType)
ParseData additionHelper<char*, unsigned char>(char* n1, unsigned char n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  unsigned char arg2 = (unsigned char) n2;
  uint32_t len = strlen(arg1);
  
  char* res = new char[len+2];
  res[0] = '\0';
  strncat(res, arg1, len);
  res[len] = arg2; res[len+1] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;

  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, -0x2c(%rbp)
movl %esi, %r14d
movq %rdi, %r15
callq 0x40e0
movq %rax, %r12
leal 0x2(%rax), %edi
callq 0x4030
movq %rax, %r13
xorl %eax, %eax
movb %al, (%r13)
movl %r12d, %ebx
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4160
movb %r14b, (%r13,%rbx)
incl %r12d
xorl %eax, %eax
movb %al, (%r13,%r12)
movl -0x2c(%rbp), %eax
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<bool, char*>(bool, char*, ParseDataType)
ParseData additionHelper<bool, char*>(bool n1, char* n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  const char* arg1Str = (arg1) ? "true" : "false";
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r14
movl %edi, %r15d
leaq 0x14cde(%rip), %rax     # 0x1e71a
leaq 0x14cdc(%rip), %r12     # 0x1e71f
testl %edi, %edi
cmovneq %rax, %r12
xorl $0x5, %r15d
movq %rsi, %rdi
callq 0x40e0
movq %rax, %r13
addl %r15d, %eax
movq %rax, -0x38(%rbp)
leal (%r15,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, bool>(char*, bool, ParseDataType)
ParseData additionHelper<char*, bool>(char* n1, bool n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  bool arg2 = (bool) n2;
  const char* arg2Str = (arg2) ? "true" : "false";
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movl %esi, %r14d
movq %rdi, %r12
leaq 0x14c4e(%rip), %rax     # 0x1e71a
leaq 0x14c4c(%rip), %r15     # 0x1e71f
testl %esi, %esi
cmovneq %rax, %r15
callq 0x40e0
movq %rax, %r13
xorl $0x5, %r14d
addl %r14d, %eax
movq %rax, -0x38(%rbp)
leal (%r14,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r13d, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4160
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, int>(char*, int, ParseDataType)
ParseData additionHelper<char*, int32_t>(char* n1, int32_t n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  int32_t arg2 = (int32_t) n2;
  const char* arg2Str = std::to_string(arg2).c_str();
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movl %esi, %r12d
movq %rdi, -0x40(%rbp)
movl %esi, %r15d
negl %r15d
cmovsl %esi, %r15d
movl $0x1, %r13d
cmpl $0xa, %r15d
jb 0x9bb3
movl $0x4, %r13d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r15d, %ecx
cmpl $0x63, %ecx
jbe 0x9baa
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x9bb0
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x9bb3
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r13d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x9b77
addl $-0x3, %r13d
jmp 0x9bb3
addl $-0x2, %r13d
jmp 0x9bb3
decl %r13d
shrl $0x1f, %r12d
leal (%r12,%r13), %esi
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x4250
addq (%rbx), %r12
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x5c72
movq (%rbx), %r15
cmpq %r14, %r15
je 0x9bf5
movq %r15, %rdi
callq 0x41e0
movq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x40e0
movq %rax, %rbx
movq %r15, %rdi
callq 0x40e0
movq %rax, %r12
addl %ebx, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%rbx), %edi
incl %edi
callq 0x4030
movq %rax, %r13
xorl %eax, %eax
movb %al, (%r13)
movl %ebx, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x4160
movl %r12d, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%r13,%rax)
movl -0x2c(%rbp), %eax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, long>(char*, long, ParseDataType)
ParseData additionHelper<char*, int64_t>(char* n1, int64_t n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  int64_t arg2 = (int64_t) n2;
  const char* arg2Str = std::to_string(arg2).c_str();
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r12
movq %rdi, -0x40(%rbp)
movq %rsi, %r15
negq %r15
cmovsq %rsi, %r15
movl $0x1, %r13d
cmpq $0xa, %r15
jb 0x9ce9
movl $0x4, %r13d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x9ce0
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x9ce6
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x9ce9
movq %rcx, %rax
mulq %rsi
shrq $0xb, %rdx
addl $0x4, %r13d
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x9ca8
addl $-0x3, %r13d
jmp 0x9ce9
addl $-0x2, %r13d
jmp 0x9ce9
decl %r13d
shrq $0x3f, %r12
leal (%r12,%r13), %esi
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x4250
addq (%rbx), %r12
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x8991
movq (%rbx), %r15
cmpq %r14, %r15
je 0x9d2b
movq %r15, %rdi
callq 0x41e0
movq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x40e0
movq %rax, %rbx
movq %r15, %rdi
callq 0x40e0
movq %rax, %r12
addl %ebx, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%rbx), %edi
incl %edi
callq 0x4030
movq %rax, %r13
xorl %eax, %eax
movb %al, (%r13)
movl %ebx, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x4160
movl %r12d, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%r13,%rax)
movl -0x2c(%rbp), %eax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, unsigned int>(char*, unsigned int, ParseDataType)
ParseData additionHelper<char*, uint32_t>(char* n1, uint32_t n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  uint32_t arg2 = (uint32_t) n2;
  const char* arg2Str = std::to_string(arg2).c_str();
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movl %esi, %r15d
movq %rdi, %r14
movl $0x1, %eax
cmpl $0xa, %esi
jb 0x9e03
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r15d, %edx
cmpl $0x63, %edx
jbe 0x9dfc
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x9e01
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x9e03
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x9dcb
addl $-0x3, %eax
jmp 0x9e03
addl $-0x2, %eax
jmp 0x9e03
decl %eax
movl %eax, %esi
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x4250
movq (%r12), %rdi
movl 0x8(%r12), %esi
movl %r15d, %edx
callq 0x5c72
movq (%r12), %r15
cmpq %rbx, %r15
je 0x9e3d
movq %r15, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x40e0
movq %rax, %r12
movq %r15, %rdi
callq 0x40e0
movq %rax, %r13
addl %r12d, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r12d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, unsigned long>(char*, unsigned long, ParseDataType)
ParseData additionHelper<char*, uint64_t>(char* n1, uint64_t n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  uint64_t arg2 = (uint64_t) n2;
  const char* arg2Str = std::to_string(arg2).c_str();
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x9f1a
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x9f13
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x9f18
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x9f1a
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x9edd
addl $-0x3, %esi
jmp 0x9f1a
addl $-0x2, %esi
jmp 0x9f1a
decl %esi
movl %esi, %esi
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x4250
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x8991
movq (%r12), %r15
cmpq %rbx, %r15
je 0x9f54
movq %r15, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x40e0
movq %rax, %r12
movq %r15, %rdi
callq 0x40e0
movq %rax, %r13
addl %r12d, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r12d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, double>(char*, double, ParseDataType)
ParseData additionHelper<char*, double>(char* n1, double n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  double arg2 = (double) n2;
  const char* arg2Str = std::to_string(arg2).c_str();
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2Str);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2Str, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, -0x2c(%rbp)
movq %rdi, %r14
movq 0x21fdd(%rip), %rsi     # 0x2bfb8
leaq 0x15091(%rip), %rcx     # 0x1f073
leaq -0x58(%rbp), %r15
movl $0x148, %edx            # imm = 0x148
movq %r15, %rdi
movb $0x1, %al
callq 0x8a11
movq (%r15), %r15
leaq -0x48(%rbp), %rax
cmpq %rax, %r15
je 0xa009
movq %r15, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x40e0
movq %rax, %r12
movq %r15, %rdi
callq 0x40e0
movq %rax, %r13
addl %r12d, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r12d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<char*, char*>(char*, char*, ParseDataType)
ParseData additionHelper<char*, char*>(char* n1, char* n2, ParseDataType type) {

  char* arg1 = (char*) n1;
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r14
movq %rdi, %r15
callq 0x40e0
movq %rax, %r12
movq %r14, %rdi
callq 0x40e0
movq %rax, %r13
addl %r12d, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r12d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<unsigned char, char*>(unsigned char, char*, ParseDataType)
ParseData additionHelper<unsigned char, char*>(unsigned char n1, char* n2, ParseDataType type) {

  unsigned char arg1 = (unsigned char) n1;
  char* arg2 = (char*) n2;
  uint32_t len = strlen(arg2);
  
  char* res = new char[len+2];
  res[0] = arg1; res[1] = '\0';
  strncat(res, arg2, len);
  res[len+1] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
movq %rsi, %rdi
callq 0x40e0
movq %rax, %r12
leal 0x2(%rax), %edi
callq 0x4030
movq %rax, %r13
movb %r15b, (%rax)
xorl %r15d, %r15d
movb %r15b, 0x1(%rax)
movl %r12d, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x4160
incl %r12d
movb %r15b, (%r13,%r12)
movl %ebx, %eax
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<int, char*>(int, char*, ParseDataType)
ParseData additionHelper<int32_t, char*>(int32_t n1, char* n2, ParseDataType type) {

  int32_t arg1 = (int32_t) n1;
  const char* arg1Str = std::to_string(arg1).c_str();
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, -0x40(%rbp)
movl %edi, %r12d
movl %edi, %r15d
negl %r15d
cmovsl %edi, %r15d
movl $0x1, %r13d
cmpl $0xa, %r15d
jb 0xa1cd
movl $0x4, %r13d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r15d, %ecx
cmpl $0x63, %ecx
jbe 0xa1c4
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0xa1ca
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0xa1cd
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r13d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0xa191
addl $-0x3, %r13d
jmp 0xa1cd
addl $-0x2, %r13d
jmp 0xa1cd
decl %r13d
shrl $0x1f, %r12d
leal (%r12,%r13), %esi
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x4250
addq (%rbx), %r12
movq %r12, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x5c72
movq (%rbx), %r15
cmpq %r14, %r15
je 0xa20f
movq %r15, %rdi
callq 0x41e0
movq %r15, %rdi
callq 0x40e0
movq %rax, %rbx
movq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x40e0
movq %rax, %r12
addl %ebx, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%rbx), %edi
incl %edi
callq 0x4030
movq %rax, %r13
xorl %eax, %eax
movb %al, (%r13)
movl %ebx, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x4160
movl %r12d, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%r13,%rax)
movl -0x2c(%rbp), %eax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<long, char*>(long, char*, ParseDataType)
ParseData additionHelper<int64_t, char*>(int64_t n1, char* n2, ParseDataType type) {

  int64_t arg1 = (int64_t) n1;
  const char* arg1Str = std::to_string(arg1).c_str();
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, %r12
movq %rdi, %r15
negq %r15
cmovsq %rdi, %r15
movl $0x1, %r13d
cmpq $0xa, %r15
jb 0xa303
movl $0x4, %r13d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0xa2fa
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0xa300
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0xa303
movq %rcx, %rax
mulq %rsi
shrq $0xb, %rdx
addl $0x4, %r13d
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0xa2c2
addl $-0x3, %r13d
jmp 0xa303
addl $-0x2, %r13d
jmp 0xa303
decl %r13d
shrq $0x3f, %r12
leal (%r12,%r13), %esi
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movl $0x2d, %edx
callq 0x4250
addq (%rbx), %r12
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x8991
movq (%rbx), %r15
cmpq %r14, %r15
je 0xa345
movq %r15, %rdi
callq 0x41e0
movq %r15, %rdi
callq 0x40e0
movq %rax, %rbx
movq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x40e0
movq %rax, %r12
addl %ebx, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%rbx), %edi
incl %edi
callq 0x4030
movq %rax, %r13
xorl %eax, %eax
movb %al, (%r13)
movl %ebx, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x4160
movl %r12d, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%r13,%rax)
movl -0x2c(%rbp), %eax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<unsigned int, char*>(unsigned int, char*, ParseDataType)
ParseData additionHelper<uint32_t, char*>(uint32_t n1, char* n2, ParseDataType type) {

  uint32_t arg1 = (uint32_t) n1;
  const char* arg1Str = std::to_string(arg1).c_str();
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r14
movl %edi, %r15d
movl $0x1, %eax
cmpl $0xa, %edi
jb 0xa41d
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r15d, %edx
cmpl $0x63, %edx
jbe 0xa416
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0xa41b
cmpl $0x2710, %edx           # imm = 0x2710
jb 0xa41d
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0xa3e5
addl $-0x3, %eax
jmp 0xa41d
addl $-0x2, %eax
jmp 0xa41d
decl %eax
movl %eax, %esi
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x4250
movq (%r12), %rdi
movl 0x8(%r12), %esi
movl %r15d, %edx
callq 0x5c72
movq (%r12), %r15
cmpq %rbx, %r15
je 0xa457
movq %r15, %rdi
callq 0x41e0
movq %r15, %rdi
callq 0x40e0
movq %rax, %r12
movq %r14, %rdi
callq 0x40e0
movq %rax, %r13
addl %r12d, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r12d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<unsigned long, char*>(unsigned long, char*, ParseDataType)
ParseData additionHelper<uint64_t, char*>(uint64_t n1, char* n2, ParseDataType type) {

  uint64_t arg1 = (uint64_t) n1;
  const char* arg1Str = std::to_string(arg1).c_str();
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %esi
cmpq $0xa, %rdi
jb 0xa534
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0xa52d
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0xa532
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0xa534
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0xa4f7
addl $-0x3, %esi
jmp 0xa534
addl $-0x2, %esi
jmp 0xa534
decl %esi
movl %esi, %esi
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x4250
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x8991
movq (%r12), %r15
cmpq %rbx, %r15
je 0xa56e
movq %r15, %rdi
callq 0x41e0
movq %r15, %rdi
callq 0x40e0
movq %rax, %r12
movq %r14, %rdi
callq 0x40e0
movq %rax, %r13
addl %r12d, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r12d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<double, char*>(double, char*, ParseDataType)
ParseData additionHelper<double, char*>(double n1, char* n2, ParseDataType type) {

  double arg1 = (double) n1;
  const char* arg1Str = std::to_string(arg1).c_str();
  char* arg2 = (char*) n2;
  uint32_t len1 = strlen(arg1Str);
  uint32_t len2 = strlen(arg2);
  
  char* res = new char[len1+len2+1];
  res[0] = '\0';
  strncat(res, arg1Str, len1);
  strncat(res, arg2, len2);
  res[len1+len2] = '\0';
  
  ParseData d;
  d.type = type;
  d.value.allocated = (void*) res;
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, -0x2c(%rbp)
movq %rdi, %r14
movq 0x219c3(%rip), %rsi     # 0x2bfb8
leaq 0x14a77(%rip), %rcx     # 0x1f073
leaq -0x58(%rbp), %r15
movl $0x148, %edx            # imm = 0x148
movq %r15, %rdi
movb $0x1, %al
callq 0x8a11
movq (%r15), %r15
leaq -0x48(%rbp), %rax
cmpq %rax, %r15
je 0xa623
movq %r15, %rdi
callq 0x41e0
movq %r15, %rdi
callq 0x40e0
movq %rax, %r12
movq %r14, %rdi
callq 0x40e0
movq %rax, %r13
addl %r12d, %eax
movq %rax, -0x38(%rbp)
leal (%r12,%r13), %edi
incl %edi
callq 0x4030
movq %rax, %rbx
xorl %eax, %eax
movb %al, (%rbx)
movl %r12d, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4160
movl %r13d, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4160
movq -0x38(%rbp), %rax
xorl %ecx, %ecx
movb %cl, (%rbx,%rax)
movl -0x2c(%rbp), %eax
movq %rbx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData additionHelper<Array*, Array*>(Array*, Array*, ParseDataType)
ParseData additionHelper<Array*, Array*>(Array* a1, Array* a2, ParseDataType type) {

	//get fields out of the array structs
	uint32_t len1 = a1->length;
	uint32_t len2 = a2->length;
	ParseDataType type1 = a1->subtype;
	ParseDataType type2 = a2->subtype;
	ParseData* values1 = a1->values;
	ParseData* values2 = a2->values;

	uint32_t length = len1 + len2;
	ParseDataType finalType = getTypeArithmeticExpression(ADD_OP, type1, type2);
	ParseData* values = (ParseData*) malloc(sizeof(ParseData) * length);

	for(uint32_t i = 0; i < len1; i++) {
		values[i] = castHelper(values1[i], finalType);
	}

	for(uint32_t i = 0; i < len2; i++) {
		values[i+len1] = castHelper(values2[i], finalType);
	}

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

	ParseData d;
	d.type = ARRAY_T;
	d.value.allocated = (void*) arr;

	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl (%rdi), %eax
movl 0x4(%rdi), %r15d
movl (%rsi), %edx
movl 0x4(%rsi), %ecx
movq 0x8(%rdi), %r12
movq 0x8(%rsi), %rsi
movq %rsi, -0x38(%rbp)
movq %rcx, -0x48(%rbp)
leal (%rcx,%r15), %ebx
movl $0xf, %edi
movl %eax, %esi
callq 0x16338
movl %eax, -0x2c(%rbp)
movq %rbx, -0x40(%rbp)
movq %rbx, %rdi
shlq $0x4, %rdi
callq 0x4290
movq %rax, %r14
testq %r15, %r15
je 0xa70f
movq %r15, %r13
shlq $0x4, %r13
xorl %ebx, %ebx
movl (%r12,%rbx), %edi
movq 0x8(%r12,%rbx), %rsi
movl -0x2c(%rbp), %edx
callq 0x150d0
movl %eax, (%r14,%rbx)
movq %rdx, 0x8(%r14,%rbx)
addq $0x10, %rbx
cmpq %rbx, %r13
jne 0xa6ec
movq -0x48(%rbp), %rbx
testq %rbx, %rbx
movq -0x38(%rbp), %r13
je 0xa751
shlq $0x4, %rbx
xorl %r12d, %r12d
movl (%r13,%r12), %edi
movq 0x8(%r13,%r12), %rsi
movl -0x2c(%rbp), %edx
callq 0x150d0
movl %r15d, %ecx
shlq $0x4, %rcx
movl %eax, (%r14,%rcx)
movq %rdx, 0x8(%r14,%rcx)
incl %r15d
addq $0x10, %r12
cmpq %r12, %rbx
jne 0xa723
movl $0x10, %edi
callq 0x4290
movq %rax, %rdx
movq -0x40(%rbp), %rax
movl %eax, 0x4(%rdx)
movl -0x2c(%rbp), %eax
movl %eax, (%rdx)
movq %r14, 0x8(%rdx)
movl $0xc, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData divisionHelper<unsigned char, double>(unsigned char, double, ParseDataType)
ParseData divisionHelper(T1 n1, T2 n2, ParseDataType type) {
 
  //first store the values in appropriate variables
  T1 arg1 = n1;
  T2 arg2 = n2;
  
  ParseData d;
  d.type = type;
  
  switch(type) {
    case CHAR_T: d.value.integer = (unsigned char) (arg1/arg2); break;
    case INT32_T: d.value.integer = (int32_t) (arg1/arg2); break;
    case INT64_T: d.value.integer = (int64_t) (arg1/arg2); break;
    case UINT32_T: d.value.integer = (uint32_t) (arg1/arg2); break;
    case UINT64_T: d.value.integer = (uint64_t) (arg1/arg2); break;
    case DOUBLE_T: d.value.floatingPoint = (double) (arg1/arg2); break;
  }
 
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
leal -0x2(%rax), %ecx
cmpl $0x8, %ecx
ja 0xc388
leaq 0x13751(%rip), %rdx     # 0x1fa40
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %ecx
movslq %ecx, %rdx
jmp 0xc388
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movl %ecx, %edx
jmp 0xc388
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
movq %xmm1, %rdx
jmp 0xc388
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rdx
jmp 0xc388
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
subsd 0x136d0(%rip), %xmm1    # 0x1fa38
cvttsd2si %xmm1, %rdx
andq %rsi, %rdx
orq %rcx, %rdx
jmp 0xc388
movzbl %dil, %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %ecx
movzbl %cl, %edx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arithmeticeval.cpp
// Function: ParseData modHelper<int, unsigned long>(int, unsigned long, ParseDataType)
ParseData modHelper(T1 n1, T2 n2, ParseDataType type) {
 
  //first store the values in appropriate variables
  T1 arg1 = n1;
  T2 arg2 = n2;
  
  ParseData d;
  d.type = type;
  
  switch(type) {
    case CHAR_T: d.value.integer = (unsigned char) (arg1 % arg2); break;
    case INT32_T: d.value.integer = (int32_t) (arg1 % arg2); break;
    case INT64_T: d.value.integer = (int64_t) (arg1 % arg2); break;
    case UINT32_T: d.value.integer = (uint32_t) (arg1 % arg2); break;
    case UINT64_T: d.value.integer = (uint64_t) (arg1 % arg2); break;
  }
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %ecx
leal -0x2(%rcx), %eax
cmpl $0x6, %eax
ja 0xe722
leaq 0x11d31(%rip), %rdx     # 0x2041c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
jmp 0xe722
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
movslq %edx, %rdx
jmp 0xe722
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
movl %edx, %edx
jmp 0xe722
movslq %edi, %rax
xorl %edx, %edx
divq %rsi
movzbl %dl, %edx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/assignmenteval.cpp
// Function: evaluateAssignmentExpression(AssignmentExpressionNode*)
ParseData evaluateAssignmentExpression(AssignmentExpressionNode* node) {

  //get stuff out of the node first
  SymbolTable* symbolTable = node->symbolTable;
  std::string variable = node->variable;
  AbstractExpressionNode* value = node->value;
  
  ParseDataType type = node->evalType;
  ParseData d = value->evaluate();
  
  //update variable value (innermost scope)
  symbolTable->update(variable, castHelper(d, type));
  
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %r15
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x8ac2
movq 0x40(%rbx), %rdi
movl 0x10(%rbx), %r12d
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebx
movq %rdx, %r14
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x8ac2
movl %ebx, %edi
movq %r14, %rsi
movl %r12d, %edx
callq 0x150d0
movq %rdx, %rcx
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
movl %eax, %edx
callq 0x165c2
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x10d62
callq 0x41e0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x10d74
callq 0x41e0
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x10d9e
callq 0x41e0
jmp 0x10d9e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x10db0
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/bitlogicaleval.cpp
// Function: logicHelper(bool, bool, ParseOperatorType)
ParseData logicHelper(bool n1, bool n2, ParseOperatorType op) {
 
  ParseData d;
  d.type = BOOL_T;
  
  switch(op) {
    case AND_OP: d.value.integer = n1 && n2; break;
    case XOR_OP: d.value.integer = n1 ^ n2; break;
    case OR_OP: d.value.integer = n1 || n2; break;
  }
 
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1e, %edx
je 0x10f0b
movl %edx, %eax
cmpl $0x1d, %edx
je 0x10f06
cmpl $0x1c, %eax
jne 0x10f12
andb %sil, %dil
jmp 0x10f0e
xorb %sil, %dil
jmp 0x10f0e
orb %sil, %dil
movzbl %dil, %edx
movl $0x9, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/comparisoneval.cpp
// Function: ParseData inequalityHelper<char*, char*>(char*, char*, ParseOperatorType)
ParseData inequalityHelper<char*, char*>(char* str1, char* str2, ParseOperatorType op) {
 
  char* arg1 = str1;
  char* arg2 = str2;
  
  ParseData d;
  d.type = BOOL_T;
  int32_t res = strcmp(str1, str2);
  
  switch(op) { 
    case GREATER_OP: d.value.integer = res > 0; break;
    case GREATER_EQ_OP: d.value.integer = res >= 0; break;
    case LESS_OP: d.value.integer = res < 0; break;
    case LESS_EQ_OP: d.value.integer = res <= 0; break;
  }
  
  return d; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %ebx
callq 0x42d0
addl $-0x13, %ebx
cmpl $0x3, %ebx
ja 0x13a24
leaq 0xeb44(%rip), %rcx      # 0x2253c
movslq (%rcx,%rbx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
xorl %edx, %edx
testl %eax, %eax
setg %dl
jmp 0x13a24
xorl %edx, %edx
testl %eax, %eax
setns %dl
jmp 0x13a24
xorl %edx, %edx
testl %eax, %eax
setle %dl
jmp 0x13a24
shrl $0x1f, %eax
movq %rax, %rdx
jmp 0x13a24
movl $0x9, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/comparisoneval.cpp
// Function: ParseData equalityHelper<char*, char*>(char*, char*, ParseOperatorType)
ParseData equalityHelper<char*, char*>(char* str1, char* str2, ParseOperatorType op) {
 
  char* arg1 = str1;
  char* arg2 = str2;
  
  ParseData d;
  d.type = BOOL_T;
  int32_t res = strcmp(str1, str2);
  
  switch(op) { 
    case EQ_EQ_OP: d.value.integer = res == 0; break;
    case NOT_EQ_OP: d.value.integer = res != 0; break;
  }
  
  return d; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edx, %ebx
callq 0x42d0
cmpl $0x18, %ebx
je 0x13a50
cmpl $0x17, %ebx
jne 0x13a57
xorl %edx, %edx
testl %eax, %eax
sete %dl
jmp 0x13a57
xorl %edx, %edx
testl %eax, %eax
setne %dl
movl $0x9, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/functioneval.cpp
// Function: evaluateFunctionExpression(FunctionExpressionNode*)
ParseData evaluateFunctionExpression(FunctionExpressionNode* node) {
	
	SymbolTable* symbolTable = node->symbolTable;

	//function information
	Function* function = node->function;
	uint32_t numArgs = node->numArgs;
	AbstractExpressionNode** args = node->arguments;
	char** argNames = function->argNames;
	vector<AbstractStatementNode*>* body = function->body;
	
	
	//evaluate parameters
	ParseData* arguments = (ParseData*) malloc(sizeof(ParseData) * numArgs);
	for(uint32_t i = 0; i < numArgs; i++) {
		arguments[i] = args[i]->evaluate();
	}

	//enter function scope
	symbolTable->enterNewScope();

	//declare parameters with computed arguments
	for(uint32_t i = 0; i < numArgs; i++) {
		symbolTable->declare(argNames[i], arguments[i]);
	}

	//execute statements in the body
	vector<AbstractStatementNode*>::iterator it;
	bool* returnFlag = node->isReturned;
	*returnFlag = false;
	for(it = body->begin(); !(*returnFlag) && it != body->end(); it++) {
		(*it)->execute();
	}

	//return value placed in correct address by return statement
	symbolTable->leaveScope();
	return *(node->returnValue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x30(%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0x28(%rdi), %rax
movl 0x18(%rdi), %ebx
movq %rdi, -0x48(%rbp)
movq 0x20(%rdi), %r12
movq 0x18(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq %rbx, %rdi
shlq $0x4, %rdi
callq 0x4290
movq %rax, %r15
testq %rbx, %rbx
je 0x14c82
leaq (,%rbx,8), %r13
xorl %r14d, %r14d
movq (%r12,%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, (%r15,%r14,2)
movq %rdx, 0x8(%r15,%r14,2)
addq $0x8, %r14
cmpq %r14, %r13
jne 0x14c67
movq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x1650a
testq %rbx, %rbx
je 0x14ce1
shlq $0x3, %rbx
xorl %r13d, %r13d
leaq -0x70(%rbp), %r12
movq -0x50(%rbp), %rax
movq (%rax,%r13), %rsi
movq %r12, %rdi
leaq -0x29(%rbp), %rdx
callq 0x40c0
movl (%r15,%r13,2), %edx
movq 0x8(%r15,%r13,2), %rcx
movq %r14, %rdi
movq %r12, %rsi
callq 0x16598
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x14cd8
callq 0x41e0
addq $0x8, %r13
cmpq %r13, %rbx
jne 0x14c9e
movq -0x48(%rbp), %r15
movq 0x38(%r15), %rbx
movb $0x0, (%rbx)
movq -0x40(%rbp), %r12
movq (%r12), %r14
cmpq 0x8(%r12), %r14
je 0x14d0c
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r14
cmpb $0x1, (%rbx)
jne 0x14cf4
movq -0x38(%rbp), %rdi
callq 0x16586
movq 0x40(%r15), %rcx
movl (%rcx), %eax
movq 0x8(%rcx), %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x14d43
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/memberaccesseval.cpp
// Function: elementHelper(ArrayAccessNode*, ParseData, int)
ParseData elementHelper(ArrayAccessNode* node, ParseData arr, int32_t index) {
  
  ParseData d;
	ParseDataType type = arr.type;
	
	if(arr.type == STRING_T) {

		d.type = CHAR_T;
		char* str = (char*) arr.value.allocated;
		int32_t len = strlen(str);
		
		int32_t ind = index;
		if(ind < 0)
			ind += len+1;

		//if index is out-of-bounds, throw exception
		if(ind < 0 || ind > len-1) {
			throw OutOfBoundsException(false, len, index, copyString(node->context), node->startLine, node->endLine);
		}

		d.value.integer = str[ind];
		return d;
		
	} else if(type == ARRAY_T) {

		Array* array = (Array*) arr.value.allocated;
		int32_t len = array->length;
		ParseData* values = array->values;

		int32_t ind = index;
		if(ind < 0)
			ind += len; 
		
		//if index is out-of-bounds, throw exception
		if(ind < 0 || ind > len-1) {
			throw OutOfBoundsException(true, len, index, copyString(node->context), node->startLine, node->endLine);
		}

		ParseData val = values[ind];
		return val;
	}

  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rdi, %r14
cmpl $0xc, %esi
je 0x14f7f
movl $0x8, %r12d
cmpl $0xb, %esi
jne 0x14fa9
movq %r15, %rdi
callq 0x40e0
movq %rax, %r13
leal 0x1(%rax), %ecx
movl %ebx, %eax
sarl $0x1f, %eax
andl %ecx, %eax
addl %ebx, %eax
js 0x14fbb
cmpl %r13d, %eax
jge 0x14fbb
movl %eax, %eax
movsbq (%r15,%rax), %rdx
jmp 0x14fa9
movl 0x4(%r15), %r12d
movl %ebx, %eax
sarl $0x1f, %eax
andl %r12d, %eax
addl %ebx, %eax
js 0x14ff2
cmpl %r12d, %eax
jge 0x14ff2
movq 0x8(%r15), %rcx
movl %eax, %eax
shlq $0x4, %rax
movl (%rcx,%rax), %r12d
movq 0x8(%rcx,%rax), %rdx
jmp 0x14fa9
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x4110
movq %rax, %r15
movq 0x30(%r14), %rdi
callq 0x176b0
movq 0x8(%r14), %rcx
leaq 0x166f4(%rip), %rdx     # 0x2b6d0
addq $0x10, %rdx
movq %rdx, (%r15)
movq %rax, 0x8(%r15)
movb $0x0, 0x10(%r15)
movl %r13d, 0x14(%r15)
jmp 0x15027
movl $0x28, %edi
callq 0x4110
movq %rax, %r15
movq 0x30(%r14), %rdi
callq 0x176b0
movq 0x8(%r14), %rcx
leaq 0x166bd(%rip), %rdx     # 0x2b6d0
addq $0x10, %rdx
movq %rdx, (%r15)
movq %rax, 0x8(%r15)
movb $0x1, 0x10(%r15)
movl %r12d, 0x14(%r15)
movl %ebx, 0x18(%r15)
movq %rcx, 0x1c(%r15)
leaq 0x166c2(%rip), %rsi     # 0x2b6f8
movq 0x16f9b(%rip), %rdx     # 0x2bfd8
movq %r15, %rdi
callq 0x4350
jmp 0x15047
movq %rax, %rbx
movq %r15, %rdi
callq 0x4190
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/memberaccesseval.cpp
// Function: evaluateArrayAccess(ArrayAccessNode*)
ParseData evaluateArrayAccess(ArrayAccessNode* node) {
  
	ParseDataType type = node->evalType;
  ParseData array = node->array->evaluate();
  ParseData start = node->start->evaluate();
  ParseData end;
  
  if(node->isSlice)
    end = node->end->evaluate();
  
  if(node->isSlice) {
    return sliceHelper(node, array, (int32_t) start.value.integer, (int32_t) end.value.integer);
  } else {
    return elementHelper(node, array, (int32_t) start.value.integer); 
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %r15d
movq %rdx, %r14
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rdx, %r12
cmpb $0x1, 0x38(%rbx)
jne 0x15095
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rdx, %r8
cmpb $0x1, 0x38(%rbx)
jne 0x150b4
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %r12d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14d4c
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movl %r12d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14f32
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/arrayeval.cpp
// Function: evaluateArrayExpression(ArrayNode*)
ParseData evaluateArrayExpression(ArrayNode* node) {

	//extract instance fields
	bool isInitialized = node->isInitialized;
	ParseDataType subtype = node->subType;
	uint32_t length = (uint32_t) (node->length->evaluate().value.integer);
	AbstractExpressionNode** elements = node->values;

	//construct the array
	Array* arr = (Array*) malloc(sizeof(Array));
	arr->subtype = subtype;
	arr->length = length;
	
	ParseData* values = (ParseData*) malloc(sizeof(ParseData) * length);
	
	//if the array is initialized, fill it accordingly
	if(isInitialized) {
		for(uint32_t i = 0; i < length ; i++) {
			values[i] = elements[i]->evaluate();
		}
	}
	arr->values = values;

	ParseData d;
	d.type = ARRAY_T;
	d.value.allocated = (void*) arr;
	
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x18(%rdi), %r13b
movl 0x14(%rdi), %r14d
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rdx, %r15
movq 0x28(%rbx), %r12
movl $0x10, %edi
callq 0x4290
movq %rax, %rbx
movl %r14d, (%rax)
movl %r15d, 0x4(%rax)
movl %r15d, %edi
shlq $0x4, %rdi
callq 0x4290
movq %rax, %r14
testl %r15d, %r15d
je 0x15757
testb %r13b, %r13b
je 0x15757
movl %r15d, %r15d
shlq $0x3, %r15
xorl %r13d, %r13d
movq (%r12,%r13), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, (%r14,%r13,2)
movq %rdx, 0x8(%r14,%r13,2)
addq $0x8, %r13
cmpq %r13, %r15
jne 0x1573c
movq %r14, 0x8(%rbx)
movl $0xc, %eax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: ExpressionStatementNode::ExpressionStatementNode(AbstractExpressionNode*, SymbolTable*)
ExpressionStatementNode::ExpressionStatementNode(AbstractExpressionNode* exp, SymbolTable* symbolTable) {
  expression = exp;
  this->symbolTable = symbolTable;
	startLine = exp->startLine;
	endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x163d5(%rip), %rax     # 0x2bb60
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x10(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: PrintStatementNode::PrintStatementNode(AbstractExpressionNode*, SymbolTable*, unsigned int)
PrintStatementNode::PrintStatementNode(AbstractExpressionNode* exp, SymbolTable* symbolTable, uint32_t startLine) {
  expression = exp;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x163bf(%rip), %rax     # 0x2bb78
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x10(%rdi)
movl %ecx, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AshOlogn[P]ash-language-interpreter/src/statementnode.cpp
// Function: PrintLineStatementNode::PrintLineStatementNode(AbstractExpressionNode*, SymbolTable*, unsigned int)
PrintLineStatementNode::PrintLineStatementNode(AbstractExpressionNode* exp, SymbolTable* symbolTable, uint32_t startLine) {
  expression = exp;
  this->symbolTable = symbolTable;
	this->startLine = startLine;
	this->endLine = exp->endLine;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x163ab(%rip), %rax     # 0x2bb90
movq %rax, (%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x10(%rdi)
movl %ecx, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
popq %rbp
retq
nop