// File: /workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/debug.c
// Function: node_ast
char *node_ast(Node *node) {
  char buf[10000];
  int n = 0;

  if (!node) {
    return NULL;
  }

  switch (node->kind) {
      case ND_DUMMY:
        break;
      case ND_ADD:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(+ %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_PTR_ADD:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(ptr+ %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_SUB:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(- %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_PTR_SUB:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(ptr- %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_PTR_DIFF:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(ptr-diff %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_MUL:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(* %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_DIV:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(/ %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_BIT_XOR:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(^ %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_BIT_OR:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(| %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_BIT_AND:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(& %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_AND:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(&& %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_OR:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(|| %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_LT:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(< %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_LTE:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(<= %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_EQL:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(== %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_NOT_EQL:
        {
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(!= %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_ASSIGN:
        {
          assert(node->lhs);
          assert(node->rhs);
          char *l = node_ast(node->lhs);
          char *r = node_ast(node->rhs);
          n = sprintf(buf, "(let %s %s)", l, r);
          char *ret = my_strndup(buf, n);
          free(l);
          free(r);
          return ret;
        }
      case ND_VAR:
        n = sprintf(buf, "(%cvar %s)", node->var->is_local ? 'l' : 'g', node->var->name);
        return my_strndup(buf, n);
      case ND_RETURN:
        {
          char *l = node_ast(node->lhs);
          n = sprintf(buf, "(return %s)", l);
          free(l);
          return my_strndup(buf, n);
        }
      case ND_WHILE:
        {
          char *cond = node_ast(node->cond);
          char *body = node_ast(node->body);
          n = sprintf(buf, "(while (cond %s) (body %s))", cond, body);
          char *ret = my_strndup(buf, n);
          free(cond);
          free(body);
          return ret;
        }
      case ND_BLOCK:
        {
          int i = 0;
          char *tmp_bufs[1000];
          n += sprintf(buf, "(block ");
          for (Node *nd = node->body; nd; nd = nd->next) {
            tmp_bufs[i] = node_ast(nd);
            n += sprintf(buf + n, "%s", tmp_bufs[i]);
            if (nd->next) {
              n += sprintf(buf + n, " ");
            }
            i++;
          }
          for (int j = 0; j < i; j++) {
            free(tmp_bufs[j]);
          }
          n += sprintf(buf + n, ")");
          return my_strndup(buf, n);
        }
      case ND_IF:
        {
          char *cond = node_ast(node->cond);
          char *then = node_ast(node->then);
          char *els = node_ast(node->els);
          n = sprintf(buf, "(if (cond %s) (then %s) (else %s))", node_ast(node->cond), node_ast(node->then), node_ast(node->els));
          char *ret = my_strndup(buf, n);
          free(cond);
          free(then);
          free(els);
          return ret;
        }
      case ND_FOR:
        {
          char *init = node_ast(node->init);
          char *cond = node_ast(node->cond);
          char *inc = node_ast(node->inc);
          char *body = node_ast(node->body);
          n = sprintf(buf, "(for (init %s) (cond %s) (inc %s) (body %s))", node_ast(node->init), node_ast(node->cond), node_ast(node->inc), node_ast(node->body));
          char *ret = my_strndup(buf, n);
          free(init);
          free(cond);
          free(inc);
          free(body);
          return ret;
        }
      case ND_CALL:
        {
          char *tmp_bufs[1000];
          n = sprintf(buf, "(call (name %s)", node->funcname);
          int i = 0;
          for (Node *p = node->arg; p; p = p->next) {
            char *tmp = tmp_bufs[i] = node_ast(p);
            n += sprintf(buf + n, " %s", tmp);
            i++;
          }
          n += sprintf(buf + n, ")");
          char *ret = my_strndup(buf, n);

          for (int j = 0; j < i; j++) {
            free(tmp_bufs[j]);
          }
          return ret;
        }
      case ND_ADDR:
        {
          char *l = node_ast(node->lhs);
          n = sprintf(buf, "(addr %s)", l);
          char *ret = my_strndup(buf, n);
          free(l);
          return ret;
        }
      case ND_DEREF:
        {
          char *l = node_ast(node->lhs);
          n = sprintf(buf, "(deref %s)", l);
          char *ret = my_strndup(buf, n);
          free(l);
          return ret;
        }
      case ND_VAR_DECL:
        {
          char *ti = type_info(node->var->type);
          n += sprintf(buf, "(decl (%s %s)", ti, node->var->name);
          if (node->initializer) {
            n += sprintf(buf + n, " (init %s)", node_ast(node->initializer));
          }
          n += sprintf(buf + n, ")");
          char *ret = my_strndup(buf, n);
          free(ti);
          return ret;
        }
      case ND_EXPR_STMT:
        {
          char *l = node_ast(node->lhs);
          n += sprintf(buf, "(expr-stmt %s)", l);
          char *ret = my_strndup(buf, n);
          free(l);
          return ret;
        }
      case ND_NUM:
        n += sprintf(buf, "(num %ld)", node->val);
        return my_strndup(buf, n);
      case ND_MEMBER:
        {
          char *l = node_ast(node->lhs);
          n += sprintf(buf, "(member %s %s)", l, node->member->name);
          char *ret = my_strndup(buf, n);
          free(l);
          return ret;
        }
      case ND_NOT:
        {
          char *l = node_ast(node->lhs);
          n += sprintf(buf, "(! %s)", l);
          char *ret = my_strndup(buf, n);
          free(l);
          return ret;
        }
      case ND_BIT_NOT:
        {
          char *l = node_ast(node->lhs);
          n += sprintf(buf, "(~ %s)", l);
          char *ret = my_strndup(buf, n);
          free(l);
          return ret;
        }
      case ND_BREAK:
        n += sprintf(buf, "(break)");
        return my_strndup(buf, n);
      case ND_CONTINUE:
        n += sprintf(buf, "(continue)");
        return my_strndup(buf, n);
      case ND_GOTO:
        n += sprintf(buf, "(goto %s)", node->label_name);
        return my_strndup(buf, n);
      case ND_SWITCH:
        {
          char *cond = node_ast(node->lhs);
          char *body = node_ast(node->body);
          n += sprintf(buf, "(switch %s %s)", cond, body);
          free(cond);
          free(body);
          return my_strndup(buf, n);
        }
      case ND_CASE:
        {
          char *stmt = node_ast(node->lhs);
          if (node->is_default_case) {
            n += sprintf(buf, "(default %s)", stmt);
          } else {
            n += sprintf(buf, "(case (cond %ld) %s)", node->case_cond_val, stmt);
          }
          free(stmt);
          return my_strndup(buf, n);
        }
      case ND_NULL:
        return "(ND_NULL)";
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4668, %rsp           # imm = 0x4668
testq %rdi, %rdi
je 0x3d7e
movq %rdi, %rbx
movl (%rdi), %eax
decl %eax
cmpl $0x30, %eax
ja 0x3d7e
leaq 0x826b(%rip), %rcx      # 0xbfbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x85af(%rip), %rsi      # 0xc328
jmp 0x43b5
xorl %ebx, %ebx
jmp 0x4593
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
cmpb $0x1, 0xb0(%rbx)
jne 0x452c
leaq 0x878f(%rip), %rsi      # 0xc534
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21c0
jmp 0x4549
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x45a8
cmpq $0x0, 0x20(%rbx)
je 0x45c7
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8621(%rip), %rsi      # 0xc40d
jmp 0x43b5
movq 0x38(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8620(%rip), %rsi      # 0xc430
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8547(%rip), %rsi      # 0xc37b
jmp 0x43b5
movq 0x88(%rbx), %rdx
leaq 0x8655(%rip), %rsi      # 0xc49c
xorl %r12d, %r12d
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x21c0
movl %eax, %r14d
movq 0x70(%rbx), %rbx
testq %rbx, %rbx
je 0x3ea3
leaq 0x8718(%rip), %r15      # 0xc581
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x3d28
movq %rax, 0x2720(%rsp,%r12,8)
movslq %r14d, %r14
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
addl %eax, %r14d
incq %r12
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x3e6c
movslq %r14d, %rsi
movw $0x29, 0x10(%rsp,%rsi)
incl %esi
leaq 0x10(%rsp), %rdi
callq 0x4ae3
movq %rax, %rbx
testl %r12d, %r12d
je 0x4593
movl %r12d, %r14d
xorl %r15d, %r15d
movq 0x2720(%rsp,%r15,8), %rdi
callq 0x2030
incq %r15
cmpq %r15, %r14
jne 0x3ecb
jmp 0x4593
movq 0x38(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x40(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
movq 0x48(%rbx), %rdi
callq 0x3d28
movq %rax, %r12
movq 0x38(%rbx), %rdi
callq 0x3d28
movq %rax, %r13
movq 0x40(%rbx), %rdi
callq 0x3d28
movq %rax, %rbp
movq 0x48(%rbx), %rdi
callq 0x3d28
leaq 0x851b(%rip), %rsi      # 0xc44c
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rdx
movq %rbp, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x21c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
movq %r15, %rdi
callq 0x2030
movq %r12, %rdi
jmp 0x44bc
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x840c(%rip), %rsi      # 0xc399
jmp 0x43b5
movabsq $0x756e69746e6f6328, %rax # imm = 0x756E69746E6F6328
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movl $0x296575, 0x7(%rdi)    # imm = 0x296575
movl $0xa, %esi
jmp 0x458b
movq 0x78(%rbx), %rax
movq (%rax), %rdi
callq 0x3cfd
movq %rax, %r14
movq 0x78(%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x84ee(%rip), %rsi      # 0xc4c1
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21c0
movl %eax, %ebp
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x4013
movslq %ebp, %rax
leaq (%rsp,%rax), %rbx
addq $0x10, %rbx
callq 0x3d28
leaq 0x84cb(%rip), %rsi      # 0xc4cf
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
addl %eax, %ebp
movslq %ebp, %rsi
movw $0x29, 0x10(%rsp,%rsi)
incl %esi
leaq 0x10(%rsp), %rdi
jmp 0x44b1
movabsq $0x206b636f6c6228, %rax # imm = 0x206B636F6C6228
movq %rax, 0x10(%rsp)
movq 0x28(%rbx), %rbx
movl $0x7, %r15d
testq %rbx, %rbx
je 0x457a
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x3d28
movq %rax, 0x2720(%rsp,%r12,8)
movslq %r15d, %r15
leaq (%rsp,%r15), %r14
addq $0x10, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x20a0
subl %r14d, %eax
addl %eax, %r15d
cmpq $0x0, 0x30(%rbx)
je 0x455c
movslq %r15d, %r15
movw $0x20, 0x10(%rsp,%r15)
incl %r15d
movq 0x30(%rbx), %rbx
incq %r12
testq %rbx, %rbx
jne 0x404e
jmp 0x455f
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x82cc(%rip), %rsi      # 0xc38f
jmp 0x43b5
movq 0x78(%rbx), %rax
movzbl 0x14(%rax), %ecx
leal (%rcx,%rcx,4), %edx
addl $0x67, %edx
movq 0x8(%rax), %rcx
leaq 0x8338(%rip), %rsi      # 0xc419
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21c0
jmp 0x441c
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x822b(%rip), %rsi      # 0xc33f
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
leaq 0x83ae(%rip), %rsi      # 0xc4da
jmp 0x449a
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x98(%rbx), %rax
movq 0x10(%rax), %rcx
leaq 0x83a4(%rip), %rsi      # 0xc4f3
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21c0
jmp 0x44ac
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x81e2(%rip), %rsi      # 0xc367
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x81dc(%rip), %rsi      # 0xc385
jmp 0x43b5
movq 0x58(%rbx), %rdi
callq 0x3d28
movq %rax, 0x8(%rsp)
movq 0x38(%rbx), %rdi
callq 0x3d28
movq %rax, (%rsp)
movq 0x60(%rbx), %rdi
callq 0x3d28
movq %rax, %r12
movq 0x28(%rbx), %rdi
callq 0x3d28
movq %rax, %r13
movq 0x58(%rbx), %rdi
callq 0x3d28
movq %rax, %rbp
movq 0x38(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
movq 0x28(%rbx), %rdi
callq 0x3d28
leaq 0x825a(%rip), %rsi      # 0xc46f
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x21c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x2030
movq (%rsp), %rdi
callq 0x2030
movq %r12, %rdi
callq 0x2030
movq %r13, %rdi
jmp 0x44bc
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x80b3(%rip), %rsi      # 0xc332
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x80ce(%rip), %rsi      # 0xc371
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x80e8(%rip), %rsi      # 0xc3af
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x80d9(%rip), %rsi      # 0xc3c4
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x80c0(%rip), %rsi      # 0xc3cf
jmp 0x43b5
movq 0x80(%rbx), %rdx
leaq 0x81c7(%rip), %rsi      # 0xc4e9
jmp 0x440d
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8003(%rip), %rsi      # 0xc349
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x7fef(%rip), %rsi      # 0xc356
jmp 0x43b5
leaq 0x81e6(%rip), %rbx      # 0xc556
jmp 0x4593
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8010(%rip), %rsi      # 0xc3a4
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8004(%rip), %rsi      # 0xc3b9
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x21c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
movq %r15, %rdi
jmp 0x44bc
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
leaq 0x810f(%rip), %rsi      # 0xc509
jmp 0x449a
movq 0xa0(%rbx), %rdx
leaq 0x810e(%rip), %rsi      # 0xc51b
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21c0
movq %rbx, %rdi
movl %eax, %esi
jmp 0x458b
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
leaq 0x80c9(%rip), %rsi      # 0xc502
jmp 0x449a
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %rbx
leaq 0x7fd6(%rip), %rsi      # 0xc424
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2030
movq %r14, %rdi
jmp 0x450f
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
leaq 0x8031(%rip), %rsi      # 0xc4b6
jmp 0x449a
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
leaq 0x8012(%rip), %rsi      # 0xc4ac
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
jmp 0x4593
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x3d28
movq %rax, %rbx
leaq 0x8040(%rip), %rsi      # 0xc525
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x21c0
movl %eax, %ebp
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
movq %r15, %rdi
movl %ebp, %esi
jmp 0x458b
movabsq $0x296b6165726228, %rax # imm = 0x296B6165726228
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movl $0x7, %esi
jmp 0x458b
movq 0xa8(%rbx), %rdx
leaq 0x8007(%rip), %rsi      # 0xc541
leaq 0x10(%rsp), %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x21c0
movl %eax, %ebx
movq %r14, %rdi
callq 0x2030
leaq 0x10(%rsp), %rdi
movl %ebx, %esi
jmp 0x458b
incq %r12
movl %r12d, %ebx
xorl %r14d, %r14d
movq 0x2720(%rsp,%r14,8), %rdi
callq 0x2030
incq %r14
cmpq %r14, %rbx
jne 0x4565
movslq %r15d, %rsi
movw $0x29, 0x10(%rsp,%rsi)
incl %esi
leaq 0x10(%rsp), %rdi
callq 0x4ae3
movq %rax, %rbx
movq %rbx, %rax
addq $0x4668, %rsp           # imm = 0x4668
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7e2b(%rip), %rdi      # 0xc3da
leaq 0x7e2e(%rip), %rsi      # 0xc3e4
leaq 0x7e2f(%rip), %rcx      # 0xc3ec
movl $0x14d, %edx            # imm = 0x14D
callq 0x20d0
leaq 0x7e35(%rip), %rdi      # 0xc403
leaq 0x7e0f(%rip), %rsi      # 0xc3e4
leaq 0x7e10(%rip), %rcx      # 0xc3ec
movl $0x14e, %edx            # imm = 0x14E
callq 0x20d0