// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, 0x70(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x97b6b
movl %eax, 0x64(%rsp)
xorl %eax, %eax
movl %eax, 0x4(%rsp)
movl %eax, 0x14(%rsp)
movdqa 0x5c6b9(%rip), %xmm0    # 0xed920
movl $0x1, %eax
movdqa 0x5c6bc(%rip), %xmm1    # 0xed930
movdqa 0x65e64(%rip), %xmm2    # 0xf70e0
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0x5c6d7(%rip), %xmm4    # 0xed960
movdqa %xmm0, %xmm5
pxor %xmm1, %xmm5
movdqa %xmm2, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm3, %xmm5
pand %xmm6, %xmm5
movd %xmm5, %ecx
testb $0x1, %cl
je 0x912b7
movl $0xfffffffe, 0x7c(%rsp,%rax,4) # imm = 0xFFFFFFFE
pextrw $0x4, %xmm5, %ecx
testb $0x1, %cl
je 0x912cc
movl $0xfffffffe, 0x80(%rsp,%rax,4) # imm = 0xFFFFFFFE
paddq %xmm4, %xmm0
addq $0x2, %rax
cmpq $0xb, %rax
jne 0x91289
movq %r14, 0x68(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x97c0f
movl %eax, %r14d
testl %eax, %eax
jne 0x91963
movq %r12, %rdi
xorl %esi, %esi
callq 0x97b6f
testl %eax, %eax
cmovnel %eax, %r14d
jne 0x91963
movl $0x0, 0x4c(%rsp)
movq $0x0, 0x40(%rsp)
movl $0x0, 0x34(%rsp)
xorl %edi, %edi
movq %r15, 0x78(%rsp)
movq %r12, 0x8(%rsp)
movq %r13, 0x18(%rsp)
testl %edi, %edi
jne 0x91948
movq %r12, %rdi
callq 0x97b6b
cmpl 0x64(%rsp), %eax
jle 0x91946
movq %r12, %rdi
callq 0x97c14
movl %eax, %ebp
movq %r12, %rdi
callq 0x97c28
movq %rax, %rbx
cmpl $0x1, %ebp
je 0x913dc
testl %ebp, %ebp
jne 0x91978
movl (%rbx), %eax
cmpq $0x3, %rax
ja 0x91997
leaq 0x65cd8(%rip), %rcx     # 0xf705c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rbx
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0x97c0f
movb $0x1, %r15b
testl %eax, %eax
jne 0x9164a
movq %r12, %rdi
xorl %esi, %esi
callq 0x97b6f
testl %eax, %eax
jne 0x9164a
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x97c0f
testl %eax, %eax
jne 0x9164a
movq %r12, %rdi
xorl %esi, %esi
callq 0x97b6f
jmp 0x9164a
movq 0x8(%rbx), %r13
movq %r12, %rdi
callq 0x97c14
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x8(%r13)
movq %rbx, 0x50(%rsp)
movl %eax, 0x60(%rsp)
jg 0x91409
xorl %edi, %edi
cmpl $0x2, 0xc(%r13)
jl 0x9175e
movl %r14d, %r12d
movq $0x0, 0x28(%rsp)
movl 0x8(%r13), %ebx
testl %ebx, %ebx
jle 0x914c3
xorl %r14d, %r14d
movq $0x0, 0x20(%rsp)
incl %r14d
xorl %ecx, %ecx
cmpl %ebx, %r14d
setge %cl
incl %ecx
movl 0x4(%rsp), %ebp
movq (%r13), %rdx
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %r8
movq %r15, %r9
leaq 0x14(%rsp), %rax
pushq %rax
leaq 0x60(%rsp), %rax
pushq %rax
callq 0x9257b
addq $0x10, %rsp
movl %eax, %edi
testl %eax, %eax
je 0x91476
xorl %ecx, %ecx
movl %edi, %r12d
jmp 0x914ac
movq 0x58(%rsp), %rax
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x91498
movq %rdi, %rbx
movq 0x18(%rsp), %rdi
movq %rax, %rdx
callq 0xb290c
movq %rbx, %rdi
testq %rax, %rax
setne %cl
movl $0xc, %edx
cmovel %edx, %r12d
movq %rax, 0x20(%rsp)
testb %cl, %cl
je 0x916e9
movl 0x8(%r13), %ebx
cmpl %ebx, %r14d
jl 0x9142d
jmp 0x914d0
movq $0x0, 0x20(%rsp)
movl %eax, %ebp
xorl %edi, %edi
cmpl $-0x1, 0xc(%r13)
je 0x91697
movq 0x28(%rsp), %r14
cmpl 0xc(%r13), %ebx
jge 0x91651
movl 0x4(%rsp), %ebp
movq (%r13), %rdx
xorl %r15d, %r15d
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %ecx, %ecx
leaq 0x4(%rsp), %r8
xorl %r9d, %r9d
leaq 0x14(%rsp), %rax
pushq %rax
leaq 0x60(%rsp), %rax
pushq %rax
callq 0x9257b
addq $0x10, %rsp
movl %eax, %edi
testl %eax, %eax
je 0x91529
movl %edi, %r12d
jmp 0x915a4
movq 0x58(%rsp), %rsi
testq %r14, %r14
movq %rdi, 0x38(%rsp)
je 0x9154a
movq 0x18(%rsp), %rdi
movq %r14, %rdx
callq 0xb290c
movq %rax, %r14
jmp 0x9154d
movq %rsi, %r14
testq %r14, %r14
je 0x91596
movq 0x18(%rsp), %r15
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xb282e
testq %rax, %rax
je 0x91596
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xb28cd
movq %rax, %r14
testq %rax, %rax
setne %r15b
movl $0xc, %eax
cmovel %eax, %r12d
jmp 0x9159f
xorl %r15d, %r15d
movl $0xc, %r12d
movq 0x38(%rsp), %rdi
testb %r15b, %r15b
je 0x916e4
incl %ebx
jmp 0x914e0
movq 0x8(%rbx), %rax
movq (%rax), %rcx
testq %rcx, %rcx
sets %dl
cmpq $-0x4, %rcx
setne %cl
xorl %edi, %edi
movb $0x1, %r15b
testb %cl, %dl
jne 0x918f7
movl 0x10(%rax), %ecx
addl 0x4(%rsp), %ecx
movl %ecx, 0x10(%rax)
movl 0x14(%rsp), %eax
cmpl %eax, %ecx
cmovlel %eax, %ecx
movl %ecx, 0x14(%rsp)
jmp 0x918f7
movq 0x8(%rbx), %rbp
movl 0x4(%rsp), %esi
movq %r12, %rdi
callq 0x97b6f
movb $0x1, %r15b
testl %eax, %eax
jne 0x9164a
movq %r12, %rdi
movq %rbx, %rsi
callq 0x97c0f
testl %eax, %eax
jne 0x9164a
movq %r12, %rdi
movl $0x1, %esi
callq 0x97b6f
testl %eax, %eax
jne 0x9164a
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x97c0f
testl %eax, %eax
jne 0x9164a
movq %r12, %rdi
xorl %esi, %esi
callq 0x97b6f
testl %eax, %eax
je 0x9192a
movl %eax, %edi
jmp 0x918f7
movq %r14, 0x28(%rsp)
movq 0x50(%rsp), %rbx
movl %ebp, 0x4(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
movl %r12d, %r14d
je 0x916dd
testq %rax, %rax
movq 0x8(%rsp), %r12
je 0x91725
movq %rdi, %r15
movq 0x18(%rsp), %rdi
movq %rax, %rdx
callq 0xb290c
movq %r15, %rdi
jmp 0x91728
movl 0x4(%rsp), %ebp
movq (%r13), %rdx
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
xorl %ecx, %ecx
leaq 0x4(%rsp), %r8
xorl %r9d, %r9d
leaq 0x14(%rsp), %rax
pushq %rax
leaq 0x30(%rsp), %rax
pushq %rax
callq 0x9257b
addq $0x10, %rsp
testl %eax, %eax
je 0x916f8
xorl %ecx, %ecx
movl %eax, %edi
movl %eax, %r14d
movq 0x8(%rsp), %r12
jmp 0x91756
movq 0x8(%rsp), %r12
jmp 0x91728
movq %r14, 0x28(%rsp)
xorl %ecx, %ecx
movq 0x8(%rsp), %rax
movl %r12d, %r14d
movq %rax, %r12
jmp 0x91756
movq 0x28(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
callq 0xb2875
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x91747
movq 0x50(%rsp), %rbx
xorl %edi, %edi
jmp 0x9165b
movq %rsi, %rax
testq %rax, %rax
je 0x9173d
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movl (%rax), %eax
movl %eax, (%rbx)
movb $0x1, %cl
jmp 0x91756
movl $0xc, %r14d
xorl %ecx, %ecx
jmp 0x91756
movl $0xc, %r14d
xorl %ecx, %ecx
movq 0x8(%rsp), %r12
xorl %edi, %edi
testb %cl, %cl
je 0x918dc
movl 0x4(%rsp), %eax
movl %eax, %ecx
subl 0x60(%rsp), %ecx
movl 0x34(%rsp), %edx
addl %ecx, %edx
decl 0x4c(%rsp)
movl %edx, 0x34(%rsp)
cmovel %edx, %eax
movl %eax, 0x4(%rsp)
movb $0x1, %r15b
cmpq $0x0, 0x18(%r13)
je 0x918f7
movl %r14d, 0x20(%rsp)
movq %rdi, %rbp
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl $0xfffffffb, %esi       # imm = 0xFFFFFFFB
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xb282e
testq %rax, %rax
je 0x918eb
movq %rax, %r14
movq 0x18(%r13), %rax
movq 0x8(%r14), %rcx
movq %rax, 0x18(%rcx)
movq 0x40(%rsp), %rax
leal 0x1(%rax), %ecx
movq 0x18(%r13), %rax
movl %ecx, 0x38(%rsp)
movl %ecx, 0x20(%rax)
movq %rbx, %rdi
movl $0xfffffffb, %esi       # imm = 0xFFFFFFFB
xorl %edx, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xb282e
testq %rax, %rax
je 0x918e1
movq %rax, %r12
movq %rbx, %r13
movl $0x24, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x955ee
testq %rax, %rax
je 0x918e1
movl 0xa0(%rsp), %ecx
movl %ecx, 0x20(%rax)
movdqa 0x80(%rsp), %xmm0
movdqa 0x90(%rsp), %xmm1
movdqu %xmm1, 0x10(%rax)
movdqu %xmm0, (%rax)
movq 0x8(%r12), %rcx
movq %rax, 0x18(%rcx)
movq 0x40(%rsp), %rcx
movl %ecx, 0x20(%rax)
movl $0x20, %edx
movq %r13, %rdi
movl $0x2, %esi
callq 0xb27c0
testq %rax, %rax
je 0x918e1
movq 0x50(%rsp), %rbx
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb290c
testq %rax, %rax
je 0x918e1
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xb290c
testq %rax, %rax
movl $0xc, %r14d
je 0x91907
movdqu (%rax), %xmm0
movdqu 0x10(%rax), %xmm1
movdqu 0x20(%rax), %xmm2
movdqu %xmm2, 0x20(%rbx)
movdqu %xmm1, 0x10(%rbx)
movdqu %xmm0, (%rbx)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movl (%rax), %eax
movl %eax, (%rbx)
movq 0x68(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpl (%rax), %ecx
movq %rbp, %rdi
jge 0x91911
movl 0x38(%rsp), %eax
jmp 0x91919
xorl %r15d, %r15d
jmp 0x918f7
xorl %r15d, %r15d
movq 0x8(%rsp), %r12
jmp 0x918ee
xorl %r15d, %r15d
movl $0xc, %r14d
movq %rbp, %rdi
testb %r15b, %r15b
movq 0x78(%rsp), %r15
jne 0x91335
jmp 0x91963
xorl %r15d, %r15d
movq 0x8(%rsp), %r12
jmp 0x918f4
movl 0x38(%rsp), %ecx
movl %ecx, (%rax)
movl %ecx, %eax
movq %rax, 0x40(%rsp)
movl 0x20(%rsp), %r14d
movq 0x8(%rsp), %r12
jmp 0x918f7
cmpl $0x1, 0x8(%rbp)
jg 0x91936
cmpl $0x2, 0xc(%rbp)
jl 0x9193e
movl $0x0, 0x4(%rsp)
incl 0x4c(%rsp)
xorl %edi, %edi
jmp 0x918f7
xorl %edi, %edi
movq 0x70(%rsp), %rcx
movl 0x34(%rsp), %edx
addl (%rcx), %edx
movl %edx, (%rcx)
movl 0x14(%rsp), %eax
cmpl %edx, %eax
cmovgl %eax, %edx
movl %edx, (%rcx)
movl %edi, %r14d
movl %r14d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x609ad(%rip), %rdi     # 0xf232c
leaq 0x6577d(%rip), %rsi     # 0xf7103
leaq 0x65818(%rip), %rcx     # 0xf71a5
movl $0x403, %edx            # imm = 0x403
callq 0xb400
leaq 0x6098e(%rip), %rdi     # 0xf232c
leaq 0x6575e(%rip), %rsi     # 0xf7103
leaq 0x657f9(%rip), %rcx     # 0xf71a5
movl $0x376, %edx            # imm = 0x376
callq 0xb400