LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rsi
addq $0x1, %rsi
leaq 0x140f4(%rip), %rdi     # 0x7e852
callq 0x39830
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
addq $0x2, %rsi
callq 0x39830
movq 0x30(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6a7f9
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x37d80
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x399b0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x392c0
testb $0x1, %al
jne 0x6a7c6
jmp 0x6a7f7
leaq 0x18(%rsp), %rdi
callq 0x38ff0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x3, %rsi
callq 0x39830
leaq 0x18(%rsp), %rdi
callq 0x36eb0
jmp 0x6a7b1
jmp 0x6a7f9
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x6a82c
movq 0x28(%rsp), %rsi
leaq 0x14036(%rip), %rdi     # 0x7e858
callq 0x39830
jmp 0x6a903
movq 0x30(%rsp), %rdi
addq $0x8c, %rdi
movq 0x28(%rsp), %rsi
callq 0x39210
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
addq $0x1, %rsi
callq 0x37340
movq 0x30(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6a881
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rsi
addq $0x1, %rsi
callq 0x37340
jmp 0x6a903
movq 0x30(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6a901
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x36b30
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x38740
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x39fa0
testb $0x1, %al
jne 0x6a8ce
jmp 0x6a8ff
leaq 0x18(%rsp), %rdi
callq 0x37b30
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x1, %rsi
callq 0x37340
leaq 0x18(%rsp), %rdi
callq 0x36f80
jmp 0x6a8b9
jmp 0x6a901
jmp 0x6a903
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x6abdb
jmp 0x6ac7d
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x39560
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x357f0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x35bc0
testb $0x1, %al
jne 0x6ac18
jmp 0x6ac7d
leaq 0x18(%rsp), %rdi
callq 0x36dc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x37340
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0x6ac5e
movq 0x28(%rsp), %rsi
leaq 0x13c2d(%rip), %rdi     # 0x7e884
callq 0x39830
jmp 0x6ac6f
movq 0x28(%rsp), %rsi
leaq 0x13c24(%rip), %rdi     # 0x7e88e
callq 0x39830
jmp 0x6ac71
leaq 0x18(%rsp), %rdi
callq 0x36e10
jmp 0x6ac03
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x6acc4
movq 0x8(%rsp), %rdi
leaq 0x13dcb(%rip), %rsi     # 0x7ea7e
callq 0x377a0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x6ad3b
movq (%rsp), %rax
testb $0x1, 0xc(%rax)
je 0x6ace1
movq 0x8(%rsp), %rdi
leaq 0x7b0e(%rip), %rsi      # 0x727e8
callq 0x377a0
jmp 0x6acf2
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0x39cc0
movq 0x8(%rsp), %rdi
leaq 0x13b23(%rip), %rsi     # 0x7e821
callq 0x377a0
movq (%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x6ad20
movq 0x8(%rsp), %rdi
leaq 0x7ae3(%rip), %rsi      # 0x727fc
callq 0x377a0
jmp 0x6ad31
movq 0x8(%rsp), %rdi
leaq 0x7ac6(%rip), %rsi      # 0x727f2
callq 0x377a0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x13c58(%rip), %rdi     # 0x7e9c2
callq 0x39830
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
incq %rsi
callq 0x39830
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x6ae05
movq (%rsp), %rax
leaq 0x13a26(%rip), %rcx     # 0x7e7c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13c17(%rip), %rdi     # 0x7e9d2
callq 0x39830
jmp 0x6ae05
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13c04(%rip), %rdi     # 0x7e9d6
callq 0x39830
jmp 0x6ae05
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13bf1(%rip), %rdi     # 0x7e9da
callq 0x39830
jmp 0x6ae05
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13be1(%rip), %rdi     # 0x7e9e1
callq 0x39830
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
callq 0x39830
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x6ae54
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13bae(%rip), %rdi     # 0x7e9e6
callq 0x39830
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x2, %rsi
callq 0x37340
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x13b73(%rip), %rdi     # 0x7e9ed
callq 0x39830
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
incq %rsi
callq 0x39830
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x6af15
movq (%rsp), %rax
leaq 0x13926(%rip), %rcx     # 0x7e7d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13b07(%rip), %rdi     # 0x7e9d2
callq 0x39830
jmp 0x6af15
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13af4(%rip), %rdi     # 0x7e9d6
callq 0x39830
jmp 0x6af15
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13ae1(%rip), %rdi     # 0x7e9da
callq 0x39830
jmp 0x6af15
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13ad1(%rip), %rdi     # 0x7e9e1
callq 0x39830
movq 0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x6af3a
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
callq 0x39830
jmp 0x6af51
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
callq 0x36610
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x13a33(%rip), %rdi     # 0x7ea0d
callq 0x39830
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x48(%rsp), %rsi
addq $0x1, %rsi
callq 0x39830
movq 0x50(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x6b08f
movq 0x48(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13a07(%rip), %rdi     # 0x7ea1d
callq 0x39830
movq 0x50(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x37d80
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x399b0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x392c0
testb $0x1, %al
jne 0x6b05c
jmp 0x6b08d
leaq 0x38(%rsp), %rdi
callq 0x38ff0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
addq $0x2, %rsi
callq 0x39830
leaq 0x38(%rsp), %rdi
callq 0x36eb0
jmp 0x6b047
jmp 0x6b08f
movq 0x50(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x6b0b3
jmp 0x6b0a1
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x6b13c
jmp 0x6b153
movq 0x48(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13962(%rip), %rdi     # 0x7ea25
callq 0x39830
movq 0x50(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x36b30
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x38740
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x39fa0
testb $0x1, %al
jne 0x6b109
jmp 0x6b13a
leaq 0x18(%rsp), %rdi
callq 0x37b30
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
addq $0x2, %rsi
callq 0x37340
leaq 0x18(%rsp), %rdi
callq 0x36f80
jmp 0x6b0f4
jmp 0x6b153
movq 0x50(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x48(%rsp), %rsi
addq $0x1, %rsi
callq 0x36610
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: hyrise[P]sql-parser/src/util/sqlhelper.cpp
// Function: hsql::printTransactionStatementInfo(hsql::TransactionStatement const*, unsigned long)
void printTransactionStatementInfo(const TransactionStatement* stmt, uintmax_t num_indent) {
  inprint("TransactionStatement", num_indent);
  switch (stmt->command) {
    case kBeginTransaction:
      inprint("BEGIN", num_indent + 1);
      break;
    case kCommitTransaction:
      inprint("COMMIT", num_indent + 1);
      break;
    case kRollbackTransaction:
      inprint("ROLLBACK", num_indent + 1);
      break;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x138b2(%rip), %rdi     # 0x7ea2c
callq 0x39830
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x6b1a7
jmp 0x6b191
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x6b1be
jmp 0x6b19c
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x6b1d5
jmp 0x6b1ea
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x75fd(%rip), %rdi      # 0x727b4
callq 0x39830
jmp 0x6b1ea
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x75ec(%rip), %rdi      # 0x727ba
callq 0x39830
jmp 0x6b1ea
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x75dc(%rip), %rdi      # 0x727c1
callq 0x39830
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x36140
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0xd, %eax
ja 0x6b286
movq 0x8(%rsp), %rax
leaq 0x135cb(%rip), %rcx     # 0x7e7e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36610
jmp 0x6b288
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39660
jmp 0x6b288
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x394d0
jmp 0x6b288
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x38990
jmp 0x6b288
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x36450
jmp 0x6b288
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x388e0
jmp 0x6b288
jmp 0x6b288
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x2598
movq -0x18(%rbp), %rax
movl 0xc0(%rax), %ecx
shll $0x2, %ecx
addl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movl 0x10(%rax,%rcx,4), %ecx
movl %ecx, -0x10(%rbp)
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movl -0x10(%rbp), %edx
shrl $0x18, %edx
movzbl %dl, %edx
xorl %edx, %ecx
movb %cl, %dl
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movslq -0xc(%rbp), %rcx
movzbl 0x4(%rax,%rcx), %ecx
movl -0x10(%rbp), %edx
andl $0xff0000, %edx         # imm = 0xFF0000
shrl $0x10, %edx
movzbl %dl, %edx
xorl %edx, %ecx
movb %cl, %dl
movslq -0xc(%rbp), %rcx
movb %dl, 0x4(%rax,%rcx)
movslq -0xc(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %ecx
movl -0x10(%rbp), %edx
andl $0xff00, %edx           # imm = 0xFF00
shrl $0x8, %edx
movzbl %dl, %edx
xorl %edx, %ecx
movb %cl, %dl
movslq -0xc(%rbp), %rcx
movb %dl, 0x8(%rax,%rcx)
movslq -0xc(%rbp), %rcx
movzbl 0xc(%rax,%rcx), %ecx
movl -0x10(%rbp), %edx
movzbl %dl, %edx
xorl %edx, %ecx
movb %cl, %dl
movslq -0xc(%rbp), %rcx
movb %dl, 0xc(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x24e7
movq -0x18(%rbp), %rax
movl 0xc0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc0(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x2760
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x2750
movb $0x0, -0x29(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jge 0x2729
movq -0x40(%rbp), %rdi
movslq -0x24(%rbp), %rcx
leaq 0x9b4a(%rip), %rax      # 0xc230
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movslq -0x30(%rbp), %rcx
shlq $0x2, %rcx
movq %rdi, %rax
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movzbl %dl, %esi
movzbl (%rax,%rcx), %edx
callq 0x27d0
movzbl %al, %ecx
movzbl -0x29(%rbp), %eax
xorl %ecx, %eax
movb %al, -0x29(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x26d1
movb -0x29(%rbp), %dl
movslq -0x24(%rbp), %rcx
leaq -0x20(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x26bc
jmp 0x2752
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x26ab
movl $0x0, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
jge 0x27be
movl $0x0, -0x38(%rbp)
cmpl $0x4, -0x38(%rbp)
jge 0x27b1
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rdx
leaq -0x20(%rbp), %rcx
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0x38(%rbp), %rdx
movb (%rcx,%rdx), %dl
movslq -0x34(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2774
jmp 0x27b3
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2767
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movb $0x0, -0xb(%rbp)
movb $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x284d
movzbl -0xa(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2811
movzbl -0xb(%rbp), %eax
movzbl -0x9(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0xb(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x80, %eax
movb %al, -0xc(%rbp)
movzbl -0x9(%rbp), %eax
shll %eax
movb %al, -0x9(%rbp)
movzbl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x2839
movzbl -0x9(%rbp), %eax
xorl $0x1b, %eax
movb %al, -0x9(%rbp)
movzbl -0xa(%rbp), %eax
sarl %eax
movb %al, -0xa(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x27f2
movb -0xb(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SimpleButNotNaive[P]AES/aes_abstract.cpp
// Function: aes_abstract::bytes_to_word(unsigned char*)
uint32 aes_abstract::bytes_to_word(uint8* bytes) {
    //将一个bytes数组的四个字节合成一个字
    uint32 number = 0;
    number = number | bytes[0];
    number = (number << 8) | bytes[1];
    number = (number << 8) | bytes[2];
    number = (number << 8) | bytes[3];
    return number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jg 0x2907
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movslq -0x14(%rbp), %rcx
movl %edx, 0x10(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x28df
jmp 0x2909
cmpl $0x2b, -0x14(%rbp)
jg 0x299e
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl 0x10(%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x2974
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2a20
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x29b0
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
subl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x99e2(%rip), %rcx      # 0xc350
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x4, %ecx
movslq %ecx, %rcx
movl 0x10(%rax,%rcx,4), %edx
xorl -0x18(%rbp), %edx
movslq -0x14(%rbp), %rcx
movl %edx, 0x10(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2909
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x2a17
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x2640
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x29d6
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: SimpleButNotNaive[P]AES/aes_abstract.cpp
// Function: aes_abstract::RotWord(unsigned int)
uint32 aes_abstract::RotWord(uint32 w) {
    // (B1, B2, B3, B4) --> (B2, B3, B4, B1)
    uint32 right = (w & 0xff000000) >> 24;
    // right为字的第一个byte，循环移位到最右边
    uint32 left = w << 8;
    return left | right;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
shrl $0x18, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
orl -0x10(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x2aa2
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %eax
shll $0x2, %eax
cltq
addq %rax, %rsi
callq 0x2860
movl %eax, %ecx
movslq -0x24(%rbp), %rax
movl %ecx, -0x20(%rbp,%rax,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2a6f
movq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x28c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x53b1(%rip), %rdi      # 0x801c
movb $0x0, %al
callq 0x2040
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x2cd5
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x2cbc
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x5386(%rip), %rdi      # 0x8030
movb $0x0, %al
callq 0x2040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2c86
leaq 0x536b(%rip), %rdi      # 0x802e
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2c79
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movzbl 0x7(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x3, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jl 0x2d28
movq -0x28(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb 0x4(%rax,%rcx), %dl
movslq -0x10(%rbp), %rcx
movb %dl, 0x4(%rax,%rcx)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2cfe
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movb %cl, 0x4(%rax)
movzbl 0x8(%rax), %ecx
movl %ecx, -0xc(%rbp)
movzbl 0x9(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x2, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x2d71
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb 0x8(%rax,%rcx), %dl
movl -0x18(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, 0x8(%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2d47
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movb %cl, 0xa(%rax)
movl -0x14(%rbp), %ecx
movb %cl, 0xb(%rax)
movzbl 0xc(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jg 0x2db9
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb 0xc(%rax,%rcx), %dl
movslq -0x1c(%rbp), %rcx
movb %dl, 0xc(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2d8f
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movb %cl, 0xf(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0xa, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x326e
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x325a
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %eax
shll $0x2, %eax
addl -0x18(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rdi
addq $0x10, %rsi
movl -0x10(%rbp), %eax
shll $0x2, %eax
addl -0x18(%rbp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
callq 0x39a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3211
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3202
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, 0xc0(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x32ff
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movslq %edx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movb -0x31(%rbp), %dl
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x32a9
movq -0x28(%rbp), %rdi
callq 0x24d0
movl $0x1, -0x18(%rbp)
cmpl $0xa, -0x18(%rbp)
jge 0x3344
movq -0x28(%rbp), %rdi
callq 0x2ce0
movq -0x28(%rbp), %rdi
callq 0x3490
movq -0x28(%rbp), %rdi
callq 0x24d0
movq -0x28(%rbp), %rdi
callq 0x3520
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x330f
movq -0x28(%rbp), %rdi
callq 0x2ce0
movq -0x28(%rbp), %rdi
callq 0x3490
movq -0x28(%rbp), %rdi
callq 0x24d0
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x33b6
movl -0x1c(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movslq %edx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3366
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x3410
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq 0x8f91(%rip), %rcx      # 0xc384
movb %dl, (%rax,%rcx)
movl 0x8f88(%rip), %eax      # 0xc384
addl $0x1, %eax
movl %eax, 0x8f7f(%rip)      # 0xc384
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x33d7
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x35f0
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x35e0
movb $0x0, -0x29(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jge 0x35b9
movq -0x40(%rbp), %rdi
movslq -0x24(%rbp), %rcx
leaq 0x8dca(%rip), %rax      # 0xc340
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movslq -0x30(%rbp), %rcx
shlq $0x2, %rcx
movq %rdi, %rax
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movzbl %dl, %esi
movzbl (%rax,%rcx), %edx
callq 0x27d0
movzbl %al, %ecx
movzbl -0x29(%rbp), %eax
xorl %ecx, %eax
movb %al, -0x29(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3561
movb -0x29(%rbp), %dl
movslq -0x24(%rbp), %rcx
leaq -0x20(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x354c
jmp 0x35e2
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x353b
movl $0x0, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
jge 0x364e
movl $0x0, -0x38(%rbp)
cmpl $0x4, -0x38(%rbp)
jge 0x3641
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rdx
leaq -0x20(%rbp), %rcx
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0x38(%rbp), %rdx
movb (%rcx,%rdx), %dl
movslq -0x34(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3604
jmp 0x3643
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x35f7
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, %rax
movq -0x50(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x20d0
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x4a42
movl $0x10, -0x34(%rbp)
jmp 0x4a72
movq -0x50(%rbp), %rdi
callq 0x20d0
movq -0x50(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x20d0
movq -0x58(%rbp), %rcx
shrq $0x4, %rax
shlq $0x4, %rax
subq %rax, %rcx
movl $0x10, %eax
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x4a99
movl -0x34(%rbp), %eax
movb %al, %cl
movslq -0x38(%rbp), %rax
movb %cl, -0x30(%rbp,%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4a79
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
movslq -0x34(%rbp), %rax
movb $0x0, -0x30(%rbp,%rax)
leaq -0x30(%rbp), %rdx
callq 0x4f00
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdx, -0x70(%rbp)
movq %rdi, %rax
movq -0x70(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq %rax, %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x20d0
movq -0x60(%rbp), %rdi
shrq $0x4, %rax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0x4d30
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4bc0
leaq -0x40(%rbp), %rdi
callq 0x4d50
movl $0x0, -0x44(%rbp)
cmpl $0x10, -0x44(%rbp)
jge 0x4b91
movq -0x70(%rbp), %rdi
movl -0x24(%rbp), %eax
shll $0x4, %eax
movl -0x44(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rsi
callq 0x2220
movq %rax, -0x78(%rbp)
jmp 0x4b4c
movq -0x78(%rbp), %rax
movb (%rax), %al
movb %al, -0x45(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x45(%rbp), %rsi
callq 0x4eb0
jmp 0x4b64
jmp 0x4b66
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x4b29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x38b0
movq -0x60(%rbp), %rdi
callq 0x4e50
jmp 0x4be0
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4de0
jmp 0x4ba0
leaq -0x40(%rbp), %rdi
callq 0x4ee0
leaq -0x40(%rbp), %rdi
callq 0x38b0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4b0d
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x4bd3
movq -0x60(%rbp), %rdi
callq 0x4e50
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x21d0
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, 0xc0(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x4c6f
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movslq %edx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movb -0x31(%rbp), %dl
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c19
movq -0x28(%rbp), %rdi
callq 0x24d0
movl $0x1, -0x18(%rbp)
cmpl $0xa, -0x18(%rbp)
jge 0x4cb4
movq -0x28(%rbp), %rdi
callq 0x25b0
movq -0x28(%rbp), %rdi
callq 0x4480
movq -0x28(%rbp), %rdi
callq 0x2690
movq -0x28(%rbp), %rdi
callq 0x24d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4c7f
movq -0x28(%rbp), %rdi
callq 0x25b0
movq -0x28(%rbp), %rdi
callq 0x4480
movq -0x28(%rbp), %rdi
callq 0x24d0
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x4d26
movl -0x1c(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movslq %edx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4cd6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x4dac
movq 0x29265(%rip), %rdi     # 0x2dfc8
leaq 0x1c29a(%rip), %rsi     # 0x21004
callq 0x3270
movq %rax, %rdi
movq 0x29237(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movq 0x29243(%rip), %rdi     # 0x2dfc8
leaq 0x1c27f(%rip), %rsi     # 0x2100b
callq 0x3270
movq %rax, %rdi
movq 0x29215(%rip), %rsi     # 0x2dfb0
callq 0x32b0
movl $0x0, -0x4(%rbp)
jmp 0x4e49
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3480
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x4ef0
jmp 0x4dd8
leaq 0x29509(%rip), %rdi     # 0x2e2e8
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x3220
jmp 0x4def
leaq -0x30(%rbp), %rdi
callq 0x34e8
leaq -0x31(%rbp), %rdi
callq 0x32d0
callq 0x5240
leaq 0x2947b(%rip), %rax     # 0x2e288
movb $0x1, (%rax)
movb $0x1, -0x45(%rbp)
movb -0x45(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0xda50
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0xde50
movq -0x50(%rbp), %rdi
callq 0xe670
movq -0x50(%rbp), %rdi
callq 0x17480
movq -0x50(%rbp), %rdi
callq 0x1bc10
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4e75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34e8
leaq -0x31(%rbp), %rdi
callq 0x32d0
movq -0x40(%rbp), %rdi
callq 0x3470
nopw (%rax,%rax)
// File: JameyWoo[P]csmile/scan.cpp
// Function: readin()
void readin() {  // 读取源文件按行写入到words数组中
    int cnt = 0;
    string str_tmp;
    while (getline(read, str_tmp))  // 一行一行读入
        words.push_back(str_tmp);
    words.push_back("EOF");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x33b0
leaq 0x29086(%rip), %rdi     # 0x2e2e8
leaq -0x28(%rbp), %rsi
callq 0x30a0
movq %rax, -0x68(%rbp)
jmp 0x5271
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3370
movb %al, -0x69(%rbp)
jmp 0x5289
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x5292
jmp 0x52b7
leaq 0x292c7(%rip), %rdi     # 0x2e560
leaq -0x28(%rbp), %rsi
callq 0x5db0
jmp 0x52a4
jmp 0x525b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x533c
leaq -0x59(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3480
movq -0x78(%rbp), %rdx
leaq 0x1be54(%rip), %rsi     # 0x21123
leaq -0x58(%rbp), %rdi
callq 0x4ef0
jmp 0x52da
leaq 0x2927f(%rip), %rdi     # 0x2e560
leaq -0x58(%rbp), %rsi
callq 0x5e20
jmp 0x52ec
leaq -0x58(%rbp), %rdi
callq 0x34e8
leaq -0x59(%rbp), %rdi
callq 0x32d0
leaq -0x28(%rbp), %rdi
callq 0x34e8
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x5333
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x34e8
leaq -0x59(%rbp), %rdi
callq 0x32d0
leaq -0x28(%rbp), %rdi
callq 0x34e8
movq -0x30(%rbp), %rdi
callq 0x3470
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x29215(%rip), %rax     # 0x2e578
movq %rax, -0x18(%rbp)
leaq 0x291d2(%rip), %rdi     # 0x2e540
callq 0x31d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jb 0x53ee
movl 0x28f07(%rip), %eax     # 0x2e28c
addl $0x1, %eax
movl %eax, 0x28efe(%rip)     # 0x2e28c
movslq %eax, %rsi
leaq 0x291c8(%rip), %rdi     # 0x2e560
callq 0x5e50
movq %rax, %rsi
leaq 0x29199(%rip), %rdi     # 0x2e540
callq 0x3050
leaq 0x2918d(%rip), %rdi     # 0x2e540
leaq 0x1bd69(%rip), %rsi     # 0x21123
callq 0x5e70
testb $0x1, %al
jne 0x53c5
jmp 0x53d2
movb $0x0, 0x28ebc(%rip)     # 0x2e288
movb $-0x1, -0x1(%rbp)
jmp 0x5428
leaq 0x29167(%rip), %rdi     # 0x2e540
movl $0x20, %esi
callq 0x31a0
movq $0x0, 0x2918a(%rip) # 0x2e578
movq 0x29183(%rip), %rax     # 0x2e578
addq $0x1, %rax
movq %rax, 0x29178(%rip)     # 0x2e578
movl 0x28e86(%rip), %ecx     # 0x2e28c
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq 0x29165(%rip), %rsi     # 0x2e578
subq $0x1, %rsi
leaq 0x29122(%rip), %rdi     # 0x2e540
callq 0x34d0
movb (%rax), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JameyWoo[P]csmile/parse.cpp
// Function: match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Token match(string expected) {
    Token tmp = ptoken;
    // cout << "ptoken.type = " << ptoken.type << " ptoken.val = " << ptoken.value << endl;
    // cout << "expected: " << expected << endl;
    // 匹配一个类型
    if (ptoken.type == expected) {
        // cout << "match: " << ptoken.value << endl;
        if (ptoken.type != "EndFile") ptoken = getToken();
    } else {
        error();
    }
    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq 0x264a8(%rip), %rsi     # 0x2e588
callq 0x7a00
movq -0x78(%rbp), %rsi
leaq 0x26498(%rip), %rdi     # 0x2e588
callq 0x75f0
testb $0x1, %al
jne 0x80fb
jmp 0x8164
leaq 0x26486(%rip), %rdi     # 0x2e588
leaq 0x18f7c(%rip), %rsi     # 0x21085
callq 0xdad0
movb %al, -0x89(%rbp)
jmp 0x8116
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x8122
jmp 0x8162
leaq -0x70(%rbp), %rdi
callq 0x5460
jmp 0x812d
leaq 0x26454(%rip), %rdi     # 0x2e588
leaq -0x70(%rbp), %rsi
callq 0xdb00
leaq -0x70(%rbp), %rdi
callq 0x4ec0
jmp 0x8162
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4ec0
jmp 0x8190
jmp 0x816d
callq 0x8040
jmp 0x816b
jmp 0x816d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8183
movq -0x88(%rbp), %rdi
callq 0x4ec0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3470
nopl (%rax)