LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2330b
movq %rsi, %r14
leaq 0x12faa(%rip), %rcx     # 0x361ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x131ac(%rip), %rsi     # 0x363fe
jmp 0x23303
leaq 0x70d7(%rip), %rsi      # 0x2a335
jmp 0x23303
leaq 0x6f63(%rip), %rsi      # 0x2a1cd
jmp 0x23303
leaq 0x13354(%rip), %rsi     # 0x365ca
jmp 0x23303
leaq 0x6f58(%rip), %rsi      # 0x2a1da
jmp 0x23303
leaq 0x6f5b(%rip), %rsi      # 0x2a1e6
jmp 0x23303
leaq 0x71ac(%rip), %rsi      # 0x2a440
jmp 0x23303
leaq 0x13169(%rip), %rsi     # 0x36406
jmp 0x232a6
leaq 0x13163(%rip), %rsi     # 0x36409
movq %rbx, %rdi
callq 0x16d00
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x16c30
leaq 0x12dea(%rip), %rsi     # 0x360ab
movq %rax, %rdi
jmp 0x23306
leaq 0x6f59(%rip), %rsi      # 0x2a226
jmp 0x23303
leaq 0x6f0d(%rip), %rsi      # 0x2a1e3
jmp 0x23303
leaq 0x7052(%rip), %rsi      # 0x2a331
jmp 0x23303
leaq 0x70a2(%rip), %rsi      # 0x2a38a
jmp 0x23303
leaq 0x6ee1(%rip), %rsi      # 0x2a1d2
jmp 0x23303
leaq 0x7077(%rip), %rsi      # 0x2a371
jmp 0x23303
leaq 0x6fc6(%rip), %rsi      # 0x2a2c9
movq %rbx, %rdi
callq 0x16d00
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b977(%rip), %rax     # 0x3ef08
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x16f30
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x235e6
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x235ca
movq (%r14), %rdi
testq %rdi, %rdi
je 0x235c4
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x235b1
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x235db
movq %r14, %rdi
callq 0x16920
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x17100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b96d(%rip), %rax     # 0x3efc0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x16f30
movq 0x28(%rbx), %rdi
callq 0x16f30
movq 0x30(%rbx), %rdi
callq 0x16f30
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x23684
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
callq 0x16f30
movq %rbx, %rdi
popq %rbx
jmp 0x17100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b8ad(%rip), %rax     # 0x3efb8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x16f30
movq 0x28(%rbx), %rdi
callq 0x16f30
movq 0x30(%rbx), %rdi
callq 0x16f30
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2373c
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
callq 0x16f30
movq %rbx, %rdi
popq %rbx
jmp 0x17100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b79f(%rip), %rax     # 0x3ef50
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x16f30
movq 0x28(%rbx), %rdi
callq 0x16f30
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x237d9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x23818
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x237fc
movq (%r14), %rdi
callq 0x16f30
addq $0x8, %r14
jmp 0x237e9
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x2380d
movq %r14, %rdi
callq 0x17760
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x2385d
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x23841
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2383b
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x23828
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x23852
movq %r14, %rdi
callq 0x16920
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x17100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b577(%rip), %rax     # 0x3ef40
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x239df
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x23a29
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x23a08
movq (%r14), %rdi
testq %rdi, %rdi
je 0x23a02
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x239ef
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x23a19
movq %rbx, %rdi
callq 0x16920
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x16d50
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1b24f(%rip), %rax     # 0x3ef68
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x23d2f
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x23d3e
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x23d9f
movq (%rax), %r12
movq 0x8(%rax), %r13
pushq $0x10
popq %r14
cmpq %r13, %r12
je 0x23d83
movq (%r12), %r15
movq (%r15), %rdi
callq 0x16f30
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x23d72
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x16d50
addq $0x8, %r12
jmp 0x23d52
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x23d94
movq %r14, %rdi
callq 0x166b0
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x17100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16f30
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x23e22
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x23e01
movq (%r14), %rdi
callq 0x16f30
addq $0x8, %r14
jmp 0x23dee
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x23e12
movq %rbx, %rdi
callq 0x17760
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x16d50
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b0bf(%rip), %rax     # 0x3ef18
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
callq 0x16f30
movq 0x18(%rbx), %rdi
callq 0x16f30
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x23e81
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x23e90
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x23ea1
movq %r14, %rdi
callq 0x171d0
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x23ef6
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x23ed5
movq (%r14), %rdi
testq %rdi, %rdi
je 0x23ecf
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x23ebc
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
je 0x23ee6
movq %rbx, %rdi
callq 0x16550
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x16d50
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b04b(%rip), %rax     # 0x3efa8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x23f73
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x23f82
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x23f91
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x23fd5
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x23fb4
movq (%r14), %rdi
callq 0x16f30
addq $0x8, %r14
jmp 0x23fa1
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0x23fc5
movq %rbx, %rdi
callq 0x17760
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x16d50
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1af93(%rip), %rax     # 0x3efb0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x24033
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x24042
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x2408c
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x2406b
movq (%r14), %rdi
testq %rdi, %rdi
je 0x24065
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x24052
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
je 0x2407c
movq %rbx, %rdi
callq 0x163c0
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x16d50
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x24c45
leaq 0x118b0(%rip), %rcx     # 0x36410
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x17700
cmpq $0x0, 0x10(%r14)
je 0x24c45
leaq 0x1(%rbx), %rsi
leaq 0x1194b(%rip), %rdi     # 0x364d6
callq 0x17700
movq 0x10(%r14), %rdi
leaq 0x2(%rbx), %rsi
callq 0x17700
jmp 0x24c45
leaq 0x11934(%rip), %rdi     # 0x364dd
movq %rbx, %rsi
callq 0x17700
leaq 0x1(%rbx), %r15
leaq 0x1192c(%rip), %rdi     # 0x364e8
movq %r15, %rsi
callq 0x17700
movq 0x38(%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x2(%rbx), %r12
movq %r12, %rsi
callq 0x17120
leaq 0x1190e(%rip), %rdi     # 0x364ed
movq %r15, %rsi
callq 0x17700
movq 0x38(%r14), %rax
movq 0x10(%rax), %rdi
movq %r12, %rsi
callq 0x17120
leaq 0x118f5(%rip), %rdi     # 0x364f3
movq %r15, %rsi
callq 0x17700
movq 0x38(%r14), %rax
movq 0x18(%rax), %rdi
movq %r12, %rsi
callq 0x16b20
jmp 0x24c45
movq 0x30(%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0x24c45
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x17120
addq $0x8, %r15
jmp 0x24c23
movq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x16780
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x24c61
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x16290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x112d3(%rip), %rdi     # 0x36502
callq 0x17700
movq (%r14), %rdi
leaq 0x2(%rbx), %rsi
callq 0x17700
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2526a
movq (%rax), %r14
movq 0x8(%rax), %r15
addq $0x3, %rbx
cmpq %r15, %r14
je 0x2526a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x17700
addq $0x8, %r14
jmp 0x25254
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x252b4
movq %rdi, %r14
addq $0x8c, %rdi
movq %rbx, %rsi
callq 0x174e0
movq 0x10(%r14), %rdi
incq %rbx
movq %rbx, %rsi
callq 0x16b20
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x252c8
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x16b20
leaq 0x1124d(%rip), %rdi     # 0x36508
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17700
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x252ee
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x252ee
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x16b20
addq $0x8, %r14
jmp 0x252d8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4fe8(%rip), %rdi      # 0x2a2f9
callq 0x17700
cmpq $0x0, 0x8(%r14)
je 0x25353
leaq 0x1(%rbx), %rsi
leaq 0x11221(%rip), %rdi     # 0x36549
callq 0x17700
movq 0x8(%r14), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
leaq 0x2(%rbx), %r15
cmpq %r13, %r12
je 0x25353
movq (%r12), %rdi
movq %r15, %rsi
callq 0x16b20
addq $0x8, %r12
jmp 0x2533c
cmpq $0x0, 0x10(%r14)
je 0x25377
leaq 0x1(%rbx), %rsi
leaq 0x111f1(%rip), %rdi     # 0x36556
callq 0x17700
movq 0x10(%r14), %rdi
leaq 0x2(%rbx), %rsi
callq 0x173e0
leaq 0x28(%rsp), %rdi
callq 0x168a0
movq 0x18(%r14), %rax
movl 0x8(%rax), %eax
cmpq $0x3, %rax
jae 0x253a6
leaq 0x11123(%rip), %rcx     # 0x364b8
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x38(%rsp), %rdi
callq 0x16d00
leaq 0x38(%rsp), %rdi
leaq 0x111ad(%rip), %rsi     # 0x3655f
callq 0x16d00
movq %rax, %r15
movq 0x18(%r14), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x174a0
leaq 0x11198(%rip), %rsi     # 0x36569
movq %r15, %rdi
callq 0x16d00
movq 0x18(%r14), %rcx
movq 0x18(%rcx), %rsi
movq %rax, %rdi
callq 0x174a0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x17520
movq 0x8(%rsp), %rdi
incq %rbx
movq %rbx, %rsi
callq 0x17700
leaq 0x8(%rsp), %rdi
callq 0x164d0
leaq 0x28(%rsp), %rdi
callq 0x17a88
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x164d0
jmp 0x25441
jmp 0x2543e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x17a88
movq %rbx, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/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 0x254b2
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
leaq 0x110c2(%rip), %r12     # 0x36534
leaq 0x110c5(%rip), %r13     # 0x3653e
cmpq %r15, %r14
je 0x254a9
movq (%r14), %rax
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x16b20
movq (%r14), %rax
cmpl $0x0, 0x8(%rax)
movq %r13, %rdi
cmoveq %r12, %rdi
movq %rbx, %rsi
callq 0x17700
addq $0x8, %r14
jmp 0x25479
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x254c9
leaq 0x11267(%rip), %rsi     # 0x3672e
jmp 0x25514
movq %rsi, %r14
cmpb $0x1, 0xc(%rsi)
jne 0x254e3
leaq 0x4faf(%rip), %rsi      # 0x2a488
movq %rbx, %rdi
callq 0x16d00
jmp 0x254ee
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x16c30
leaq 0x10fdc(%rip), %rsi     # 0x364d1
movq %rbx, %rdi
callq 0x16d00
cmpl $0x1, 0x8(%r14)
leaq 0x4f93(%rip), %rax      # 0x2a49c
leaq 0x4f82(%rip), %rsi      # 0x2a492
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x16d00
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11139(%rip), %rdi     # 0x36672
callq 0x17700
movq 0x20(%r14), %rdi
leaq 0x1(%rbx), %r15
movq %r15, %rsi
callq 0x17700
movl 0x1c(%r14), %eax
cmpq $0x3, %rax
ja 0x2556b
leaq 0x196f9(%rip), %rcx     # 0x3ec58
movq (%rcx,%rax,8), %rdi
movq %r15, %rsi
callq 0x17700
movq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x17700
cmpq $0x0, 0x38(%r14)
je 0x255a2
leaq 0x11111(%rip), %rdi     # 0x36696
movq %r15, %rsi
callq 0x17700
movq 0x38(%r14), %rdi
addq $0x2, %rbx
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x16b20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x110e4(%rip), %rdi     # 0x3669d
callq 0x17700
movq 0x20(%r14), %rdi
incq %rbx
movq %rbx, %rsi
callq 0x17700
movl 0x1c(%r14), %eax
cmpq $0x3, %rax
ja 0x255ea
leaq 0x1967a(%rip), %rcx     # 0x3ec58
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x17700
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x25602
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17700
movq 0x38(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16780
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1104b(%rip), %rdi     # 0x366bd
callq 0x17700
movq 0x28(%r14), %rdi
leaq 0x1(%rbx), %r15
movq %r15, %rsi
callq 0x17700
cmpq $0x0, 0x30(%r14)
je 0x256c3
leaq 0x11038(%rip), %rdi     # 0x366cd
movq %r15, %rsi
callq 0x17700
movq 0x30(%r14), %rax
movq (%rax), %r13
movq 0x8(%rax), %rbp
leaq 0x2(%rbx), %r12
cmpq %rbp, %r13
je 0x256c3
movq (%r13), %rdi
movq %r12, %rsi
callq 0x17700
addq $0x8, %r13
jmp 0x256ac
movl 0x1c(%r14), %eax
cmpl $0x1, %eax
je 0x25713
testl %eax, %eax
jne 0x25704
leaq 0x10ffe(%rip), %rdi     # 0x366d5
movq %r15, %rsi
callq 0x17700
movq 0x38(%r14), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
addq $0x2, %rbx
cmpq %r15, %r14
je 0x25704
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x16b20
addq $0x8, %r14
jmp 0x256ee
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 0x16780
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16590
decl %eax
cmpl $0xd, %eax
ja 0x257b6
leaq 0x10cd8(%rip), %rcx     # 0x36464
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x16780
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x17680
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x171c0
popq %rbx
retq
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x17200
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x175c0
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x166c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/aes_abstract.cpp
// Function: aes_abstract::AddRoundKey()
void aes_abstract::AddRoundKey() {
    //表示第current_round轮的密钥轮加，从0开始
    for (int k = 0; k < 4; k++) {
        uint32 current_key = round_key[4 * current_round + k];
        state[0][k] = state[0][k] ^ (uint8)(current_key >> 24);
        state[1][k] = state[1][k] ^ (uint8)((current_key & 0x00ff0000) >> 16);
        state[2][k] = state[2][k] ^ (uint8)((current_key & 0x0000ff00) >> 8);
        state[3][k] = state[3][k] ^ (uint8)(current_key);
    }
    current_round++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl 0xc0(%rdi), %ecx
cmpq $0x4, %rax
je 0x135b
leal (%rax,%rcx,4), %ecx
movslq %ecx, %rcx
movl 0x10(%rdi,%rcx,4), %ecx
movl %ecx, %edx
shrl $0x18, %edx
xorb %dl, (%rdi,%rax)
movl %ecx, %edx
shrl $0x10, %edx
xorb %dl, 0x4(%rdi,%rax)
movl %ecx, %edx
shrl $0x8, %edx
xorb %dl, 0x8(%rdi,%rax)
xorb %cl, 0xc(%rdi,%rax)
incq %rax
jmp 0x1322
incl %ecx
movl %ecx, 0xc0(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/aes_abstract.cpp
// Function: aes_abstract::MixColumns()
void aes_abstract::MixColumns() {
    uint8 new_state[4][4];
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            uint8 n = 0;
            for (int k = 0; k < 4; k++) {
                n ^= FieldMul(mix_column_matrix[i][k], state[k][j]);
            }
            new_state[i][j] = n;
        }
    }

    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            state[i][j] = new_state[i][j];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x4df2(%rip), %r14      # 0x61d0
xorl %eax, %eax
movq %rdi, -0x30(%rbp)
cmpq $0x4, %rax
je 0x144d
movq %rax, -0x38(%rbp)
leaq -0x50(,%rax,4), %rax
addq %rbp, %rax
movq %rax, -0x40(%rbp)
movq %rdi, %r13
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x143c
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpq $0x4, %rbx
je 0x142c
movzbl (%r14,%rbx), %esi
movzbl (%r13,%rbx,4), %edx
callq 0x148a
xorb %al, %r12b
incq %rbx
jmp 0x140e
movq -0x40(%rbp), %rax
movb %r12b, (%r15,%rax)
incq %r15
incq %r13
jmp 0x1403
movq -0x38(%rbp), %rax
incq %rax
addq $0x4, %r14
movq -0x30(%rbp), %rdi
jmp 0x13e4
leaq -0x50(%rbp), %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x147b
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x146e
movb (%rax,%rdx), %sil
movb %sil, (%rdi,%rdx)
incq %rdx
jmp 0x145b
incq %rcx
addq $0x4, %rax
addq $0x4, %rdi
jmp 0x1453
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/aes_abstract.cpp
// Function: aes_abstract::FieldMul(unsigned char, unsigned char)
uint8 aes_abstract::FieldMul(uint8 a, uint8 b) {
    // 有限域上两者相乘，计算乘积，a为被乘数，b为乘数
    uint8 result = 0;
    uint8 most_significant_bit = 0;
    for (int i = 0; i < 8; i++) {
        if (b & 0x01) {
            result = result ^ a;
        }
        most_significant_bit = 0x80 & a;
        a = a << 1;
        if (most_significant_bit != 0) {
            a = a ^ 0x1b;
        }
        b = b >> 1;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x8, %ecx
xorl %eax, %eax
subl $0x1, %ecx
jb 0x14c3
movl %edx, %edi
andb $0x1, %dil
negb %dil
andb %sil, %dil
xorb %dil, %al
leal (%rsi,%rsi), %edi
movzbl %dil, %r8d
xorb $0x1b, %dil
testb %sil, %sil
movzbl %dil, %esi
cmovnsl %r8d, %esi
shrb %dl
jmp 0x1495
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/aes_abstract.cpp
// Function: aes_abstract::KeyExpansion(unsigned int*)
void aes_abstract::KeyExpansion(uint32 initial_key[4]) {
    // 将初始的密钥分为四个字，密钥拓展为44个字
    int i;
    for (i = 0; i <= 3; i++) {
        this->round_key[i] = initial_key[i];
    }

    for (; i <= 43; i++) {
        uint32 temp = round_key[i - 1];
        if (i % 4 == 0) {
            temp = SubWord(RotWord(temp)) ^ r_cont[i / 4 - 1];
        }
        this->round_key[i] = this->round_key[i - 4] ^ temp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x4, %rax
je 0x14f2
movl (%rsi,%rax,4), %ecx
movl %ecx, 0x10(%rbx,%rax,4)
incq %rax
jmp 0x14e0
pushq $0x8
popq %r14
leaq 0x4df3(%rip), %r15      # 0x62f0
cmpq $0x30, %r14
je 0x1535
movl -0x4(%rbx,%r14,4), %eax
leaq -0x4(%r14), %r12
testb $0x3, %r12b
jne 0x1527
roll $0x8, %eax
movl %eax, %esi
callq 0x153e
shrl $0x2, %r12d
decl %r12d
xorl (%r15,%r12,4), %eax
xorl -0x10(%rbx,%r14,4), %eax
movl %eax, (%rbx,%r14,4)
incq %r14
jmp 0x14fd
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/aes_abstract.cpp
// Function: aes_abstract::SubWord(unsigned int)
uint32 aes_abstract::SubWord(uint32 w) {
    uint8* byte_array = (uint8*)&w;
    for (int i = 0; i < 4; i++) {
        uint8 one_char = byte_array[i];
        byte_array[i] = SubByte(byte_array[i]);
    }
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, -0x4(%rbp)
xorl %eax, %eax
leaq 0x4b82(%rip), %rcx      # 0x60d0
cmpq $0x4, %rax
je 0x1570
movzbl -0x4(%rbp,%rax), %edx
movl %edx, %esi
andl $0xf, %esi
andl $-0x10, %edx
addq %rcx, %rdx
movb (%rsi,%rdx), %dl
movb %dl, -0x4(%rbp,%rax)
incq %rax
jmp 0x154e
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/aes_abstract.cpp
// Function: aes_abstract::generate_roundkey(unsigned char*)
void aes_abstract::generate_roundkey(uint8 initial_key_byte[16]) {
    uint32 initial_key_word[4];
    for (int i = 0; i < 4; i++) {
        initial_key_word[i] = bytes_to_word(&initial_key_byte[4 * i]);
    }

    KeyExpansion(initial_key_word);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq $0x10, %r15
je 0x15b2
leaq (%r14,%r15), %rsi
callq 0x14c6
movl %eax, -0x30(%rbp,%r15)
addq $0x4, %r15
jmp 0x1598
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x14d0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/aes_abstract.cpp
// Function: aes_abstract::print_state()
void aes_abstract::print_state(){
    printf("The current state:\n");
    for(int i = 0;i < 4;i++){
        for(int j = 0;j < 4;j++){
            printf("%x ", state[i][j]);
        }
        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1972(%rip), %rdi      # 0x3020
callq 0x1120
pushq $0xa
popq %r14
leaq 0x195e(%rip), %r15      # 0x301c
xorl %r12d, %r12d
cmpq $0x4, %r12
je 0x16f5
xorl %r13d, %r13d
cmpq $0x4, %r13
je 0x16e4
movzbl (%rbx,%r13), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1040
incq %r13
jmp 0x16ca
movl %r14d, %edi
callq 0x1100
incq %r12
addq $0x4, %rbx
jmp 0x16c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/decryptor.cpp
// Function: aes_decryptor::ShiftRows()
void aes_decryptor::ShiftRows() {
    int temp = state[1][3];
    for (int i = 3; i >= 1; i--) {
        state[1][i] = state[1][i - 1];
    }
    state[1][0] = temp;

    temp = state[2][0];
    int temp2 = state[2][1];
    for (int i = 2; i < 4; i++) {
        state[2][i - 2] = state[2][i];
    }
    state[2][2] = temp;
    state[2][3] = temp2;
    ;

    //右移三位等于左移一位
    temp = state[3][0];
    for (int i = 0; i <= 2; i++) {
        state[3][i] = state[3][i + 1];
    }
    state[3][3] = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x7(%rdi), %al
movabsq $0x7, %rcx
cmpq $0x4, %rcx
je 0x1727
movb -0x1(%rdi,%rcx), %dl
movb %dl, (%rdi,%rcx)
decq %rcx
jmp 0x1715
movb %al, 0x4(%rdi)
roll $0x10, 0x8(%rdi)
movb 0xc(%rdi), %al
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x1746
movb 0xd(%rdi,%rcx), %dl
movb %dl, 0xc(%rdi,%rcx)
incq %rcx
jmp 0x1733
movb %al, 0xf(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/decryptor.cpp
// Function: aes_decryptor::reverse_round_key()
void aes_decryptor::reverse_round_key() {
    int i = 0, j = 10;
    uint32 temp;
    while (i < j) {
        for(int k = 0;k < 4;k++){
            swap(round_key[4*i + k], round_key[4*j + k]);
        }
        i++;
        j--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rdi), %rax
addq $0xb0, %rdi
xorl %ecx, %ecx
cmpq $0x5, %rcx
je 0x1923
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x1916
movl (%rax,%rdx,4), %esi
movl (%rdi,%rdx,4), %r8d
movl %r8d, (%rax,%rdx,4)
movl %esi, (%rdi,%rdx,4)
incq %rdx
jmp 0x18fd
incq %rcx
addq $-0x10, %rdi
addq $0x10, %rax
jmp 0x18f5
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/decryptor.cpp
// Function: aes_decryptor::decrypt_one_group(unsigned char*)
void aes_decryptor::decrypt_one_group(uint8 cipher[16]) {
    current_round = 0;
    for (int i = 0; i < 16; i++) {
        state[i % 4][i / 4] = cipher[i];
    }

    AddRoundKey();
    for (int i = 1; i < NROUND; i++) {
        ShiftRows();
        SubBytes();
        AddRoundKey();
        MixColumns();
    }

    ShiftRows();
    SubBytes();
    AddRoundKey();

    for (int i = 0; i < 16; i++) {
        cipher[i] = state[i % 4][i / 4];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, 0xc0(%rdi)
xorl %eax, %eax
cmpq $0x10, %rax
je 0x195e
movb (%rbx,%rax), %cl
movl %eax, %edx
andl $0x3, %edx
movl %eax, %esi
shrl $0x2, %esi
leaq (%r14,%rdx,4), %rdx
movb %cl, (%rsi,%rdx)
incq %rax
jmp 0x193f
movq %r14, %rdi
callq 0x131c
pushq $0x9
popq %r15
movq %r14, %rdi
callq 0x1704
movq %r14, %rdi
callq 0x1a12
movq %r14, %rdi
callq 0x131c
subl $0x1, %r15d
jb 0x1992
movq %r14, %rdi
callq 0x1a56
jmp 0x196a
xorl %eax, %eax
cmpq $0x10, %rax
je 0x19b3
movl %eax, %ecx
andl $0x3, %ecx
movl %eax, %edx
shrl $0x2, %edx
leaq (%r14,%rcx,4), %rcx
movb (%rdx,%rcx), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x1994
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/decryptor.cpp
// Function: aes_decryptor::splice(unsigned char*, unsigned char*)
void aes_decryptor::splice(uint8* p_text_array, uint8 group[16]){
    static int cursor = 0;
    for(int i = 0;i < 16;i++){
        p_text_array[cursor] = group[i];
        cursor++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x495b(%rip), %rcx      # 0x6324
movl %ecx, %eax
addq %rcx, %rsi
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x19e3
movb (%rdx,%rcx), %dil
movb %dil, (%rsi,%rcx)
incq %rcx
jmp 0x19d0
addl %ecx, %eax
movl %eax, 0x4939(%rip)      # 0x6324
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/decryptor.cpp
// Function: aes_decryptor::MixColumns()
void aes_decryptor::MixColumns() {
    uint8 new_state[4][4];
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            uint8 n = 0;
            for (int k = 0; k < 4; k++) {
                n ^= FieldMul(mix_column_matrix_inv[i][k], state[k][j]);
            }
            new_state[i][j] = n;
        }
    }

    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            state[i][j] = new_state[i][j];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x486f(%rip), %r14      # 0x62e0
xorl %eax, %eax
cmpq $0x4, %rax
je 0x1ae6
movq %rax, -0x30(%rbp)
leaq -0x50(,%rax,4), %rax
addq %rbp, %rax
movq %rax, -0x38(%rbp)
movq %rbx, %r13
xorl %eax, %eax
cmpq $0x4, %rax
je 0x1ad9
movq %rax, -0x40(%rbp)
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpq $0x4, %r12
je 0x1ac2
movzbl (%r14,%r12), %esi
movzbl (%r13,%r12,4), %edx
movq %rbx, %rdi
callq 0x148a
xorb %al, %r15b
incq %r12
jmp 0x1aa1
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movb %r15b, (%rcx,%rax)
movq %rcx, %rax
incq %rax
incq %r13
jmp 0x1a91
movq -0x30(%rbp), %rax
incq %rax
addq $0x4, %r14
jmp 0x1a73
leaq -0x50(%rbp), %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x1b14
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x1b07
movb (%rax,%rdx), %sil
movb %sil, (%rbx,%rdx)
incq %rdx
jmp 0x1af4
incq %rcx
addq $0x4, %rax
addq $0x4, %rbx
jmp 0x1aec
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/encryptor.cpp
// Function: aes_encryptor::padding(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string aes_encryptor::padding(string s) {
    char padding[17];
    int pad_size;
    if (s.size() % 16 == 0) {
        pad_size = 16;
    }
    else{
        pad_size = 16 - (s.size() - (s.size() / 16) * 16);
    }

    for(int i = 0;i < pad_size;i++){
        padding[i] = pad_size;
    }
    padding[pad_size] = '\0';

    return s + padding;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdx), %rcx
movl %ecx, %esi
andl $0xf, %esi
pushq $0x10
popq %rdi
movl %edi, %eax
subl %esi, %eax
testb $0xf, %cl
cmovel %edi, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1f9c
movb %al, -0x20(%rbp,%rcx)
incq %rcx
jmp 0x1f8e
movb $0x0, -0x20(%rbp,%rax)
leaq -0x20(%rbp), %rax
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x21c1
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/encryptor.cpp
// Function: aes_encryptor::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<vector<uint8>> aes_encryptor::split(string s){
    int group_number = s.size() / 16;
    vector<vector<uint8>> ret;
    for(int i = 0;i < group_number;i++){
        vector<uint8> one_group;
        for(int j = 0;j < 16;j++){
            one_group.push_back(s[i * 16 + j]);
        }
        ret.push_back(one_group);
        one_group.clear();
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq 0x8(%rdx), %rax
shrq $0x4, %rax
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, -0x38(%rbp)
movups %xmm0, (%rdi)
xorl %ebx, %ebx
testl %eax, %eax
cmovlel %ebx, %eax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %r15
leaq -0x29(%rbp), %r12
cmpq -0x58(%rbp), %rbx
je 0x2067
movq %rbx, -0x60(%rbp)
shll $0x4, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x203c
movq (%r14), %rax
addq %rbx, %rax
movb (%r13,%rax), %al
movb %al, -0x29(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2590
incq %r13
jmp 0x2018
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x215a
movq -0x50(%rbp), %rax
cmpq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rbx
je 0x205a
movq %rax, -0x48(%rbp)
movq %r15, %rdi
callq 0x1b9e
incq %rbx
jmp 0x1ffc
movq -0x38(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x207c
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x1b9e
movq -0x38(%rbp), %rdi
callq 0x2196
movq %r14, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O2/SimpleButNotNaive[P]AES/encryptor.cpp
// Function: aes_encryptor::encrypt_one_group(unsigned char*)
void aes_encryptor::encrypt_one_group(uint8 p_text[16]) {
    current_round = 0;
    for (int i = 0; i < 16; i++) {
        state[i % 4][i / 4] = p_text[i];
    }
    AddRoundKey();

    for (int round = 1; round < NROUND; round++) {
        SubBytes();
        ShiftRows();
        MixColumns();
        AddRoundKey();
    }

    SubBytes();
    ShiftRows();
    AddRoundKey();

    for(int i = 0;i < 16;i++){
        p_text[i] = state[i % 4][i / 4];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, 0xc0(%rdi)
xorl %eax, %eax
cmpq $0x10, %rax
je 0x20d2
movb (%rbx,%rax), %cl
movl %eax, %edx
andl $0x3, %edx
movl %eax, %esi
shrl $0x2, %esi
leaq (%r14,%rdx,4), %rdx
movb %cl, (%rsi,%rdx)
incq %rax
jmp 0x20b3
movq %r14, %rdi
callq 0x131c
pushq $0x9
popq %r15
movq %r14, %rdi
callq 0x1366
movq %r14, %rdi
callq 0x1cc4
movq %r14, %rdi
subl $0x1, %r15d
jb 0x2106
callq 0x13c6
movq %r14, %rdi
callq 0x131c
jmp 0x20de
callq 0x131c
xorl %eax, %eax
cmpq $0x10, %rax
je 0x212c
movl %eax, %ecx
andl $0x3, %ecx
movl %eax, %edx
shrl $0x2, %edx
leaq (%r14,%rcx,4), %rcx
movb (%rdx,%rcx), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x210d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/JameyWoo[P]csmile/main.cpp
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 2) {  // 判断参数, 给出用法提示
        cout << "Usage:" << endl;
        cout << "./main <file_name>" << endl;
        return 0;
    }
    read.open(string(argv[1]), ios::in);
    readin();
    scanning = true;
    bool printParse = true;
    TreeNode* root = parse(printParse);
    buildSymtab(root);
    typeCheck(root);
    codeGen(root);  // 目前只传递根节点进去, 暂时不写入文件
    genAssembly(root);  // 生成汇编代码
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpl $0x2, %edi
jne 0x2e94
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2efc
leaq 0x133dd(%rip), %rdi     # 0x16220
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x2180
leaq 0x10(%rsp), %rdi
callq 0x2358
callq 0x2fd0
leaq 0x1335c(%rip), %rax     # 0x161c0
movb $0x1, (%rax)
pushq $0x1
popq %rdi
callq 0x6fa2
movq %rax, %rbx
movq %rax, %rdi
callq 0x71e0
movq %rbx, %rdi
callq 0x76f7
movq %rbx, %rdi
callq 0xa3c7
movq %rbx, %rdi
callq 0xccea
jmp 0x2ec9
movq 0x1312d(%rip), %rbx     # 0x15fc8
leaq 0xc162(%rip), %rsi      # 0xf004
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
leaq 0xc152(%rip), %rsi      # 0xf00b
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2358
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/JameyWoo[P]csmile/scan.cpp
// Function: getNextChar(int&)
char getNextChar(int &line) {  // 获取下一个字符
    if (position >= cur_str.size()) {
        cur_str = words[++word_cnt];
        if (cur_str == "EOF") {
            scanning = false;
            return EOF;
        }
        cur_str += ' ';  // 默认加一个空格. 因为如果独立两行都没有空格的话, 会被合并
        position = 0;
    }
    position += 1;
    line = word_cnt;
    return cur_str[position - 1];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x13414(%rip), %rax     # 0x164b0
cmpq 0x133dd(%rip), %rax     # 0x16480
jb 0x30fe
movslq 0x13118(%rip), %rsi     # 0x161c4
incq %rsi
movl %esi, 0x1310f(%rip)     # 0x161c4
shlq $0x5, %rsi
addq 0x133d8(%rip), %rsi     # 0x16498
leaq 0x133b1(%rip), %r14     # 0x16478
movq %r14, %rdi
callq 0x2110
leaq 0xc0c9(%rip), %rsi      # 0xf19f
movq %r14, %rdi
callq 0x368e
testb %al, %al
je 0x30ed
movb $0x0, 0x130d7(%rip)     # 0x161c0
movb $-0x1, %al
jmp 0x311b
leaq 0x13384(%rip), %rdi     # 0x16478
pushq $0x20
popq %rsi
callq 0x2170
xorl %eax, %eax
leaq 0x1(%rax), %rcx
movq %rcx, 0x133a7(%rip)     # 0x164b0
movl 0x130b5(%rip), %ecx     # 0x161c4
movl %ecx, (%rbx)
movq 0x13360(%rip), %rcx     # 0x16478
movb (%rcx,%rax), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq