// File: /workspace/github_c_makefile_star2_O0/taeguk[P]Compiler-Proj-Cminus/src/analyze.c
// Function: typeCheck
ExpType typeCheck(TreeNode *n)
{
  if (n == NULL) return NoneT;
  if (n->nodeType != NotResolvedT) return n->nodeType;

  TreeNode *t = n;
  for(t=n; t; t=t->sibling)
    {
      switch (t->nodeKind)
        {
        case VariableDeclarationK:
          if(t->attr.varDecl.type_spec->attr.TOK != INT)
            {
              printError(t, "Type", "Variable type other than 'int' is not allowed.");
              t->nodeType = ErrorT;
            }
          else
            {
              t->nodeType = NoneT;
            }
          break;

        case ArrayDeclarationK:
          if(t->attr.arrDecl.type_spec->attr.TOK != INT)
            {
              printError(t, "Type", "Array type other than 'int' is not allowed.");
              t->nodeType = ErrorT;
            }
          else
            {
              t->nodeType = NoneT;
            }
          break;

        case FunctionDeclarationK:
        {
          TreeNode *cmpdStmt = t->attr.funcDecl.cmpd_stmt;
          if(cmpdStmt != NULL)
            {
              if(t->attr.arrDecl.type_spec->attr.TOK == INT)
                expectedRetType = IntT; //cmpdStmt->attr.cmpdStmt.retType = IntT;
              else if(t->attr.arrDecl.type_spec->attr.TOK == VOID)
                expectedRetType = VoidT; // cmpdStmt->attr.cmpdStmt.retType = VoidT;
              else
                DONT_OCCUR_PRINT;
              typeCheck(cmpdStmt);
            }
          typeCheck(t->attr.funcDecl.params);
          t->nodeType = NoneT;
        }
          break;

        case VariableParameterK:
          if(t->attr.varParam.type_spec->attr.TOK != INT)
            {
              printError(t, "Type", "Parameter type other than 'int' or 'int[ ]' is not allowed.");
              t->nodeType = ErrorT;
            }
          else
            {
              t->nodeType = IntT;
            }
          break;

        case ArrayParameterK:
          if(t->attr.arrParam.type_spec->attr.TOK != INT)
            {
              printError(t, "Type", "Parameter type other than 'int' or 'int[ ]' is not allowed.");
              t->nodeType = ErrorT;
            }
          else
            {
              t->nodeType = IntArrayT;
            }
          break;

        case CompoundStatementK:
        {
          /*
          // Propagate return type for return statement
          TreeNode *stmt;
          for(stmt = t->attr.cmpdStmt.stmt_list;
              stmt != NULL;
              stmt = stmt->sibling)
            {
              if(stmt->nodeKind == ReturnStatementK)
                {
                  stmt->attr.retStmt.retType = t->attr.cmpdStmt.retType;
                }
              if(stmt->nodeKind == CompoundStatementK)
                {
                  //TODO: need to compare equalness.
                  stmt->attr.cmpdStmt.retType = t->attr.cmpdStmt.retType;
                }
            }
          */

          typeCheck(t->attr.cmpdStmt.local_decl);
          typeCheck(t->attr.cmpdStmt.stmt_list);
          t->nodeType = NoneT;
        }
          break;

        case ExpressionStatementK:
          typeCheck(t->attr.exprStmt.expr);
          t->nodeType = NoneT;
          break;

        case SelectionStatementK:
          if (typeCheck(t->attr.selectStmt.expr) != IntT)
            {
              printError(t, "Type", "Expression inside selection statement should be type 'int'.");
              t->nodeType = ErrorT;
            }
          else
            {
              typeCheck(t->attr.selectStmt.if_stmt);
              typeCheck(t->attr.selectStmt.else_stmt);
              t->nodeType = NoneT;
            }
          break;

        case IterationStatementK:
          if (typeCheck(t->attr.iterStmt.expr) != IntT)
            {
              printError(t, "Type", "Expression inside iteration statement should be type 'int'.");
              t->nodeType = ErrorT;
            }
          else
            {
              typeCheck(t->attr.iterStmt.loop_stmt);
              t->nodeType = NoneT;
            }
          break;

        case ReturnStatementK:
        {
          if(expectedRetType == VoidT/*t->attr.retStmt.retType != IntT
             && t->attr.retStmt.retType != VoidT*/)
            {
              DONT_OCCUR_PRINT;
              t->nodeType = ErrorT;
            }
          else
            {
              ExpType type = typeCheck(t->attr.retStmt.expr);
              if(type != expectedRetType/*t->attr.retStmt.retType*/)
                {
                  printError(t, "Type", "Returning expression must match pre-declared function return type.");
                  t->nodeType = ErrorT;
                }
              else
                {
                  t->nodeType = NoneT;
                }
            }
        }
          break;

        case AssignExpressionK:
        {
          ExpType exprType = typeCheck(t->attr.assignStmt.expr);
          ExpType varType = typeCheck(t->attr.assignStmt._var);
          if (varType != IntT || varType != exprType)
            {
              if(varType != ErrorT && exprType != ErrorT)
                printError(t, "Type", "Assignment and assignee type mismatch");
            }
          t->nodeType = varType;
        }
          break;

        case ComparisonExpressionK:
        {
          ExpType lType = typeCheck(t->attr.cmpExpr.lexpr);
          ExpType rType = typeCheck(t->attr.cmpExpr.rexpr);
          if (lType == IntT && lType == rType)
            {
              t->nodeType = IntT;
            }
          else
            {
              printError(t, "Type", "Comparison between different types.");
              t->nodeType = ErrorT;
            }
        }
          break;

        case AdditiveExpressionK:
        {
          ExpType lType = typeCheck(t->attr.addExpr.lexpr);
          ExpType rType = typeCheck(t->attr.addExpr.rexpr);
          if (lType == IntT && lType == rType)
            {
              t->nodeType = IntT;
            }
          else
            {
              printError(t, "Type", "Addition between different types.");
              t->nodeType = ErrorT;
            }
        }
          break;

        case MultiplicativeExpressionK:
        {
          ExpType lType = typeCheck(t->attr.multExpr.lexpr);
          ExpType rType = typeCheck(t->attr.multExpr.rexpr);
          if (lType == IntT && lType == rType)
            {
              t->nodeType = IntT;
            }
          else
            {
              printError(t, "Type", "Multiplication between different types.");
              t->nodeType = ErrorT;
            }
        }
          break;

        case ArrayK:
        {
          int isError = FALSE;
          if (typeCheck(t->attr.arr._var) != IntArrayT)
            {
              printError(t, "Type", "Variable '%s' is not subscriptable.", t->attr.arr._var->attr.ID);
              t->nodeType = ErrorT;
              isError = TRUE;
            }
          if(typeCheck(t->attr.arr.arr_expr) != IntT)
            {
              printError(t, "Type", "Array subscript must be type 'int'.", t->attr.arr._var->attr.ID);
              t->nodeType = ErrorT;
              isError = TRUE;
            }

          if(!isError)
            {
              t->nodeType = IntT;
            }
        }
          break;

        case CallK:
        {
          int isError = FALSE;
          SymbolInfo *info = t->attr.call._var->symbolInfo;
          ExpType fType = typeCheck(t->attr.call._var);

          if (fType != FuncT)
            {
              if (fType == IntT || fType == IntArrayT)
                {
                  printError(t, "Type", "Variable '%s' is not callable.", t->attr.call._var->attr.ID);
                }
              else
                {
                  printError(t, "Type", "'%s' is never declared.", t->attr.call._var->attr.ID);
                }
              t->nodeType = ErrorT;
              isError = TRUE;
            }

          if (!isError && info == NULL)
            {
              t->nodeType = ErrorT;
              isError = TRUE;
              DONT_OCCUR_PRINT;
            }

          if(!isError)
            {
              // Parameter type checking
              int exprIdx = 0;
              TreeNode *expr;
              for(expr = t->attr.call.expr_list;
                  expr != NULL;
                  expr = expr->sibling, exprIdx++)
                {
                  if(exprIdx >= info->attr.funcInfo.paramLen)
                    {
                      printError(t,
                                 "Type",
                                 "Too many parameters while calling function '%s'.",
                                 t->attr.call._var->attr.ID);
                      isError = TRUE;
                      break;
                    }
                  // TODO: checking filetype with symbolInfo?
                  if(typeCheck(expr) != info->attr.funcInfo.paramTypeList[exprIdx])
                    {
                      printError(t,
                                 "Type",
                                 "Type mismatch of parameter at %d while calling '%s'.",
                                 exprIdx + 1,
                                 t->attr.call._var->attr.ID);
                      isError = TRUE;
                    }
                }
              if(exprIdx < info->attr.funcInfo.paramLen)
                {
                  printError(t,
                             "Type",
                             "Too little parameters while calling function '%s'.",
                             t->attr.call._var->attr.ID);
                  isError = TRUE;
                  break;
                }
            }

          if(!isError)
            {
              t->nodeType = info->attr.funcInfo.retType;
            }
        }
          break;

        case VariableK:
          break;

        case ConstantK:
          t->nodeType = IntT;
          break;
        case TokenTypeK:
          t->nodeType = NoneT;
          break;

        case ErrorK:
          DONT_OCCUR_PRINT;
        default:
          DONT_OCCUR_PRINT;
          break;
        }
    }

  return n->nodeType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x192f
movl $0x2, -0x4(%rbp)
jmp 0x20d2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x1948
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x20d2
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x20c8
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movq %rax, -0x70(%rbp)
subq $0x13, %rax
ja 0x20b4
movq -0x70(%rbp), %rax
leaq 0x76d1(%rip), %rcx      # 0x9054
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x107, 0x20(%rax)      # imm = 0x107
je 0x19c3
movq -0x18(%rbp), %rdi
leaq 0x7710(%rip), %rsi      # 0x90b8
leaq 0x770e(%rip), %rdx      # 0x90bd
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x19ce
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x107, 0x20(%rax)      # imm = 0x107
je 0x1a0a
movq -0x18(%rbp), %rdi
leaq 0x76c9(%rip), %rsi      # 0x90b8
leaq 0x76f6(%rip), %rdx      # 0x90ec
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x1a15
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1a74
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x107, 0x20(%rax)      # imm = 0x107
jne 0x1a4a
movl $0x4, 0xc6ec(%rip)      # 0xe134
jmp 0x1a6b
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x109, 0x20(%rax)      # imm = 0x109
jne 0x1a67
movl $0x3, 0xc6cf(%rip)      # 0xe134
jmp 0x1a69
jmp 0x1a69
jmp 0x1a6b
movq -0x20(%rbp), %rdi
callq 0x1910
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1910
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x107, 0x20(%rax)      # imm = 0x107
je 0x1ac8
movq -0x18(%rbp), %rdi
leaq 0x760b(%rip), %rsi      # 0x90b8
leaq 0x7664(%rip), %rdx      # 0x9118
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x1ad3
movq -0x18(%rbp), %rax
movl $0x4, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x107, 0x20(%rax)      # imm = 0x107
je 0x1b0f
movq -0x18(%rbp), %rdi
leaq 0x75c4(%rip), %rsi      # 0x90b8
leaq 0x761d(%rip), %rdx      # 0x9118
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x1b1a
movq -0x18(%rbp), %rax
movl $0x5, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1910
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
cmpl $0x4, %eax
je 0x1b9e
movq -0x18(%rbp), %rdi
leaq 0x7535(%rip), %rsi      # 0x90b8
leaq 0x75ca(%rip), %rdx      # 0x9154
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x1bc3
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1910
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1910
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
cmpl $0x4, %eax
je 0x1c00
movq -0x18(%rbp), %rdi
leaq 0x74d3(%rip), %rsi      # 0x90b8
leaq 0x75a4(%rip), %rdx      # 0x9190
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x1c18
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1910
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x20b6
cmpl $0x3, 0xc510(%rip)      # 0xe134
jne 0x1c33
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x1c81
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0xc4e8(%rip), %eax      # 0xe134
je 0x1c74
movq -0x18(%rbp), %rdi
leaq 0x745f(%rip), %rsi      # 0x90b8
leaq 0x756c(%rip), %rdx      # 0x91cc
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x1c7f
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x1c81
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1910
movl %eax, -0x2c(%rbp)
cmpl $0x4, -0x2c(%rbp)
jne 0x1cb4
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x1cdb
cmpl $0x1, -0x2c(%rbp)
je 0x1cd9
cmpl $0x1, -0x28(%rbp)
je 0x1cd9
movq -0x18(%rbp), %rdi
leaq 0x73ed(%rip), %rsi      # 0x90b8
leaq 0x753d(%rip), %rdx      # 0x920f
movb $0x0, %al
callq 0x21d0
jmp 0x1cdb
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1910
movl %eax, -0x34(%rbp)
cmpl $0x4, -0x30(%rbp)
jne 0x1d25
movl -0x30(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x1d25
movq -0x18(%rbp), %rax
movl $0x4, 0x10(%rax)
jmp 0x1d49
movq -0x18(%rbp), %rdi
leaq 0x7388(%rip), %rsi      # 0x90b8
leaq 0x74fe(%rip), %rdx      # 0x9235
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1910
movl %eax, -0x3c(%rbp)
cmpl $0x4, -0x38(%rbp)
jne 0x1d89
movl -0x38(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jne 0x1d89
movq -0x18(%rbp), %rax
movl $0x4, 0x10(%rax)
jmp 0x1dad
movq -0x18(%rbp), %rdi
leaq 0x7324(%rip), %rsi      # 0x90b8
leaq 0x74be(%rip), %rdx      # 0x9259
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1910
movl %eax, -0x44(%rbp)
cmpl $0x4, -0x40(%rbp)
jne 0x1ded
movl -0x40(%rbp), %eax
cmpl -0x44(%rbp), %eax
jne 0x1ded
movq -0x18(%rbp), %rax
movl $0x4, 0x10(%rax)
jmp 0x1e11
movq -0x18(%rbp), %rdi
leaq 0x72c0(%rip), %rsi      # 0x90b8
leaq 0x747c(%rip), %rdx      # 0x927b
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x20b6
movl $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
cmpl $0x5, %eax
je 0x1e66
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0x7272(%rip), %rsi      # 0x90b8
leaq 0x7456(%rip), %rdx      # 0x92a3
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movl $0x1, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1910
cmpl $0x4, %eax
je 0x1eaf
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0x7229(%rip), %rsi      # 0x90b8
leaq 0x7431(%rip), %rdx      # 0x92c7
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movl $0x1, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jne 0x1ec0
movq -0x18(%rbp), %rax
movl $0x4, 0x10(%rax)
jmp 0x20b6
movl $0x0, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1910
movl %eax, -0x5c(%rbp)
cmpl $0x6, -0x5c(%rbp)
je 0x1f5c
cmpl $0x4, -0x5c(%rbp)
je 0x1efe
cmpl $0x5, -0x5c(%rbp)
jne 0x1f25
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0x71a3(%rip), %rsi      # 0x90b8
leaq 0x73cf(%rip), %rdx      # 0x92eb
movb $0x0, %al
callq 0x21d0
jmp 0x1f4a
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0x717c(%rip), %rsi      # 0x90b8
leaq 0x73c7(%rip), %rdx      # 0x930a
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movl $0x1, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jne 0x1f7b
cmpq $0x0, -0x58(%rbp)
jne 0x1f7b
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movl $0x1, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jne 0x2080
movl $0x0, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x2044
movl -0x60(%rbp), %eax
movq -0x58(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0x1fdd
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0x70f2(%rip), %rsi      # 0x90b8
leaq 0x7355(%rip), %rdx      # 0x9322
movb $0x0, %al
callq 0x21d0
movl $0x1, -0x4c(%rbp)
jmp 0x2044
movq -0x68(%rbp), %rdi
callq 0x1910
movq -0x58(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x60(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x2029
movq -0x18(%rbp), %rdi
movl -0x60(%rbp), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %r8
leaq 0x70a4(%rip), %rsi      # 0x90b8
leaq 0x7338(%rip), %rdx      # 0x9353
movb $0x0, %al
callq 0x21d0
movl $0x1, -0x4c(%rbp)
jmp 0x202b
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x1f98
movl -0x60(%rbp), %eax
movq -0x58(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x207e
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rcx
leaq 0x7051(%rip), %rsi      # 0x90b8
leaq 0x731a(%rip), %rdx      # 0x9388
movb $0x0, %al
callq 0x21d0
movl $0x1, -0x4c(%rbp)
jmp 0x20b6
jmp 0x2080
cmpl $0x0, -0x4c(%rbp)
jne 0x2094
movq -0x58(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x20b6
jmp 0x20b6
movq -0x18(%rbp), %rax
movl $0x4, 0x10(%rax)
jmp 0x20b6
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x20b6
jmp 0x20b4
jmp 0x20b6
jmp 0x20b8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1958
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)