// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-compile.c
// Function: tre_expand_ast
static reg_errcode_t
tre_expand_ast(tre_mem_t mem, tre_stack_t *stack, tre_ast_node_t *ast,
	       int *position, tre_tag_direction_t *tag_directions,
	       int *max_depth)
{
  reg_errcode_t status = REG_OK;
  int bottom = tre_stack_num_objects(stack);
  int pos_add = 0;
  int pos_add_total = 0;
  int max_pos = 0;
  /* Current approximate matching parameters. */
  int params[TRE_PARAM_LAST];
  /* Approximate parameter nesting level. */
  int params_depth = 0;
  int iter_depth = 0;
  int i;

  for (i = 0; i < TRE_PARAM_LAST; i++)
    params[i] = TRE_PARAM_DEFAULT;

  STACK_PUSHR(stack, voidptr, ast);
  STACK_PUSHR(stack, int, EXPAND_RECURSE);
  while (status == REG_OK && tre_stack_num_objects(stack) > bottom)
    {
      tre_ast_node_t *node;
      tre_expand_ast_symbol_t symbol;

      if (status != REG_OK)
	break;

      DPRINT(("pos_add %d\n", pos_add));

      symbol = (tre_expand_ast_symbol_t)tre_stack_pop_int(stack);
      node = tre_stack_pop_voidptr(stack);
      switch (symbol)
	{
	case EXPAND_RECURSE:
	  switch (node->type)
	    {
	    case LITERAL:
	      {
		tre_literal_t *lit= node->obj;
		if (!(IS_SPECIAL(lit)) || IS_BACKREF(lit))
		  {
		    lit->position += pos_add;
		    if (lit->position > max_pos)
		      max_pos = lit->position;
		  }
		break;
	      }
	    case UNION:
	      {
		tre_union_t *uni = node->obj;
		STACK_PUSHX(stack, voidptr, uni->right);
		STACK_PUSHX(stack, int, EXPAND_RECURSE);
		STACK_PUSHX(stack, voidptr, uni->left);
		STACK_PUSHX(stack, int, EXPAND_RECURSE);
		break;
	      }
	    case CATENATION:
	      {
		tre_catenation_t *cat = node->obj;
		STACK_PUSHX(stack, voidptr, cat->right);
		STACK_PUSHX(stack, int, EXPAND_RECURSE);
		STACK_PUSHX(stack, voidptr, cat->left);
		STACK_PUSHX(stack, int, EXPAND_RECURSE);
		break;
	      }
	    case ITERATION:
	      {
		tre_iteration_t *iter = node->obj;
		STACK_PUSHX(stack, int, pos_add);
		STACK_PUSHX(stack, voidptr, node);
		STACK_PUSHX(stack, int, EXPAND_AFTER_ITER);
		STACK_PUSHX(stack, voidptr, iter->arg);
		STACK_PUSHX(stack, int, EXPAND_RECURSE);
		/* If we are going to expand this node at EXPAND_AFTER_ITER
		   then don't increase the `pos' fields of the nodes now, it
		   will get done when expanding. */
		if (iter->min > 1 || iter->max > 1)
		  pos_add = 0;
		iter_depth++;
		DPRINT(("iter\n"));
		break;
	      }
	    default:
	      assert(0);
	      break;
	    }
	  break;
	case EXPAND_AFTER_ITER:
	  {
	    tre_iteration_t *iter = node->obj;
	    int pos_add_last;
	    pos_add = tre_stack_pop_int(stack);
	    pos_add_last = pos_add;
	    if (iter->min > 1 || iter->max > 1)
	      {
		tre_ast_node_t *seq1 = NULL, *seq2 = NULL;
		int j;
		int pos_add_save = pos_add;

		/* Create a catenated sequence of copies of the node. */
		for (j = 0; j < iter->min; j++)
		  {
		    tre_ast_node_t *copy;
		    /* Remove tags from all but the last copy. */
		    int flags = ((j + 1 < iter->min)
				 ? COPY_REMOVE_TAGS
				 : COPY_MAXIMIZE_FIRST_TAG);
		    DPRINT(("  pos_add %d\n", pos_add));
		    pos_add_save = pos_add;
		    status = tre_copy_ast(mem, stack, iter->arg, flags,
					  &pos_add, tag_directions, &copy,
					  &max_pos);
		    if (status != REG_OK)
		      return status;
		    if (seq1 != NULL)
		      seq1 = tre_ast_new_catenation(mem, seq1, copy);
		    else
		      seq1 = copy;
		    if (seq1 == NULL)
		      return REG_ESPACE;
		  }

		if (iter->max == -1)
		  {
		    /* No upper limit. */
		    pos_add_save = pos_add;
		    status = tre_copy_ast(mem, stack, iter->arg, 0,
					  &pos_add, NULL, &seq2, &max_pos);
		    if (status != REG_OK)
		      return status;
		    seq2 = tre_ast_new_iter(mem, seq2, 0, -1, 0);
		    if (seq2 == NULL)
		      return REG_ESPACE;
		  }
		else
		  {
		    for (j = iter->min; j < iter->max; j++)
		      {
			tre_ast_node_t *tmp, *copy;
			pos_add_save = pos_add;
			status = tre_copy_ast(mem, stack, iter->arg, 0,
					      &pos_add, NULL, &copy, &max_pos);
			if (status != REG_OK)
			  return status;
			if (seq2 != NULL)
			  seq2 = tre_ast_new_catenation(mem, copy, seq2);
			else
			  seq2 = copy;
			if (seq2 == NULL)
			  return REG_ESPACE;
			tmp = tre_ast_new_literal(mem, EMPTY, -1, -1);
			if (tmp == NULL)
			  return REG_ESPACE;
			seq2 = tre_ast_new_union(mem, tmp, seq2);
			if (seq2 == NULL)
			  return REG_ESPACE;
		      }
		  }

		pos_add = pos_add_save;
		if (seq1 == NULL)
		  seq1 = seq2;
		else if (seq2 != NULL)
		  seq1 = tre_ast_new_catenation(mem, seq1, seq2);
		if (seq1 == NULL)
		  return REG_ESPACE;
		node->obj = seq1->obj;
		node->type = seq1->type;
	      }

	    iter_depth--;
	    pos_add_total += pos_add - pos_add_last;
	    if (iter_depth == 0)
	      pos_add = pos_add_total;

	    /* If approximate parameters are specified, surround the result
	       with two parameter setting nodes.  The one on the left sets
	       the specified parameters, and the one on the right restores
	       the old parameters. */
	    if (iter->params)
	      {
		tre_ast_node_t *tmp_l, *tmp_r, *tmp_node, *node_copy;
		int *old_params;

		tmp_l = tre_ast_new_literal(mem, PARAMETER, 0, -1);
		if (!tmp_l)
		  return REG_ESPACE;
		((tre_literal_t *)tmp_l->obj)->u.params = iter->params;
		iter->params[TRE_PARAM_DEPTH] = params_depth + 1;
		tmp_r = tre_ast_new_literal(mem, PARAMETER, 0, -1);
		if (!tmp_r)
		  return REG_ESPACE;
		old_params = tre_mem_alloc(mem, sizeof(*old_params)
					   * TRE_PARAM_LAST);
		if (!old_params)
		  return REG_ESPACE;
		for (i = 0; i < TRE_PARAM_LAST; i++)
		  old_params[i] = params[i];
		((tre_literal_t *)tmp_r->obj)->u.params = old_params;
		old_params[TRE_PARAM_DEPTH] = params_depth;
		/* XXX - this is the only place where ast_new_node is
		   needed -- should be moved inside AST module. */
		node_copy = tre_ast_new_node(mem, ITERATION,
					     sizeof(tre_iteration_t));
		if (!node_copy)
		  return REG_ESPACE;
		node_copy->obj = node->obj;
		tmp_node = tre_ast_new_catenation(mem, tmp_l, node_copy);
		if (!tmp_node)
		  return REG_ESPACE;
		tmp_node = tre_ast_new_catenation(mem, tmp_node, tmp_r);
		if (!tmp_node)
		  return REG_ESPACE;
		/* Replace the contents of `node' with `tmp_node'. */
		memcpy(node, tmp_node, sizeof(*node));
		node->obj = tmp_node->obj;
		node->type = tmp_node->type;
		params_depth++;
		if (params_depth > *max_depth)
		  *max_depth = params_depth;
	      }
	    break;
	  }
	default:
	  assert(0);
	  break;
	}
    }

  *position += pos_add_total;

  /* `max_pos' should never be larger than `*position' if the above
     code works, but just an extra safeguard let's make sure
     `*position' is set large enough so enough memory will be
     allocated for the transition table. */
  if (max_pos > *position)
    *position = max_pos;

#ifdef TRE_DEBUG
  DPRINT(("Expanded AST:\n"));
  tre_ast_print(ast);
  DPRINT(("*position %d, max_pos %d\n", *position, max_pos));
#endif

  return status;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movq %rdx, 0x138(%rsp)
movq %rcx, 0x130(%rsp)
movq %r8, 0x128(%rsp)
movq %r9, 0x120(%rsp)
movl $0x0, 0x11c(%rsp)
movq 0x140(%rsp), %rdi
callq 0xc7920
movl %eax, 0x118(%rsp)
movl $0x0, 0x114(%rsp)
movl $0x0, 0x110(%rsp)
movl $0x0, 0x10c(%rsp)
movl $0x0, 0xdc(%rsp)
movl $0x0, 0xd8(%rsp)
movl $0x0, 0xd4(%rsp)
cmpl $0x9, 0xd4(%rsp)
jge 0xbbb48
movslq 0xd4(%rsp), %rax
movl $0xfffffffe, 0xe0(%rsp,%rax,4) # imm = 0xFFFFFFFE
movl 0xd4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
jmp 0xbbb18
movq 0x140(%rsp), %rdi
movq 0x138(%rsp), %rsi
callq 0xc7aa0
movl %eax, 0xd0(%rsp)
cmpl $0x0, 0xd0(%rsp)
je 0xbbb81
movl 0xd0(%rsp), %eax
movl %eax, 0x154(%rsp)
jmp 0xbc725
movq 0x140(%rsp), %rdi
xorl %esi, %esi
callq 0xc7930
movl %eax, 0xcc(%rsp)
cmpl $0x0, 0xcc(%rsp)
je 0xbbbb4
movl 0xcc(%rsp), %eax
movl %eax, 0x154(%rsp)
jmp 0xbc725
jmp 0xbbbb6
xorl %eax, %eax
cmpl $0x0, 0x11c(%rsp)
movb %al, 0x27(%rsp)
jne 0xbbbe1
movq 0x140(%rsp), %rdi
callq 0xc7920
cmpl 0x118(%rsp), %eax
setg %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xbbbee
jmp 0xbc6e0
cmpl $0x0, 0x11c(%rsp)
je 0xbbbfd
jmp 0xbc6e0
jmp 0xbbbff
jmp 0xbbc01
movq 0x140(%rsp), %rdi
callq 0xc7ad0
movl %eax, 0xbc(%rsp)
movq 0x140(%rsp), %rdi
callq 0xc7b00
movq %rax, 0xc0(%rsp)
movl 0xbc(%rsp), %eax
movl %eax, 0x20(%rsp)
testl %eax, %eax
je 0xbbc4d
jmp 0xbbc3b
movl 0x20(%rsp), %eax
subl $0x1, %eax
je 0xbbfab
jmp 0xbc6bc
movq 0xc0(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x18(%rsp)
subq $0x3, %rax
ja 0xbbf87
movq 0x18(%rsp), %rax
leaq 0xb94d6(%rip), %rcx     # 0x175148
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
cmpq $0x0, (%rax)
jge 0xbbcab
movq 0xb0(%rsp), %rax
cmpq $-0x4, (%rax)
jne 0xbbce8
movl 0x114(%rsp), %ecx
movq 0xb0(%rsp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq 0xb0(%rsp), %rax
movl 0x10(%rax), %eax
cmpl 0x10c(%rsp), %eax
jle 0xbbce6
movq 0xb0(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x10c(%rsp)
jmp 0xbbce8
jmp 0xbbfa6
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xa8(%rsp)
movq 0x140(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xc7aa0
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbd30
jmp 0xbbfa6
movq 0x140(%rsp), %rdi
xorl %esi, %esi
callq 0xc7930
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbd55
jmp 0xbbfa6
movq 0x140(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq (%rax), %rsi
callq 0xc7aa0
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbd83
jmp 0xbbfa6
movq 0x140(%rsp), %rdi
xorl %esi, %esi
callq 0xc7930
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbda8
jmp 0xbbfa6
jmp 0xbbfa6
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0x140(%rsp), %rdi
movq 0xa0(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xc7aa0
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbdf0
jmp 0xbbfa6
movq 0x140(%rsp), %rdi
xorl %esi, %esi
callq 0xc7930
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbe15
jmp 0xbbfa6
movq 0x140(%rsp), %rdi
movq 0xa0(%rsp), %rax
movq (%rax), %rsi
callq 0xc7aa0
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbe43
jmp 0xbbfa6
movq 0x140(%rsp), %rdi
xorl %esi, %esi
callq 0xc7930
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbe68
jmp 0xbbfa6
jmp 0xbbfa6
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x98(%rsp)
movq 0x140(%rsp), %rdi
movl 0x114(%rsp), %esi
callq 0xc7930
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbeab
jmp 0xbbfa6
movq 0x140(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0xc7aa0
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbed6
jmp 0xbbfa6
movq 0x140(%rsp), %rdi
movl $0x1, %esi
callq 0xc7930
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbefe
jmp 0xbbfa6
movq 0x140(%rsp), %rdi
movq 0x98(%rsp), %rax
movq (%rax), %rsi
callq 0xc7aa0
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbf29
jmp 0xbbfa6
movq 0x140(%rsp), %rdi
xorl %esi, %esi
callq 0xc7930
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbbf4b
jmp 0xbbfa6
movq 0x98(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jg 0xbbf67
movq 0x98(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jle 0xbbf72
movl $0x0, 0x114(%rsp)
movl 0xd8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd8(%rsp)
jmp 0xbbf85
jmp 0xbbfa6
leaq 0xb3f2d(%rip), %rdi     # 0x16febb
leaq 0xb9276(%rip), %rsi     # 0x17520b
movl $0x376, %edx            # imm = 0x376
leaq 0xb930c(%rip), %rcx     # 0x1752ad
callq 0xb3e0
jmp 0xbc6db
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x90(%rsp)
movq 0x140(%rsp), %rdi
callq 0xc7ad0
movl %eax, 0x114(%rsp)
movl 0x114(%rsp), %eax
movl %eax, 0x8c(%rsp)
movq 0x90(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jg 0xbc001
movq 0x90(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jle 0xbc3ff
movq $0x0, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
movl 0x114(%rsp), %eax
movl %eax, 0x70(%rsp)
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
movq 0x90(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xbc147
movl 0x74(%rsp), %edx
addl $0x1, %edx
movq 0x90(%rsp), %rax
movl 0x8(%rax), %esi
movl $0x2, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, 0x64(%rsp)
jmp 0xbc065
movl 0x114(%rsp), %eax
movl %eax, 0x70(%rsp)
movq 0x148(%rsp), %rdi
movq 0x140(%rsp), %rsi
movq 0x90(%rsp), %rax
movq (%rax), %rdx
movl 0x64(%rsp), %ecx
movq 0x128(%rsp), %r9
leaq 0x114(%rsp), %r8
leaq 0x68(%rsp), %r10
leaq 0x10c(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xbddb0
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbc0de
movl 0x11c(%rsp), %eax
movl %eax, 0x154(%rsp)
jmp 0xbc725
cmpq $0x0, 0x80(%rsp)
je 0xbc10d
movq 0x148(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0xfc380
movq %rax, 0x80(%rsp)
jmp 0xbc11a
movq 0x68(%rsp), %rax
movq %rax, 0x80(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0xbc135
movl $0xc, 0x154(%rsp)
jmp 0xbc725
jmp 0xbc137
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0xbc029
movq 0x90(%rsp), %rax
cmpl $-0x1, 0xc(%rax)
jne 0xbc20c
movl 0x114(%rsp), %eax
movl %eax, 0x70(%rsp)
movq 0x148(%rsp), %rdi
movq 0x140(%rsp), %rsi
movq 0x90(%rsp), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
leaq 0x114(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
leaq 0x78(%rsp), %r10
leaq 0x10c(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xbddb0
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbc1cd
movl 0x11c(%rsp), %eax
movl %eax, 0x154(%rsp)
jmp 0xbc725
movq 0x148(%rsp), %rdi
movq 0x78(%rsp), %rsi
xorl %r8d, %r8d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %r8d, %edx
callq 0xfc230
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0xbc207
movl $0xc, 0x154(%rsp)
jmp 0xbc725
jmp 0xbc367
movq 0x90(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
movq 0x90(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0xbc365
movl 0x114(%rsp), %eax
movl %eax, 0x70(%rsp)
movq 0x148(%rsp), %rdi
movq 0x140(%rsp), %rsi
movq 0x90(%rsp), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
leaq 0x114(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
leaq 0x50(%rsp), %r10
leaq 0x10c(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xbddb0
movl %eax, 0x11c(%rsp)
cmpl $0x0, 0x11c(%rsp)
je 0xbc2a4
movl 0x11c(%rsp), %eax
movl %eax, 0x154(%rsp)
jmp 0xbc725
cmpq $0x0, 0x78(%rsp)
je 0xbc2ca
movq 0x148(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0xfc380
movq %rax, 0x78(%rsp)
jmp 0xbc2d4
movq 0x50(%rsp), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0xbc2ec
movl $0xc, 0x154(%rsp)
jmp 0xbc725
movq 0x148(%rsp), %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %esi
movl %ecx, %edx
callq 0xfc1a0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0xbc31f
movl $0xc, 0x154(%rsp)
jmp 0xbc725
movq 0x148(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0xfc2f0
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0xbc353
movl $0xc, 0x154(%rsp)
jmp 0xbc725
jmp 0xbc355
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0xbc21b
jmp 0xbc367
movl 0x70(%rsp), %eax
movl %eax, 0x114(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0xbc38c
movq 0x78(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0xbc3b8
cmpq $0x0, 0x78(%rsp)
je 0xbc3b6
movq 0x148(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0xfc380
movq %rax, 0x80(%rsp)
jmp 0xbc3b8
cmpq $0x0, 0x80(%rsp)
jne 0xbc3d3
movl $0xc, 0x154(%rsp)
jmp 0xbc725
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0xc0(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x80(%rsp), %rax
movl (%rax), %ecx
movq 0xc0(%rsp), %rax
movl %ecx, (%rax)
movl 0xd8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xd8(%rsp)
movl 0x114(%rsp), %eax
subl 0x8c(%rsp), %eax
addl 0x110(%rsp), %eax
movl %eax, 0x110(%rsp)
cmpl $0x0, 0xd8(%rsp)
jne 0xbc444
movl 0x110(%rsp), %eax
movl %eax, 0x114(%rsp)
movq 0x90(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xbc6ba
movq 0x148(%rsp), %rdi
movl $0xfffffffb, %esi       # imm = 0xFFFFFFFB
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xfc1a0
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0xbc48d
movl $0xc, 0x154(%rsp)
jmp 0xbc725
movq 0x90(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movl 0xdc(%rsp), %ecx
addl $0x1, %ecx
movq 0x90(%rsp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x20(%rax)
movq 0x148(%rsp), %rdi
movl $0xfffffffb, %esi       # imm = 0xFFFFFFFB
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xfc1a0
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0xbc4f5
movl $0xc, 0x154(%rsp)
jmp 0xbc725
movq 0x148(%rsp), %rdi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %edx
movl $0x24, %r8d
movl %ecx, %esi
callq 0xc3270
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xbc52d
movl $0xc, 0x154(%rsp)
jmp 0xbc725
movl $0x0, 0xd4(%rsp)
cmpl $0x9, 0xd4(%rsp)
jge 0xbc574
movslq 0xd4(%rsp), %rax
movl 0xe0(%rsp,%rax,4), %edx
movq 0x28(%rsp), %rax
movslq 0xd4(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xd4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
jmp 0xbc538
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movl 0xdc(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x148(%rsp), %rdi
movl $0x2, %esi
movl $0x20, %edx
callq 0xfc0e0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0xbc5c9
movl $0xc, 0x154(%rsp)
jmp 0xbc725
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x148(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0xfc380
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xbc612
movl $0xc, 0x154(%rsp)
jmp 0xbc725
movq 0x148(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0xfc380
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xbc646
movl $0xc, 0x154(%rsp)
jmp 0xbc725
movq 0xc0(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x30, %edx
callq 0xb500
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0xc0(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
movl (%rax), %ecx
movq 0xc0(%rsp), %rax
movl %ecx, (%rax)
movl 0xdc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xdc(%rsp)
movl 0xdc(%rsp), %eax
movq 0x120(%rsp), %rcx
cmpl (%rcx), %eax
jle 0xbc6b8
movl 0xdc(%rsp), %ecx
movq 0x120(%rsp), %rax
movl %ecx, (%rax)
jmp 0xbc6ba
jmp 0xbc6db
leaq 0xb37f8(%rip), %rdi     # 0x16febb
leaq 0xb8b41(%rip), %rsi     # 0x17520b
movl $0x403, %edx            # imm = 0x403
leaq 0xb8bd7(%rip), %rcx     # 0x1752ad
callq 0xb3e0
jmp 0xbbbb6
movl 0x110(%rsp), %ecx
movq 0x130(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl 0x10c(%rsp), %eax
movq 0x130(%rsp), %rcx
cmpl (%rcx), %eax
jle 0xbc717
movl 0x10c(%rsp), %ecx
movq 0x130(%rsp), %rax
movl %ecx, (%rax)
movl 0x11c(%rsp), %eax
movl %eax, 0x154(%rsp)
movl 0x154(%rsp), %eax
addq $0x158, %rsp            # imm = 0x158
retq
nopw %cs:(%rax,%rax)