// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/tre/lib/tre-parse.c
// Function: tre_parse_bound
static reg_errcode_t
tre_parse_bound(tre_parse_ctx_t *ctx, tre_ast_node_t **result)
{
  int min, max, i;
  int cost_ins, cost_del, cost_subst, cost_max;
  int limit_ins, limit_del, limit_subst, limit_err;
  const tre_char_t *r = ctx->re;
  const tre_char_t *start;
  int minimal = (ctx->cflags & REG_UNGREEDY) ? 1 : 0;
  int approx = 0;
  int costs_set = 0;
  int counts_set = 0;

  cost_ins = cost_del = cost_subst = cost_max = TRE_PARAM_UNSET;
  limit_ins = limit_del = limit_subst = limit_err = TRE_PARAM_UNSET;

  /* Parse number (minimum repetition count). */
  min = -1;
  if (r < ctx->re_end && *r >= L'0' && *r <= L'9') {
    DPRINT(("tre_parse:	  min count: '%.*" STRF "'\n", REST(r)));
    min = tre_parse_int(&r, ctx->re_end);
  }

  /* Parse comma and second number (maximum repetition count). */
  max = min;
  if (r < ctx->re_end && *r == CHAR_COMMA)
    {
      r++;
      DPRINT(("tre_parse:   max count: '%.*" STRF "'\n", REST(r)));
      max = tre_parse_int(&r, ctx->re_end);
    }

  /* Check that the repeat counts are sane. */
  if ((max >= 0 && min > max) || max > RE_DUP_MAX)
    return REG_BADBR;


  /*
   '{'
     optionally followed immediately by a number == minimum repcount
     optionally followed by , then a number == maximum repcount
      + then a number == maximum insertion count
      - then a number == maximum deletion count
      # then a number == maximum substitution count
      ~ then a number == maximum number of errors
      Any of +, -, # or ~ without followed by a number means that
      the maximum count/number of errors is infinite.

      An equation of the form
	Xi + Yd + Zs < C
      can be specified to set costs and the cost limit to a value
      different from the default value:
	- X is the cost of an insertion
	- Y is the cost of a deletion
	- Z is the cost of a substitution
	- C is the maximum cost

      If no count limit or cost is set for an operation, the operation
      is not allowed at all.
  */


  do {
    int done;
    start = r;

    /* Parse count limit settings */
    done = 0;
    if (!counts_set)
      while (r + 1 < ctx->re_end && !done)
	{
	  switch (*r)
	    {
	    case CHAR_PLUS:  /* Insert limit */
	      DPRINT(("tre_parse:   ins limit: '%.*" STRF "'\n", REST(r)));
	      r++;
	      limit_ins = tre_parse_int(&r, ctx->re_end);
	      if (limit_ins < 0)
		limit_ins = INT_MAX;
	      counts_set = 1;
	      break;
	    case CHAR_MINUS: /* Delete limit */
	      DPRINT(("tre_parse:   del limit: '%.*" STRF "'\n", REST(r)));
	      r++;
	      limit_del = tre_parse_int(&r, ctx->re_end);
	      if (limit_del < 0)
		limit_del = INT_MAX;
	      counts_set = 1;
	      break;
	    case CHAR_HASH:  /* Substitute limit */
	      DPRINT(("tre_parse: subst limit: '%.*" STRF "'\n", REST(r)));
	      r++;
	      limit_subst = tre_parse_int(&r, ctx->re_end);
	      if (limit_subst < 0)
		limit_subst = INT_MAX;
	      counts_set = 1;
	      break;
	    case CHAR_TILDE: /* Maximum number of changes */
	      DPRINT(("tre_parse: count limit: '%.*" STRF "'\n", REST(r)));
	      r++;
	      limit_err = tre_parse_int(&r, ctx->re_end);
	      if (limit_err < 0)
		limit_err = INT_MAX;
	      approx = 1;
	      break;
	    case CHAR_COMMA:
	      r++;
	      break;
	    case L' ':
	      r++;
	      break;
	    case L'}':
	      done = 1;
	      break;
	    default:
	      done = 1;
	      break;
	    }
	}

    /* Parse cost restriction equation. */
    done = 0;
    if (!costs_set)
      while (r + 1 < ctx->re_end && !done)
	{
	  switch (*r)
	    {
	    case CHAR_PLUS:
	    case L' ':
	      r++;
	      break;
	    case L'<':
	      DPRINT(("tre_parse:    max cost: '%.*" STRF "'\n", REST(r)));
	      r++;
	      while (*r == L' ')
		r++;
	      cost_max = tre_parse_int(&r, ctx->re_end);
	      if (cost_max < 0)
		cost_max = INT_MAX;
	      else
		cost_max--;
	      approx = 1;
	      break;
	    case CHAR_COMMA:
	      r++;
	      done = 1;
	      break;
	    default:
	      if (*r >= L'0' && *r <= L'9')
		{
#ifdef TRE_DEBUG
		  const tre_char_t *sr = r;
#endif /* TRE_DEBUG */
		  int cost = tre_parse_int(&r, ctx->re_end);
		  /* XXX - make sure r is not past end. */
		  switch (*r)
		    {
		    case L'i':	/* Insert cost */
		      DPRINT(("tre_parse:    ins cost: '%.*" STRF "'\n",
			      REST(sr)));
		      r++;
		      cost_ins = cost;
		      costs_set = 1;
		      break;
		    case L'd':	/* Delete cost */
		      DPRINT(("tre_parse:    del cost: '%.*" STRF "'\n",
			      REST(sr)));
		      r++;
		      cost_del = cost;
		      costs_set = 1;
		      break;
		    case L's':	/* Substitute cost */
		      DPRINT(("tre_parse:  subst cost: '%.*" STRF "'\n",
			      REST(sr)));
		      r++;
		      cost_subst = cost;
		      costs_set = 1;
		      break;
		    default:
		      return REG_BADBR;
		    }
		}
	      else
		{
		  done = 1;
		  break;
		}
	    }
	}
  } while (start != r);

  /* Missing }. */
  if (r >= ctx->re_end)
    return REG_EBRACE;

  /* Empty contents of {}. */
  if (r == ctx->re)
    return REG_BADBR;

  /* Parse the ending '}' or '\}'.*/
  if (ctx->cflags & REG_EXTENDED)
    {
      if (r >= ctx->re_end || *r != CHAR_RBRACE)
	return REG_BADBR;
      r++;
    }
  else
    {
      if (r + 1 >= ctx->re_end
	  || *r != CHAR_BACKSLASH
	  || *(r + 1) != CHAR_RBRACE)
	return REG_BADBR;
      r += 2;
    }


  /* Parse trailing '?' marking minimal repetition. */
  if (r < ctx->re_end)
    {
      if (*r == CHAR_QUESTIONMARK)
	{
	  minimal = !(ctx->cflags & REG_UNGREEDY);
	  r++;
	}
      else if (*r == CHAR_STAR || *r == CHAR_PLUS)
	{
	  /* These are reserved for future extensions. */
	  return REG_BADRPT;
	}
    }

  /* Create the AST node(s). */
  if (min == 0 && max == 0)
    {
      *result = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
      if (*result == NULL)
	return REG_ESPACE;
    }
  else
    {
      if (min < 0 && max < 0)
	/* Only approximate parameters set, no repetitions. */
	min = max = 1;

      *result = tre_ast_new_iter(ctx->mem, *result, min, max, minimal);
      if (!*result)
	return REG_ESPACE;

      /* If approximate matching parameters are set, add them to the
	 iteration node. */
      if (approx || costs_set || counts_set)
	{
	  int *params;
	  tre_iteration_t *iter = (*result)->obj;

	  if (costs_set || counts_set)
	    {
	      if (limit_ins == TRE_PARAM_UNSET)
		{
		  if (cost_ins == TRE_PARAM_UNSET)
		    limit_ins = 0;
		  else
		    limit_ins = INT_MAX;
		}

	      if (limit_del == TRE_PARAM_UNSET)
		{
		  if (cost_del == TRE_PARAM_UNSET)
		    limit_del = 0;
		  else
		    limit_del = INT_MAX;
		}

	      if (limit_subst == TRE_PARAM_UNSET)
		{
		  if (cost_subst == TRE_PARAM_UNSET)
		    limit_subst = 0;
		  else
		    limit_subst = INT_MAX;
		}
	    }

	  if (cost_max == TRE_PARAM_UNSET)
	    cost_max = INT_MAX;
	  if (limit_err == TRE_PARAM_UNSET)
	    limit_err = INT_MAX;

	  ctx->have_approx = 1;
	  params = tre_mem_alloc(ctx->mem, sizeof(*params) * TRE_PARAM_LAST);
	  if (!params)
	    return REG_ESPACE;
	  for (i = 0; i < TRE_PARAM_LAST; i++)
	    params[i] = TRE_PARAM_UNSET;
	  params[TRE_PARAM_COST_INS] = cost_ins;
	  params[TRE_PARAM_COST_DEL] = cost_del;
	  params[TRE_PARAM_COST_SUBST] = cost_subst;
	  params[TRE_PARAM_COST_MAX] = cost_max;
	  params[TRE_PARAM_MAX_INS] = limit_ins;
	  params[TRE_PARAM_MAX_DEL] = limit_del;
	  params[TRE_PARAM_MAX_SUBST] = limit_subst;
	  params[TRE_PARAM_MAX_ERR] = limit_err;
	  iter->params = params;
	}
    }

  DPRINT(("tre_parse_bound: min %d, max %d, costs [%d,%d,%d, total %d], "
	  "limits [%d,%d,%d, total %d]\n",
	  min, max, cost_ins, cost_del, cost_subst, cost_max,
	  limit_ins, limit_del, limit_subst, limit_err));


  ctx->re = r;
  return REG_OK;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x98(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x98(%rsp), %rax
movl 0x44(%rax), %edx
andl $0x40, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x4c(%rsp)
movl $0x0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl $0x0, 0x40(%rsp)
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x78(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x7c(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x80(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x68(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x6c(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x70(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x8c(%rsp) # imm = 0xFFFFFFFF
movq 0x58(%rsp), %rax
movq 0x98(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0xc5bfb
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xc5bfb
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x39, %eax
jg 0xc5bfb
jmp 0xc5bdc
jmp 0xc5bde
movq 0x98(%rsp), %rax
movq 0x28(%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0xc6c40
movl %eax, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
movl %eax, 0x88(%rsp)
movq 0x58(%rsp), %rax
movq 0x98(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0xc5c56
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2c, %eax
jne 0xc5c56
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xc5c39
movq 0x98(%rsp), %rax
movq 0x28(%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0xc6c40
movl %eax, 0x88(%rsp)
cmpl $0x0, 0x88(%rsp)
jl 0xc5c70
movl 0x8c(%rsp), %eax
cmpl 0x88(%rsp), %eax
jg 0xc5c7d
cmpl $0xff, 0x88(%rsp)
jle 0xc5c8d
movl $0xa, 0xa4(%rsp)
jmp 0xc64f1
jmp 0xc5c8f
movq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movl $0x0, 0x3c(%rsp)
cmpl $0x0, 0x40(%rsp)
jne 0xc5ea5
jmp 0xc5cae
movq 0x58(%rsp), %rcx
addq $0x1, %rcx
movq 0x98(%rsp), %rdx
xorl %eax, %eax
cmpq 0x28(%rdx), %rcx
movb %al, 0x27(%rsp)
jae 0xc5cd9
cmpl $0x0, 0x3c(%rsp)
setne %al
xorb $-0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xc5ce6
jmp 0xc5ea3
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0x20(%rsp)
subl $0x20, %eax
je 0xc5e7c
jmp 0xc5cfd
movl 0x20(%rsp), %eax
subl $0x23, %eax
je 0xc5de2
jmp 0xc5d0c
movl 0x20(%rsp), %eax
subl $0x2b, %eax
je 0xc5d52
jmp 0xc5d17
movl 0x20(%rsp), %eax
subl $0x2c, %eax
je 0xc5e6c
jmp 0xc5d26
movl 0x20(%rsp), %eax
subl $0x2d, %eax
je 0xc5d9a
jmp 0xc5d31
movl 0x20(%rsp), %eax
subl $0x7d, %eax
je 0xc5e8c
jmp 0xc5d40
movl 0x20(%rsp), %eax
subl $0x7e, %eax
je 0xc5e27
jmp 0xc5e96
jmp 0xc5d54
jmp 0xc5d56
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movq 0x98(%rsp), %rax
movq 0x28(%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0xc6c40
movl %eax, 0x70(%rsp)
cmpl $0x0, 0x70(%rsp)
jge 0xc5d8d
movl $0x7fffffff, 0x70(%rsp) # imm = 0x7FFFFFFF
movl $0x1, 0x40(%rsp)
jmp 0xc5e9e
jmp 0xc5d9c
jmp 0xc5d9e
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movq 0x98(%rsp), %rax
movq 0x28(%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0xc6c40
movl %eax, 0x6c(%rsp)
cmpl $0x0, 0x6c(%rsp)
jge 0xc5dd5
movl $0x7fffffff, 0x6c(%rsp) # imm = 0x7FFFFFFF
movl $0x1, 0x40(%rsp)
jmp 0xc5e9e
jmp 0xc5de4
jmp 0xc5de6
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movq 0x98(%rsp), %rax
movq 0x28(%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0xc6c40
movl %eax, 0x68(%rsp)
cmpl $0x0, 0x68(%rsp)
jge 0xc5e1d
movl $0x7fffffff, 0x68(%rsp) # imm = 0x7FFFFFFF
movl $0x1, 0x40(%rsp)
jmp 0xc5e9e
jmp 0xc5e29
jmp 0xc5e2b
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movq 0x98(%rsp), %rax
movq 0x28(%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0xc6c40
movl %eax, 0x64(%rsp)
cmpl $0x0, 0x64(%rsp)
jge 0xc5e62
movl $0x7fffffff, 0x64(%rsp) # imm = 0x7FFFFFFF
movl $0x1, 0x48(%rsp)
jmp 0xc5e9e
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xc5e9e
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xc5e9e
movl $0x1, 0x3c(%rsp)
jmp 0xc5e9e
movl $0x1, 0x3c(%rsp)
jmp 0xc5cae
jmp 0xc5ea5
movl $0x0, 0x3c(%rsp)
cmpl $0x0, 0x44(%rsp)
jne 0xc60bb
jmp 0xc5eba
movq 0x58(%rsp), %rcx
addq $0x1, %rcx
movq 0x98(%rsp), %rdx
xorl %eax, %eax
cmpq 0x28(%rdx), %rcx
movb %al, 0x1f(%rsp)
jae 0xc5ee5
cmpl $0x0, 0x3c(%rsp)
setne %al
xorb $-0x1, %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xc5ef2
jmp 0xc60b9
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
addl $-0x20, %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x1c, %eax
ja 0xc5fc2
movq 0x10(%rsp), %rax
leaq 0xaf953(%rip), %rcx     # 0x17586c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xc60b4
jmp 0xc5f37
jmp 0xc5f39
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0xc5f64
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xc5f47
movq 0x98(%rsp), %rax
movq 0x28(%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0xc6c40
movl %eax, 0x74(%rsp)
cmpl $0x0, 0x74(%rsp)
jge 0xc5f8f
movl $0x7fffffff, 0x74(%rsp) # imm = 0x7FFFFFFF
jmp 0xc5f9a
movl 0x74(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x74(%rsp)
movl $0x1, 0x48(%rsp)
jmp 0xc60b4
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0xc60b4
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jl 0xc60a8
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x39, %eax
jg 0xc60a8
movq 0x98(%rsp), %rax
movq 0x28(%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0xc6c40
movl %eax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x64, %eax
je 0xc604e
jmp 0xc6011
movl 0xc(%rsp), %eax
subl $0x69, %eax
je 0xc6027
jmp 0xc601c
movl 0xc(%rsp), %eax
subl $0x73, %eax
je 0xc6072
jmp 0xc6096
jmp 0xc6029
jmp 0xc602b
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x80(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xc60a6
jmp 0xc6050
jmp 0xc6052
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x7c(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xc60a6
jmp 0xc6074
jmp 0xc6076
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x78(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xc60a6
movl $0xa, 0xa4(%rsp)
jmp 0xc64f1
jmp 0xc60b2
movl $0x1, 0x3c(%rsp)
jmp 0xc60b4
jmp 0xc60b4
jmp 0xc5eba
jmp 0xc60bb
jmp 0xc60bd
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
jne 0xc5c8f
movq 0x58(%rsp), %rax
movq 0x98(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0xc60f0
movl $0x9, 0xa4(%rsp)
jmp 0xc64f1
movq 0x58(%rsp), %rax
movq 0x98(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0xc6113
movl $0xa, 0xa4(%rsp)
jmp 0xc64f1
movq 0x98(%rsp), %rax
movl 0x44(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc6166
movq 0x58(%rsp), %rax
movq 0x98(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0xc6146
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x7d, %eax
je 0xc6156
movl $0xa, 0xa4(%rsp)
jmp 0xc64f1
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xc61b6
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq 0x98(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0xc6198
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x5c, %eax
jne 0xc6198
movq 0x58(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x7d, %eax
je 0xc61a8
movl $0xa, 0xa4(%rsp)
jmp 0xc64f1
movq 0x58(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq 0x98(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0xc6233
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x3f, %eax
jne 0xc6205
movq 0x98(%rsp), %rax
movl 0x44(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4c(%rsp)
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xc6231
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2a, %eax
je 0xc621f
movq 0x58(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2b, %eax
jne 0xc622f
movl $0xd, 0xa4(%rsp)
jmp 0xc64f1
jmp 0xc6231
jmp 0xc6233
cmpl $0x0, 0x8c(%rsp)
jne 0xc6291
cmpl $0x0, 0x88(%rsp)
jne 0xc6291
movq 0x98(%rsp), %rax
movq (%rax), %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %esi
movl %ecx, %edx
callq 0xfc1a0
movq %rax, %rcx
movq 0x90(%rsp), %rax
movq %rcx, (%rax)
movq 0x90(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xc628c
movl $0xc, 0xa4(%rsp)
jmp 0xc64f1
jmp 0xc64d1
cmpl $0x0, 0x8c(%rsp)
jge 0xc62bb
cmpl $0x0, 0x88(%rsp)
jge 0xc62bb
movl $0x1, 0x88(%rsp)
movl $0x1, 0x8c(%rsp)
movq 0x98(%rsp), %rax
movq (%rax), %rdi
movq 0x90(%rsp), %rax
movq (%rax), %rsi
movl 0x8c(%rsp), %edx
movl 0x88(%rsp), %ecx
movl 0x4c(%rsp), %r8d
callq 0xfc230
movq %rax, %rcx
movq 0x90(%rsp), %rax
movq %rcx, (%rax)
movq 0x90(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xc6315
movl $0xc, 0xa4(%rsp)
jmp 0xc64f1
cmpl $0x0, 0x48(%rsp)
jne 0xc632e
cmpl $0x0, 0x44(%rsp)
jne 0xc632e
cmpl $0x0, 0x40(%rsp)
je 0xc64cf
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x44(%rsp)
jne 0xc6350
cmpl $0x0, 0x40(%rsp)
je 0xc63bb
cmpl $-0x1, 0x70(%rsp)
jne 0xc6375
cmpl $-0x1, 0x80(%rsp)
jne 0xc636b
movl $0x0, 0x70(%rsp)
jmp 0xc6373
movl $0x7fffffff, 0x70(%rsp) # imm = 0x7FFFFFFF
jmp 0xc6375
cmpl $-0x1, 0x6c(%rsp)
jne 0xc6397
cmpl $-0x1, 0x7c(%rsp)
jne 0xc638d
movl $0x0, 0x6c(%rsp)
jmp 0xc6395
movl $0x7fffffff, 0x6c(%rsp) # imm = 0x7FFFFFFF
jmp 0xc6397
cmpl $-0x1, 0x68(%rsp)
jne 0xc63b9
cmpl $-0x1, 0x78(%rsp)
jne 0xc63af
movl $0x0, 0x68(%rsp)
jmp 0xc63b7
movl $0x7fffffff, 0x68(%rsp) # imm = 0x7FFFFFFF
jmp 0xc63b9
jmp 0xc63bb
cmpl $-0x1, 0x74(%rsp)
jne 0xc63ca
movl $0x7fffffff, 0x74(%rsp) # imm = 0x7FFFFFFF
cmpl $-0x1, 0x64(%rsp)
jne 0xc63d9
movl $0x7fffffff, 0x64(%rsp) # imm = 0x7FFFFFFF
movq 0x98(%rsp), %rax
movl $0x1, 0x40(%rax)
movq 0x98(%rsp), %rax
movq (%rax), %rdi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %edx
movl $0x24, %r8d
movl %ecx, %esi
callq 0xc3270
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0xc6423
movl $0xc, 0xa4(%rsp)
jmp 0xc64f1
movl $0x0, 0x84(%rsp)
cmpl $0x9, 0x84(%rsp)
jge 0xc645f
movq 0x30(%rsp), %rax
movslq 0x84(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0xc642e
movl 0x80(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movl 0x7c(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x78(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x74(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x70(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x6c(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x14(%rax)
movl 0x68(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0x64(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0xc64d1
jmp 0xc64d3
jmp 0xc64d5
movq 0x58(%rsp), %rcx
movq 0x98(%rsp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq