// File: /workspace/github_c_makefile_star2_O2/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 0x3c6d
movq %rdi, %rbx
movl (%rdi), %eax
decl %eax
cmpl $0x30, %eax
ja 0x3c6d
leaq 0x637c(%rip), %rcx      # 0x9fbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x66c0(%rip), %rsi      # 0xa328
jmp 0x42b7
xorl %ebx, %ebx
jmp 0x4462
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
cmpb $0x1, 0xb0(%rbx)
jne 0x442c
leaq 0x68a0(%rip), %rsi      # 0xa534
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21b0
jmp 0x4449
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4477
cmpq $0x0, 0x20(%rbx)
je 0x4496
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x6732(%rip), %rsi      # 0xa40d
jmp 0x42b7
movq 0x38(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x6731(%rip), %rsi      # 0xa430
jmp 0x42b7
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x6658(%rip), %rsi      # 0xa37b
jmp 0x42b7
movq 0x88(%rbx), %rdx
leaq 0x6766(%rip), %rsi      # 0xa49c
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x21b0
movl %eax, %r14d
addq $0x70, %rbx
leaq 0x6831(%rip), %r15      # 0xa581
xorl %r12d, %r12d
movq (%rbx), %rbx
movslq %r14d, %r14
testq %rbx, %rbx
je 0x3d8f
movq %rbx, %rdi
callq 0x3c17
movq %rax, 0x2720(%rsp,%r12,8)
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21b0
addl %eax, %r14d
incq %r12
addq $0x30, %rbx
jmp 0x3d53
movw $0x29, 0x10(%rsp,%r14)
incl %r14d
leaq 0x10(%rsp), %rdi
movl %r14d, %esi
callq 0x4903
movq %rax, %rbx
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x4462
movq 0x2720(%rsp,%r14,8), %rdi
callq 0x2030
incq %r14
jmp 0x3dad
movq 0x38(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x40(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
movq 0x48(%rbx), %rdi
callq 0x3c17
movq %rax, %r12
movq 0x38(%rbx), %rdi
callq 0x3c17
movq %rax, %r13
movq 0x40(%rbx), %rdi
callq 0x3c17
movq %rax, %rbp
movq 0x48(%rbx), %rdi
callq 0x3c17
leaq 0x6638(%rip), %rsi      # 0xa44c
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rdx
movq %rbp, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x21b0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4903
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
movq %r15, %rdi
callq 0x2030
movq %r12, %rdi
jmp 0x43be
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x6529(%rip), %rsi      # 0xa399
jmp 0x42b7
movabsq $0x756e69746e6f6328, %rax # imm = 0x756E69746E6F6328
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movl $0x296575, 0x7(%rdi)    # imm = 0x296575
pushq $0xa
jmp 0x4429
movq 0x78(%rbx), %rax
movq (%rax), %rdi
callq 0x3bec
movq %rax, %r14
movq 0x78(%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x660e(%rip), %rsi      # 0xa4c1
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21b0
movl %eax, %ebp
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x3ef3
movslq %ebp, %rax
leaq (%rsp,%rax), %rbx
addq $0x10, %rbx
callq 0x3c17
leaq 0x65eb(%rip), %rsi      # 0xa4cf
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21b0
addl %eax, %ebp
movslq %ebp, %rsi
movw $0x29, 0x10(%rsp,%rsi)
incl %esi
leaq 0x10(%rsp), %rdi
jmp 0x43b3
movabsq $0x206b636f6c6228, %rax # imm = 0x206B636F6C6228
movq %rax, 0x10(%rsp)
addq $0x28, %rbx
pushq $0x7
popq %r14
xorl %r12d, %r12d
movq (%rbx), %rbx
movslq %r14d, %r14
testq %rbx, %rbx
je 0x3f75
movq %rbx, %rdi
callq 0x3c17
movq %rax, 0x2720(%rsp,%r12,8)
leaq (%rsp,%r14), %r15
addq $0x10, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x20a0
subl %r15d, %eax
addl %eax, %r14d
cmpq $0x0, 0x30(%rbx)
je 0x3f6c
movslq %r14d, %r14
movw $0x20, 0x10(%rsp,%r14)
incl %r14d
addq $0x30, %rbx
incq %r12
jmp 0x3f23
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x3f8e
movq 0x2720(%rsp,%rbx,8), %rdi
callq 0x2030
incq %rbx
jmp 0x3f77
movw $0x29, 0x10(%rsp,%r14)
incl %r14d
leaq 0x10(%rsp), %rdi
movl %r14d, %esi
jmp 0x445a
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x63ca(%rip), %rsi      # 0xa38f
jmp 0x42b7
movq 0x78(%rbx), %rax
movzbl 0x14(%rax), %ecx
leal (%rcx,%rcx,4), %edx
addl $0x67, %edx
movq 0x8(%rax), %rcx
leaq 0x6436(%rip), %rsi      # 0xa419
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21b0
jmp 0x431e
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x6329(%rip), %rsi      # 0xa33f
jmp 0x42b7
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
leaq 0x64ac(%rip), %rsi      # 0xa4da
jmp 0x439c
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x98(%rbx), %rax
movq 0x10(%rax), %rcx
leaq 0x64a2(%rip), %rsi      # 0xa4f3
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21b0
jmp 0x43ae
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x62e0(%rip), %rsi      # 0xa367
jmp 0x42b7
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x62da(%rip), %rsi      # 0xa385
jmp 0x42b7
movq 0x58(%rbx), %rdi
callq 0x3c17
movq %rax, 0x8(%rsp)
movq 0x38(%rbx), %rdi
callq 0x3c17
movq %rax, (%rsp)
movq 0x60(%rbx), %rdi
callq 0x3c17
movq %rax, %r12
movq 0x28(%rbx), %rdi
callq 0x3c17
movq %rax, %r13
movq 0x58(%rbx), %rdi
callq 0x3c17
movq %rax, %rbp
movq 0x38(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
movq 0x28(%rbx), %rdi
callq 0x3c17
leaq 0x6358(%rip), %rsi      # 0xa46f
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x21b0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4903
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x2030
movq (%rsp), %rdi
callq 0x2030
movq %r12, %rdi
callq 0x2030
movq %r13, %rdi
jmp 0x43be
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x61b1(%rip), %rsi      # 0xa332
jmp 0x42b7
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x61cc(%rip), %rsi      # 0xa371
jmp 0x42b7
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x61e6(%rip), %rsi      # 0xa3af
jmp 0x42b7
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x61d7(%rip), %rsi      # 0xa3c4
jmp 0x42b7
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x61be(%rip), %rsi      # 0xa3cf
jmp 0x42b7
movq 0x80(%rbx), %rdx
leaq 0x62c5(%rip), %rsi      # 0xa4e9
jmp 0x430f
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x6101(%rip), %rsi      # 0xa349
jmp 0x42b7
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x60ed(%rip), %rsi      # 0xa356
jmp 0x42b7
leaq 0x62e4(%rip), %rbx      # 0xa556
jmp 0x4462
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x610e(%rip), %rsi      # 0xa3a4
jmp 0x42b7
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3c17
movq %rax, %r15
leaq 0x6102(%rip), %rsi      # 0xa3b9
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x21b0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4903
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
movq %r15, %rdi
jmp 0x43be
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
leaq 0x620d(%rip), %rsi      # 0xa509
jmp 0x439c
movq 0xa0(%rbx), %rdx
leaq 0x620c(%rip), %rsi      # 0xa51b
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21b0
movq %rbx, %rdi
movl %eax, %esi
jmp 0x445a
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
leaq 0x61c7(%rip), %rsi      # 0xa502
jmp 0x439c
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %rbx
leaq 0x60d4(%rip), %rsi      # 0xa424
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21b0
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2030
movq %r14, %rdi
jmp 0x4411
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
leaq 0x612f(%rip), %rsi      # 0xa4b6
jmp 0x439c
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
leaq 0x6110(%rip), %rsi      # 0xa4ac
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21b0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4903
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
jmp 0x4462
movq 0x18(%rbx), %rdi
callq 0x3c17
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x3c17
movq %rax, %rbx
leaq 0x613e(%rip), %rsi      # 0xa525
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x21b0
movl %eax, %ebp
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
movq %r15, %rdi
movl %ebp, %esi
jmp 0x445a
movabsq $0x296b6165726228, %rax # imm = 0x296B6165726228
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
pushq $0x7
popq %rsi
jmp 0x445a
movq 0xa8(%rbx), %rdx
leaq 0x6107(%rip), %rsi      # 0xa541
leaq 0x10(%rsp), %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x21b0
movl %eax, %ebx
movq %r14, %rdi
callq 0x2030
leaq 0x10(%rsp), %rdi
movl %ebx, %esi
callq 0x4903
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 0x5f5c(%rip), %rdi      # 0xa3da
leaq 0x5f5f(%rip), %rsi      # 0xa3e4
leaq 0x5f60(%rip), %rcx      # 0xa3ec
movl $0x14d, %edx            # imm = 0x14D
callq 0x20d0
leaq 0x5f66(%rip), %rdi      # 0xa403
leaq 0x5f40(%rip), %rsi      # 0xa3e4
leaq 0x5f41(%rip), %rcx      # 0xa3ec
movl $0x14e, %edx            # imm = 0x14E
callq 0x20d0