LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::CreateStatement::setColumnDefsAndConstraints(std::vector<hsql::TableElement*, std::allocator<hsql::TableElement*>>*)
void CreateStatement::setColumnDefsAndConstraints(std::vector<TableElement*>* tableElements) {
  columns = new std::vector<ColumnDefinition*>();
  tableConstraints = new std::vector<TableConstraint*>();

  for (auto tableElem : *tableElements) {
    if (auto* colDef = dynamic_cast<ColumnDefinition*>(tableElem)) {
      columns->emplace_back(colDef);
    } else if (auto* tableConstraint = dynamic_cast<TableConstraint*>(tableElem)) {
      tableConstraints->emplace_back(tableConstraint);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x12970
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
movq %rax, 0x50(%rbx)
movl $0x18, %edi
callq 0x12970
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x58(%rbx)
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x1f2c4
movq 0x1bd30(%rip), %r15     # 0x3af78
movq 0x1bcf1(%rip), %rbp     # 0x3af40
movq (%r12), %r14
testq %r14, %r14
je 0x1f26a
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x12a60
jmp 0x1f26c
xorl %eax, %eax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1f286
movq 0x50(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x120e0
jmp 0x1f2bb
testq %r14, %r14
je 0x1f2a1
movq %r14, %rdi
movq %r15, %rsi
movq 0x1bbf8(%rip), %rdx     # 0x3ae90
xorl %ecx, %ecx
callq 0x12a60
jmp 0x1f2a3
xorl %eax, %eax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1f2bb
movq 0x58(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x12120
addq $0x8, %r12
cmpq %r13, %r12
jne 0x1f24f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::WindowDescription::~WindowDescription()
WindowDescription::~WindowDescription() {
  if (partitionList) {
    for (Expr* e : *partitionList) {
      delete e;
    }
    delete partitionList;
  }

  if (orderList) {
    for (OrderDescription* orderDescription : *orderList) {
      delete orderDescription;
    }
    delete orderList;
  }

  delete frameDescription;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1b7f5(%rip), %rax     # 0x3aee8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1f74d
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x1f723
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f71d
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1f70a
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1f74d
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f740
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1f7a0
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x1f776
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f770
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1f75d
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x1f7a0
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f793
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1f7b4
movq (%rdi), %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::~Expr()
Expr::~Expr() {
  delete expr;
  delete expr2;
  delete select;
  delete windowDescription;

  free(name);
  free(table);
  free(alias);

  if (exprList) {
    for (Expr* e : *exprList) {
      delete e;
    }
    delete exprList;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1b6b7(%rip), %rax     # 0x3af08
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1f867
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1f876
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1f885
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x1f897
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rdi
callq 0x12ab0
movq 0x38(%rbx), %rdi
callq 0x12ab0
movq 0x40(%rbx), %rdi
callq 0x12ab0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x1f90a
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x1f8db
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f8d5
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1f8c2
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0x1f90a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1f8f8
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12990
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeOpUnary(hsql::OperatorType, hsql::Expr*)
Expr* Expr::makeOpUnary(OperatorType op, Expr* expr) {
  Expr* e = new Expr(kExprOperator);
  e->opType = op;
  e->expr = expr;
  e->expr2 = nullptr;
  return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xa, %esi
callq 0x13330
movl %ebp, 0x8c(%rbx)
movq %r14, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeOpBinary(hsql::Expr*, hsql::OperatorType, hsql::Expr*)
Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) {
  Expr* e = new Expr(kExprOperator);
  e->opType = op;
  e->expr = expr1;
  e->expr2 = expr2;
  return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xa, %esi
callq 0x13330
movl %ebp, 0x8c(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeBetween(hsql::Expr*, hsql::Expr*, hsql::Expr*)
Expr* Expr::makeBetween(Expr* expr, Expr* left, Expr* right) {
  Expr* e = new Expr(kExprOperator);
  e->expr = expr;
  e->opType = kOpBetween;
  e->exprList = new std::vector<Expr*>();
  e->exprList->push_back(left);
  e->exprList->push_back(right);
  return e;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xa, %esi
callq 0x13330
movq %r14, 0x10(%rbx)
movl $0x1, 0x8c(%rbx)
movl $0x18, %edi
callq 0x12970
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x20(%rbx)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x1fa8b
movq 0x10(%rsp), %rcx
movq %rcx, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x1fa98
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x12080
movq 0x20(%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1fab5
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x1fabf
leaq 0x8(%rsp), %rdx
callq 0x12080
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeCaseList(hsql::Expr*)
Expr* Expr::makeCaseList(Expr* caseListElement) {
  Expr* e = new Expr(kExprOperator);
  // Case list expressions are temporary and will be integrated into the case
  // expressions exprList - thus assign operator type kOpNone
  e->opType = kOpNone;
  e->exprList = new std::vector<Expr*>();
  e->exprList->push_back(caseListElement);
  return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xa, %esi
callq 0x13330
movl $0x0, 0x8c(%rbx)
movl $0x18, %edi
callq 0x12970
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x20(%rbx)
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x1fb42
movq (%rsp), %rcx
movq %rcx, (%rsi)
addq $0x8, 0x8(%rax)
jmp 0x1fb4d
movq %rsp, %rdx
movq %rax, %rdi
callq 0x12080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeCaseListElement(hsql::Expr*, hsql::Expr*)
Expr* Expr::makeCaseListElement(Expr* when, Expr* then) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpCaseListElement;
  e->expr = when;
  e->expr2 = then;
  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xa, %esi
callq 0x13330
movl $0x3, 0x8c(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeCase(hsql::Expr*, hsql::Expr*, hsql::Expr*)
Expr* Expr::makeCase(Expr* expr, Expr* caseList, Expr* elseExpr) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpCase;
  e->expr = expr;
  e->expr2 = elseExpr;
  e->exprList = caseList->exprList;
  caseList->exprList = nullptr;
  delete caseList;
  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xa, %esi
callq 0x13330
movl $0x2, 0x8c(%rbx)
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq $0x0, 0x20(%r14)
testq %r14, %r14
je 0x1fc5f
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeLiteral(bool)
Expr* Expr::makeLiteral(bool val) {
  Expr* e = new Expr(kExprLiteralInt);
  e->ival = (int)val;
  e->isBoolLiteral = true;
  return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0x2, %esi
callq 0x13330
movzbl %bpl, %eax
movq %rax, 0x50(%rbx)
movb $0x1, 0x88(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeIntervalLiteral(long, hsql::DatetimeField)
Expr* Expr::makeIntervalLiteral(int64_t duration, DatetimeField unit) {
  Expr* e = new Expr(kExprLiteralInterval);
  e->ival = duration;
  e->datetimeField = unit;
  return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0x5, %esi
callq 0x13330
movq %r14, 0x50(%rbx)
movl %ebp, 0x60(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeColumnRef(char*, char*)
Expr* Expr::makeColumnRef(char* table, char* name) {
  Expr* e = new Expr(kExprColumnRef);
  e->name = name;
  e->table = table;
  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0x8, %esi
callq 0x13330
movq %r15, 0x30(%rbx)
movq %r14, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeFunctionRef(char*, std::vector<hsql::Expr*, std::allocator<hsql::Expr*>>*, bool, hsql::WindowDescription*)
Expr* Expr::makeFunctionRef(char* func_name, std::vector<Expr*>* exprList, bool distinct, WindowDescription* window) {
  Expr* e = new Expr(kExprFunctionRef);
  e->name = func_name;
  e->exprList = exprList;
  e->distinct = distinct;
  e->windowDescription = window;
  return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movl $0xa0, %edi
callq 0x12970
movq %rax, %r14
movq %rax, %rdi
movl $0x9, %esi
callq 0x13330
movq %r12, 0x30(%r14)
movq %r15, 0x20(%r14)
movb %bpl, 0x90(%r14)
movq %rbx, 0x98(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xa0, %esi
movq %r14, %rdi
callq 0x12990
movq %rbx, %rdi
callq 0x13110
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeArrayIndex(hsql::Expr*, long)
Expr* Expr::makeArrayIndex(Expr* expr, int64_t index) {
  Expr* e = new Expr(kExprArrayIndex);
  e->expr = expr;
  e->ival = index;
  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xe, %esi
callq 0x13330
movq %r15, 0x10(%rbx)
movq %r14, 0x50(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeExists(hsql::SelectStatement*)
Expr* Expr::makeExists(SelectStatement* select) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpExists;
  e->select = select;
  return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xa, %esi
callq 0x13330
movl $0x1a, 0x8c(%rbx)
movq %r14, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeInOperator(hsql::Expr*, std::vector<hsql::Expr*, std::allocator<hsql::Expr*>>*)
Expr* Expr::makeInOperator(Expr* expr, std::vector<Expr*>* exprList) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpIn;
  e->expr = expr;
  e->exprList = exprList;

  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xa, %esi
callq 0x13330
movl $0x15, 0x8c(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeExtract(hsql::DatetimeField, hsql::Expr*)
Expr* Expr::makeExtract(DatetimeField datetimeField, Expr* expr) {
  Expr* e = new Expr(kExprExtract);
  e->datetimeField = datetimeField;
  e->expr = expr;
  return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xf, %esi
callq 0x13330
movl %ebp, 0x60(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeCast(hsql::Expr*, hsql::ColumnType)
Expr* Expr::makeCast(Expr* expr, ColumnType columnType) {
  Expr* e = new Expr(kExprCast);
  e->columnType = columnType;
  e->expr = expr;
  return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0x10, %esi
callq 0x13330
leaq 0x20(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::substr(char const*, int, int)
char* substr(const char* source, int from, int to) {
  int len = to - from;
  char* copy = (char*)malloc(len + 1);
  ;
  strncpy(copy, source + from, len);
  copy[len] = '\0';
  return copy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
subl %esi, %ebx
leal 0x1(%rbx), %eax
movslq %eax, %rdi
callq 0x12c00
movq %rax, %r15
movslq %ebp, %rsi
addq %r14, %rsi
movslq %ebx, %rbx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x12420
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/SQLStatement.cpp
// Function: hsql::SQLStatement::~SQLStatement()
SQLStatement::~SQLStatement() {
  if (hints) {
    for (Expr* hint : *hints) {
      delete hint;
    }
  }
  delete hints;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1ab6b(%rip), %rax     # 0x3af60
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x20425
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x20425
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2041f
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x2040c
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x20454
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x20442
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12990
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::operator<<(std::ostream&, hsql::ColumnType const&)
std::ostream& operator<<(std::ostream& stream, const ColumnType& column_type) {
  switch (column_type.data_type) {
    case DataType::UNKNOWN:
      stream << "UNKNOWN";
      break;
    case DataType::INT:
      stream << "INT";
      break;
    case DataType::BIGINT:
      stream << "BIGINT";
      break;
    case DataType::LONG:
      stream << "LONG";
      break;
    case DataType::FLOAT:
      stream << "FLOAT";
      break;
    case DataType::DOUBLE:
      stream << "DOUBLE";
      break;
    case DataType::REAL:
      stream << "REAL";
      break;
    case DataType::CHAR:
      stream << "CHAR(" << column_type.length << ")";
      break;
    case DataType::VARCHAR:
      stream << "VARCHAR(" << column_type.length << ")";
      break;
    case DataType::DECIMAL:
      stream << "DECIMAL";
      break;
    case DataType::TEXT:
      stream << "TEXT";
      break;
    case DataType::DATETIME:
      stream << "DATETIME";
      break;
    case DataType::DATE:
      stream << "DATE";
      break;
    case DataType::TIME:
      stream << "TIME";
      break;
    case DataType::SMALLINT:
      stream << "SMALLINT";
      break;
    case DataType::BOOLEAN:
      stream << "BOOLEAN";
      break;
  }
  return stream;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0xf, %rax
ja 0x205fd
movq %rsi, %r14
leaq 0x12cda(%rip), %rcx     # 0x331ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x12edc(%rip), %rsi     # 0x333fe
jmp 0x205e2
leaq 0x6e07(%rip), %rsi      # 0x27335
jmp 0x205f0
leaq 0x6c93(%rip), %rsi      # 0x271cd
jmp 0x205f0
leaq 0x130a0(%rip), %rsi     # 0x335e6
jmp 0x205f0
leaq 0x6c88(%rip), %rsi      # 0x271da
jmp 0x205cb
leaq 0x6c8b(%rip), %rsi      # 0x271e6
movl $0x3, %edx
jmp 0x205f5
leaq 0x6ed4(%rip), %rsi      # 0x27440
jmp 0x205e2
leaq 0x12e91(%rip), %rsi     # 0x33406
movl $0x8, %edx
jmp 0x20588
leaq 0x12e86(%rip), %rsi     # 0x33409
movl $0x5, %edx
movq %rbx, %rdi
callq 0x12a70
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x128b0
leaq 0x12b08(%rip), %rsi     # 0x330ab
movl $0x1, %edx
movq %rax, %rdi
jmp 0x205f8
leaq 0x6c72(%rip), %rsi      # 0x27226
jmp 0x205bd
leaq 0x6c26(%rip), %rsi      # 0x271e3
movl $0x6, %edx
jmp 0x205f5
leaq 0x6d66(%rip), %rsi      # 0x27331
movl $0x8, %edx
jmp 0x205f5
leaq 0x6db1(%rip), %rsi      # 0x2738a
jmp 0x205f0
leaq 0x6bf0(%rip), %rsi      # 0x271d2
movl $0x7, %edx
jmp 0x205f5
leaq 0x6d81(%rip), %rsi      # 0x27371
movl $0x4, %edx
movq %rbx, %rdi
callq 0x12a70
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6cba(%rip), %rsi      # 0x272c9
movl $0x5, %edx
jmp 0x205f5
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::ExecuteStatement::~ExecuteStatement()
ExecuteStatement::~ExecuteStatement() {
  free(name);

  if (parameters) {
    for (Expr* param : *parameters) {
      delete param;
    }
    delete parameters;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1a65b(%rip), %rax     # 0x3af10
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x12ab0
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x20918
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x208ee
movq (%r14), %rdi
testq %rdi, %rdi
je 0x208e8
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x208d5
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x20918
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2090b
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12c10
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::ExportStatement::~ExportStatement()
ExportStatement::~ExportStatement() {
  free(filePath);
  free(schema);
  free(tableName);
  delete select;
  free(encoding);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1a63d(%rip), %rax     # 0x3afc8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x12ab0
movq 0x28(%rbx), %rdi
callq 0x12ab0
movq 0x30(%rbx), %rdi
callq 0x12ab0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x209bc
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
callq 0x12ab0
movq %rbx, %rdi
popq %rbx
jmp 0x12c10
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::ImportStatement::~ImportStatement()
ImportStatement::~ImportStatement() {
  free(filePath);
  free(schema);
  free(tableName);
  delete whereClause;
  free(encoding);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1a573(%rip), %rax     # 0x3afc0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x12ab0
movq 0x28(%rbx), %rdi
callq 0x12ab0
movq 0x30(%rbx), %rdi
callq 0x12ab0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x20a7e
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
callq 0x12ab0
movq %rbx, %rdi
popq %rbx
jmp 0x12c10
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::InsertStatement::~InsertStatement()
InsertStatement::~InsertStatement() {
  free(schema);
  free(tableName);
  delete select;

  if (columns) {
    for (char* column : *columns) {
      free(column);
    }
    delete columns;
  }

  if (values) {
    for (Expr* expr : *values) {
      delete expr;
    }
    delete values;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1a45f(%rip), %rax     # 0x3af58
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x12ab0
movq 0x28(%rbx), %rdi
callq 0x12ab0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x20b21
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x20b6e
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x20b44
movq (%r14), %rdi
callq 0x12ab0
addq $0x8, %r14
jmp 0x20b31
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x20b6e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x20b61
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x20bc1
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x20b97
movq (%r14), %rdi
testq %rdi, %rdi
je 0x20b91
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x20b7e
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x20bc1
movq (%r14), %rdi
testq %rdi, %rdi
je 0x20bb4
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12c10
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::GroupByDescription::~GroupByDescription()
GroupByDescription::~GroupByDescription() {
  delete having;

  if (columns) {
    for (Expr* expr : *columns) {
      delete expr;
    }
    delete columns;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1a211(%rip), %rax     # 0x3af48
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x20d4d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x20da5
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x20d76
movq (%r14), %rdi
testq %rdi, %rdi
je 0x20d70
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x20d5d
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x20da5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x20d93
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12990
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::UpdateStatement::~UpdateStatement()
UpdateStatement::~UpdateStatement() {
  delete table;
  delete where;

  if (updates) {
    for (UpdateClause* update : *updates) {
      free(update->column);
      delete update->value;
      delete update;
    }
    delete updates;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x19e82(%rip), %rax     # 0x3af70
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x21104
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x21113
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2117f
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x21155
movq (%r15), %r14
movq (%r14), %rdi
callq 0x12ab0
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x21142
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x10, %esi
movq %r14, %rdi
callq 0x12990
addq $0x8, %r15
jmp 0x21123
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x2117f
movq (%r14), %rdi
testq %rdi, %rdi
je 0x21172
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12c10
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::Alias::~Alias()
Alias::~Alias() {
  free(name);
  if (columns) {
    for (char* column : *columns) {
      free(column);
    }
    delete columns;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x12ab0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x21214
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x211e5
movq (%r14), %rdi
callq 0x12ab0
addq $0x8, %r14
jmp 0x211d2
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x21214
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x21202
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12990
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::TableRef::~TableRef()
TableRef::~TableRef() {
  free(schema);
  free(name);

  delete select;
  delete join;
  delete alias;

  if (list) {
    for (TableRef* table : *list) {
      delete table;
    }
    delete list;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x19cd5(%rip), %rax     # 0x3af20
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
callq 0x12ab0
movq 0x18(%rbx), %rdi
callq 0x12ab0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x21273
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x21282
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x212a0
movq %r14, %rdi
callq 0x12c90
movl $0x10, %esi
movq %r14, %rdi
callq 0x12990
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x212f8
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x212c9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x212c3
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x212b0
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
je 0x212f8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x212e6
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12990
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::JoinDefinition::~JoinDefinition()
JoinDefinition::~JoinDefinition() {
  delete left;
  delete right;
  delete condition;

  if (namedColumns) {
    for (auto* column : *namedColumns) {
      free(column);
    }
    delete namedColumns;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x19c4b(%rip), %rax     # 0x3afb0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2137b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2138a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x21399
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x213eb
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x213bc
movq (%r14), %rdi
callq 0x12ab0
addq $0x8, %r14
jmp 0x213a9
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0x213eb
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x213d9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12990
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::SetOperation::~SetOperation()
SetOperation::~SetOperation() {
  delete nestedSelectStatement;
  delete resultLimit;

  if (resultOrder) {
    for (OrderDescription* desc : *resultOrder) {
      delete desc;
    }
    delete resultOrder;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x19b81(%rip), %rax     # 0x3afb8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2144d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x2145c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x214b4
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x21485
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2147f
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x2146c
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
je 0x214b4
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x214a2
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12990
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x12990
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::printTableRefInfo(hsql::TableRef*, unsigned long)
void printTableRefInfo(TableRef* table, uintmax_t num_indent) {
  switch (table->type) {
    case kTableName:
      inprint(table->name, num_indent);
      if (table->schema) {
        inprint("Schema", num_indent + 1);
        inprint(table->schema, num_indent + 2);
      }
      break;
    case kTableSelect:
      printSelectStatementInfo(table->select, num_indent);
      break;
    case kTableJoin:
      inprint("Join Table", num_indent);
      inprint("Left", num_indent + 1);
      printTableRefInfo(table->join->left, num_indent + 2);
      inprint("Right", num_indent + 1);
      printTableRefInfo(table->join->right, num_indent + 2);
      inprint("Join Condition", num_indent + 1);
      printExpression(table->join->condition, num_indent + 2);
      break;
    case kTableCrossProduct:
      for (TableRef* tbl : *table->list) printTableRefInfo(tbl, num_indent);
      break;
  }

  if (table->alias) {
    printAlias(table->alias, num_indent);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpq $0x3, %rax
ja 0x22555
leaq 0x10fa0(%rip), %rcx     # 0x33410
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x13090
cmpq $0x0, 0x10(%r14)
je 0x22555
leaq 0x1(%rbx), %rsi
leaq 0x11057(%rip), %rdi     # 0x334f2
callq 0x13090
movq 0x10(%r14), %rdi
leaq 0x2(%rbx), %rsi
callq 0x13090
jmp 0x22555
leaq 0x11040(%rip), %rdi     # 0x334f9
movq %rbx, %rsi
callq 0x13090
leaq 0x1(%rbx), %r15
leaq 0x11038(%rip), %rdi     # 0x33504
movq %r15, %rsi
callq 0x13090
movq 0x38(%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x2(%rbx), %r12
movq %r12, %rsi
callq 0x12c20
leaq 0x1101a(%rip), %rdi     # 0x33509
movq %r15, %rsi
callq 0x13090
movq 0x38(%r14), %rax
movq 0x10(%rax), %rdi
movq %r12, %rsi
callq 0x12c20
leaq 0x11001(%rip), %rdi     # 0x3350f
movq %r15, %rsi
callq 0x13090
movq 0x38(%r14), %rax
movq 0x18(%rax), %rdi
movq %r12, %rsi
callq 0x12800
jmp 0x22555
movq 0x30(%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x22555
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x12c20
addq $0x8, %r15
jmp 0x22533
movq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x12540
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x22571
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::printAlias(hsql::Alias*, unsigned long)
void printAlias(Alias* alias, uintmax_t num_indent) {
  inprint("Alias", num_indent + 1);
  inprint(alias->name, num_indent + 2);

  if (alias->columns) {
    for (char* column : *(alias->columns)) {
      inprint(column, num_indent + 3);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
incq %rsi
leaq 0x10940(%rip), %rdi     # 0x3351e
callq 0x13090
movq (%r14), %rdi
leaq 0x2(%rbx), %rsi
callq 0x13090
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x22c1c
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x22c1c
addq $0x3, %rbx
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x13090
addq $0x8, %r14
cmpq %r15, %r14
jne 0x22c08
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::printOperatorExpression(hsql::Expr*, unsigned long)
void printOperatorExpression(Expr* expr, uintmax_t num_indent) {
  if (expr == nullptr) {
    inprint("null", num_indent);
    return;
  }

  inprint(expr->opType, num_indent);

  printExpression(expr->expr, num_indent + 1);
  if (expr->expr2) {
    printExpression(expr->expr2, num_indent + 1);
  } else if (expr->exprList) {
    for (Expr* e : *expr->exprList) printExpression(e, num_indent + 1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x22c66
movq %rdi, %r14
addq $0x8c, %rdi
movq %rbx, %rsi
callq 0x12ed0
movq 0x10(%r14), %rdi
incq %rbx
movq %rbx, %rsi
callq 0x12800
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x22c7a
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x12800
leaq 0x108b7(%rip), %rdi     # 0x33524
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13090
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x22ca0
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x22ca0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x12800
addq $0x8, %r14
jmp 0x22c8a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::printWindowDescription(hsql::WindowDescription*, unsigned long)
void printWindowDescription(WindowDescription* window_description, uintmax_t num_indent) {
  inprint("OVER", num_indent);
  if (window_description->partitionList) {
    inprint("PARTITION BY", num_indent + 1);
    for (const auto e : *window_description->partitionList) {
      printExpression(e, num_indent + 2);
    }
  }

  if (window_description->orderList) {
    inprint("ORDER BY", num_indent + 1);
    printOrderBy(window_description->orderList, num_indent + 2);
  }

  std::stringstream stream;
  switch (window_description->frameDescription->type) {
    case kRows:
      stream << "ROWS";
      break;
    case kRange:
      stream << "RANGE";
      break;
    case kGroups:
      stream << "GROUPS";
      break;
  }
  stream << " BETWEEN " << *window_description->frameDescription->start << " AND "
         << *window_description->frameDescription->end;
  inprint(stream.str().c_str(), num_indent + 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4636(%rip), %rdi      # 0x272f9
callq 0x13090
cmpq $0x0, 0x8(%r14)
je 0x22d08
leaq 0x1(%rbx), %rsi
leaq 0x1088b(%rip), %rdi     # 0x33565
callq 0x13090
movq 0x8(%r14), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x22d08
leaq 0x2(%rbx), %r15
movq (%r12), %rdi
movq %r15, %rsi
callq 0x12800
addq $0x8, %r12
cmpq %r13, %r12
jne 0x22cf3
cmpq $0x0, 0x10(%r14)
je 0x22d2c
leaq 0x1(%rbx), %rsi
leaq 0x10858(%rip), %rdi     # 0x33572
callq 0x13090
movq 0x10(%r14), %rdi
leaq 0x2(%rbx), %rsi
callq 0x12e00
leaq 0x28(%rsp), %rdi
callq 0x12620
movq 0x18(%r14), %rax
movl 0x8(%rax), %eax
cmpq $0x3, %rax
jae 0x22d66
leaq 0x1076e(%rip), %rcx     # 0x334b8
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x10770(%rip), %rcx     # 0x334c8
movq (%rcx,%rax,8), %rdx
leaq 0x38(%rsp), %rdi
callq 0x12a70
leaq 0x38(%rsp), %r15
leaq 0x10809(%rip), %rsi     # 0x3357b
movl $0x9, %edx
movq %r15, %rdi
callq 0x12a70
movq 0x18(%r14), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x12eb0
leaq 0x107ef(%rip), %rsi     # 0x33585
movl $0x5, %edx
movq %r15, %rdi
callq 0x12a70
movq 0x18(%r14), %rax
movq 0x18(%rax), %rsi
movq %r15, %rdi
callq 0x12eb0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x12f10
movq 0x8(%rsp), %rdi
incq %rbx
movq %rbx, %rsi
callq 0x13090
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22ded
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x12990
movq 0x180bc(%rip), %rsi     # 0x3aeb0
leaq 0x28(%rsp), %rdi
callq 0x12660
leaq 0xa8(%rsp), %rdi
callq 0x122c0
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22e41
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x12990
jmp 0x22e41
jmp 0x22e3e
movq %rax, %rbx
movq 0x18068(%rip), %rsi     # 0x3aeb0
leaq 0x28(%rsp), %rdi
callq 0x12660
leaq 0xa8(%rsp), %rdi
callq 0x122c0
movq %rbx, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::printOrderBy(std::vector<hsql::OrderDescription*, std::allocator<hsql::OrderDescription*>> const*, unsigned long)
void printOrderBy(const std::vector<OrderDescription*>* expr, uintmax_t num_indent) {
  if (!expr) return;
  for (const auto& order_description : *expr) {
    printExpression(order_description->expr, num_indent);
    if (order_description->type == kOrderAsc) {
      inprint("ascending", num_indent);
    } else {
      inprint("descending", num_indent);
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0x22ec9
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x22ec0
movq %rsi, %rbx
leaq 0x106c5(%rip), %r12     # 0x33550
leaq 0x106c8(%rip), %r13     # 0x3355a
movq (%r14), %rax
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x12800
movq (%r14), %rax
cmpl $0x0, 0x8(%rax)
movq %r13, %rdi
cmoveq %r12, %rdi
movq %rbx, %rsi
callq 0x13090
addq $0x8, %r14
cmpq %r15, %r14
jne 0x22e92
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::operator<<(std::ostream&, hsql::FrameBound const&)
std::ostream& operator<<(std::ostream& os, const FrameBound& frame_bound) {
  if (frame_bound.type == kCurrentRow) {
    os << "CURRENT ROW";
    return os;
  }

  if (frame_bound.unbounded) {
    os << "UNBOUNDED";
  } else {
    os << frame_bound.offset;
  }

  os << " ";

  if (frame_bound.type == kPreceding) {
    os << "PRECEDING";
  } else {
    os << "FOLLOWING";
  }

  return os;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, 0x8(%rsi)
jne 0x22ee5
leaq 0x1086c(%rip), %rsi     # 0x3374a
movl $0xb, %edx
jmp 0x22f3f
movq %rsi, %r14
cmpb $0x1, 0xc(%rsi)
jne 0x22f04
leaq 0x4593(%rip), %rsi      # 0x27488
movl $0x9, %edx
movq %rbx, %rdi
callq 0x12a70
jmp 0x22f0f
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x128b0
leaq 0x105d7(%rip), %rsi     # 0x334ed
movl $0x1, %edx
movq %rbx, %rdi
callq 0x12a70
cmpl $0x1, 0x8(%r14)
jne 0x22f33
leaq 0x456b(%rip), %rsi      # 0x2749c
jmp 0x22f3a
leaq 0x4558(%rip), %rsi      # 0x27492
movl $0x9, %edx
movq %rbx, %rdi
callq 0x12a70
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::printImportStatementInfo(hsql::ImportStatement const*, unsigned long)
void printImportStatementInfo(const ImportStatement* stmt, uintmax_t num_indent) {
  inprint("ImportStatement", num_indent);
  inprint(stmt->filePath, num_indent + 1);
  switch (stmt->type) {
    case ImportType::kImportCSV:
      inprint("CSV", num_indent + 1);
      break;
    case ImportType::kImportTbl:
      inprint("TBL", num_indent + 1);
      break;
    case ImportType::kImportBinary:
      inprint("BINARY", num_indent + 1);
      break;
    case ImportType::kImportAuto:
      inprint("AUTO", num_indent + 1);
      break;
  }
  inprint(stmt->tableName, num_indent + 1);
  if (stmt->whereClause) {
    inprint("WHERE:", num_indent + 1);
    printExpression(stmt->whereClause, num_indent + 2);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1072a(%rip), %rdi     # 0x3368e
callq 0x13090
movq 0x20(%r14), %rdi
leaq 0x1(%rbx), %r15
movq %r15, %rsi
callq 0x13090
movl 0x1c(%r14), %eax
cmpq $0x3, %rax
ja 0x22f96
leaq 0x17cce(%rip), %rcx     # 0x3ac58
movq (%rcx,%rax,8), %rdi
movq %r15, %rsi
callq 0x13090
movq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x13090
cmpq $0x0, 0x38(%r14)
je 0x22fcd
leaq 0x10702(%rip), %rdi     # 0x336b2
movq %r15, %rsi
callq 0x13090
movq 0x38(%r14), %rdi
addq $0x2, %rbx
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x12800
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::printExportStatementInfo(hsql::ExportStatement const*, unsigned long)
void printExportStatementInfo(const ExportStatement* stmt, uintmax_t num_indent) {
  inprint("ExportStatement", num_indent);
  inprint(stmt->filePath, num_indent + 1);
  switch (stmt->type) {
    case ImportType::kImportCSV:
      inprint("CSV", num_indent + 1);
      break;
    case ImportType::kImportTbl:
      inprint("TBL", num_indent + 1);
      break;
    case ImportType::kImportBinary:
      inprint("BINARY", num_indent + 1);
      break;
    case ImportType::kImportAuto:
      inprint("AUTO", num_indent + 1);
      break;
  }

  if (stmt->tableName) {
    inprint(stmt->tableName, num_indent + 1);
  } else {
    printSelectStatementInfo(stmt->select, num_indent + 1);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x106d5(%rip), %rdi     # 0x336b9
callq 0x13090
movq 0x20(%r14), %rdi
incq %rbx
movq %rbx, %rsi
callq 0x13090
movl 0x1c(%r14), %eax
cmpq $0x3, %rax
ja 0x23015
leaq 0x17c4f(%rip), %rcx     # 0x3ac58
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x13090
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x2302d
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13090
movq 0x38(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12540
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::printInsertStatementInfo(hsql::InsertStatement const*, unsigned long)
void printInsertStatementInfo(const InsertStatement* stmt, uintmax_t num_indent) {
  inprint("InsertStatement", num_indent);
  inprint(stmt->tableName, num_indent + 1);
  if (stmt->columns) {
    inprint("Columns", num_indent + 1);
    for (char* col_name : *stmt->columns) {
      inprint(col_name, num_indent + 2);
    }
  }
  switch (stmt->type) {
    case kInsertValues:
      inprint("Values", num_indent + 1);
      for (Expr* expr : *stmt->values) {
        printExpression(expr, num_indent + 2);
      }
      break;
    case kInsertSelect:
      printSelectStatementInfo(stmt->select, num_indent + 1);
      break;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1063c(%rip), %rdi     # 0x336d9
callq 0x13090
movq 0x28(%r14), %rdi
leaq 0x1(%rbx), %r15
movq %r15, %rsi
callq 0x13090
cmpq $0x0, 0x30(%r14)
je 0x230f1
leaq 0x10629(%rip), %rdi     # 0x336e9
movq %r15, %rsi
callq 0x13090
movq 0x30(%r14), %rax
movq (%rax), %r13
movq 0x8(%rax), %rbp
cmpq %rbp, %r13
je 0x230f1
leaq 0x2(%rbx), %r12
movq (%r13), %rdi
movq %r12, %rsi
callq 0x13090
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x230dc
movl 0x1c(%r14), %eax
cmpl $0x1, %eax
je 0x23144
testl %eax, %eax
jne 0x23135
leaq 0x105ec(%rip), %rdi     # 0x336f1
movq %r15, %rsi
callq 0x13090
movq 0x38(%r14), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x23135
addq $0x2, %rbx
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x12800
addq $0x8, %r14
cmpq %r15, %r14
jne 0x23121
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%r14), %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12540
// File: /workspace/github_cpp_makefile_star2_O1/hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::printStatementInfo(hsql::SQLStatement const*)
void printStatementInfo(const SQLStatement* stmt) {
  switch (stmt->type()) {
    case kStmtSelect:
      printSelectStatementInfo((const SelectStatement*)stmt, 0);
      break;
    case kStmtInsert:
      printInsertStatementInfo((const InsertStatement*)stmt, 0);
      break;
    case kStmtCreate:
      printCreateStatementInfo((const CreateStatement*)stmt, 0);
      break;
    case kStmtImport:
      printImportStatementInfo((const ImportStatement*)stmt, 0);
      break;
    case kStmtExport:
      printExportStatementInfo((const ExportStatement*)stmt, 0);
      break;
    case kStmtTransaction:
      printTransactionStatementInfo((const TransactionStatement*)stmt, 0);
      break;
    default:
      break;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x12400
decl %eax
cmpl $0xd, %eax
ja 0x231e7
leaq 0x102b7(%rip), %rcx     # 0x33474
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x12540
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x13030
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x12c80
popq %rbx
retq
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x12cb0
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x12f90
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x124d0