// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-match-parallel.c
// Function: tre_tnfa_run_parallel
reg_errcode_t
tre_tnfa_run_parallel(const tre_tnfa_t *tnfa, const void *string, int len,
		      tre_str_type_t type, int *match_tags, int eflags,
		      int *match_end_ofs)
{
  /* State variables required by GET_NEXT_WCHAR. */
  tre_char_t prev_c = 0, next_c = 0;
  const char *str_byte = string;
  int pos = -1;
  unsigned int pos_add_next = 1;
#ifdef TRE_WCHAR
  const wchar_t *str_wide = string;
#ifdef TRE_MBSTATE
  mbstate_t mbstate;
#endif /* TRE_MBSTATE */
#endif /* TRE_WCHAR */
  int reg_notbol = eflags & REG_NOTBOL;
  int reg_noteol = eflags & REG_NOTEOL;
  int reg_newline = tnfa->cflags & REG_NEWLINE;
  int str_user_end = 0;

  char *buf;
  tre_tnfa_transition_t *trans_i;
  tre_tnfa_reach_t *reach, *reach_next, *reach_i, *reach_next_i;
  tre_reach_pos_t *reach_pos;
  int *tag_i;
  int num_tags, i;

  int match_eo = -1;	   /* end offset of match (-1 if no match found yet) */
  int new_match = 0;
  int *tmp_tags = NULL;
  int *tmp_iptr;

#ifdef TRE_MBSTATE
  memset(&mbstate, '\0', sizeof(mbstate));
#endif /* TRE_MBSTATE */

  DPRINT(("tre_tnfa_run_parallel, input type %d\n", type));

  if (!match_tags)
    num_tags = 0;
  else
    num_tags = tnfa->num_tags;

  /* Allocate memory for temporary data required for matching.	This needs to
     be done for every matching operation to be thread safe.  This allocates
     everything in a single large block from the stack frame using alloca()
     or with malloc() if alloca is unavailable. */
  {
    int tbytes, rbytes, pbytes, xbytes, total_bytes;
    char *tmp_buf;
    /* Compute the length of the block we need. */
    tbytes = sizeof(*tmp_tags) * num_tags;
    rbytes = sizeof(*reach_next) * (tnfa->num_states + 1);
    pbytes = sizeof(*reach_pos) * tnfa->num_states;
    xbytes = sizeof(int) * num_tags;
    total_bytes =
      (sizeof(GtWord) - 1) * 4 /* for alignment paddings */
      + (rbytes + xbytes * tnfa->num_states) * 2 + tbytes + pbytes;

    /* Allocate the memory. */
#ifdef TRE_USE_ALLOCA
    buf = alloca(total_bytes);
#else /* !TRE_USE_ALLOCA */
    buf = xmalloc((unsigned)total_bytes);
#endif /* !TRE_USE_ALLOCA */
    if (buf == NULL)
      return REG_ESPACE;
    memset(buf, 0, (size_t)total_bytes);

    /* Get the various pointers within tmp_buf (properly aligned). */
    tmp_tags = (void *)buf;
    tmp_buf = buf + tbytes;
    tmp_buf += ALIGN(tmp_buf, GtWord);
    reach_next = (void *)tmp_buf;
    tmp_buf += rbytes;
    tmp_buf += ALIGN(tmp_buf, GtWord);
    reach = (void *)tmp_buf;
    tmp_buf += rbytes;
    tmp_buf += ALIGN(tmp_buf, GtWord);
    reach_pos = (void *)tmp_buf;
    tmp_buf += pbytes;
    tmp_buf += ALIGN(tmp_buf, GtWord);
    for (i = 0; i < tnfa->num_states; i++)
      {
	reach[i].tags = (void *)tmp_buf;
	tmp_buf += xbytes;
	reach_next[i].tags = (void *)tmp_buf;
	tmp_buf += xbytes;
      }
  }

  for (i = 0; i < tnfa->num_states; i++)
    reach_pos[i].pos = -1;

  /* If only one character can start a match, find it first. */
  if (tnfa->first_char >= 0 && type == STR_BYTE && str_byte)
    {
      const char *orig_str = str_byte;
      int first = tnfa->first_char;

      if (len >= 0)
	str_byte = memchr(orig_str, first, (size_t)len);
      else
	str_byte = strchr(orig_str, first);
      if (str_byte == NULL)
	{
#ifndef TRE_USE_ALLOCA
	  if (buf)
	    xfree(buf);
#endif /* !TRE_USE_ALLOCA */
	  return REG_NOMATCH;
	}
      DPRINT(("skipped %lu chars\n", (GtUword)(str_byte - orig_str)));
      if (str_byte >= orig_str + 1)
	prev_c = (unsigned char)*(str_byte - 1);
      next_c = (unsigned char)*str_byte;
      pos = str_byte - orig_str;
      if (len < 0 || pos < len)
	str_byte++;
    }
  else
    {
      GET_NEXT_WCHAR();
      pos = 0;
    }

#if 0
  /* Skip over characters that cannot possibly be the first character
     of a match. */
  if (tnfa->firstpos_chars != NULL)
    {
      char *chars = tnfa->firstpos_chars;

      if (len < 0)
	{
	  const char *orig_str = str_byte;
	  /* XXX - use strpbrk() and wcspbrk() because they might be
	     optimized for the target architecture.  Try also strcspn()
	     and wcscspn() and compare the speeds. */
	  while (next_c != L'\0' && !chars[next_c])
	    {
	      next_c = *str_byte++;
	    }
	  prev_c = *(str_byte - 2);
	  pos += str_byte - orig_str;
	  DPRINT(("skipped %d chars\n", str_byte - orig_str));
	}
      else
	{
	  while (pos <= len && !chars[next_c])
	    {
	      prev_c = next_c;
	      next_c = (unsigned char)(*str_byte++);
	      pos++;
	    }
	}
    }
#endif

  DPRINT(("length: %d\n", len));
  DPRINT(("pos:chr/code | states and tags\n"));
  DPRINT(("-------------+------------------------------------------------\n"));

  reach_next_i = reach_next;
  while (/*CONSTCOND*/(void)1,1)
    {
      /* If no match found yet, add the initial states to `reach_next'. */
      if (match_eo < 0)
	{
	  DPRINT((" init >"));
	  trans_i = tnfa->initial;
	  while (trans_i->state != NULL)
	    {
	      if (reach_pos[trans_i->state_id].pos < pos)
		{
		  if (trans_i->assertions
		      && CHECK_ASSERTIONS(trans_i->assertions))
		    {
		      DPRINT(("assertion failed\n"));
		      trans_i++;
		      continue;
		    }

		  DPRINT((" %p", (void *)trans_i->state));
		  reach_next_i->state = trans_i->state;
		  for (i = 0; i < num_tags; i++)
		    reach_next_i->tags[i] = -1;
		  tag_i = trans_i->tags;
		  if (tag_i)
		    while (*tag_i >= 0)
		      {
			if (*tag_i < num_tags)
			  reach_next_i->tags[*tag_i] = pos;
			tag_i++;
		      }
		  if (reach_next_i->state == tnfa->final)
		    {
		      DPRINT(("	 found empty match\n"));
		      match_eo = pos;
		      new_match = 1;
		      for (i = 0; i < num_tags; i++)
			match_tags[i] = reach_next_i->tags[i];
		    }
		  reach_pos[trans_i->state_id].pos = pos;
		  reach_pos[trans_i->state_id].tags = &reach_next_i->tags;
		  reach_next_i++;
		}
	      trans_i++;
	    }
	  DPRINT(("\n"));
	  reach_next_i->state = NULL;
	}
      else
	{
	  if (num_tags == 0 || reach_next_i == reach_next)
	    /*�We have found a match. */
	    break;
	}

      /* Check for end of string. */
      if (len < 0)
	{
	  if (type == STR_USER)
	    {
	      if (str_user_end)
		break;
	    }
	  else if (next_c == L'\0')
	    break;
	}
      else
	{
	  if (pos >= len)
	    break;
	}

      GET_NEXT_WCHAR();

#ifdef TRE_DEBUG
      DPRINT(("%3d:%2lc/%05d |", pos - 1, (tre_cint_t)prev_c, (int)prev_c));
      tre_print_reach(tnfa, reach_next, num_tags);
      DPRINT(("%3d:%2lc/%05d |", pos, (tre_cint_t)next_c, (int)next_c));
      tre_print_reach(tnfa, reach_next, num_tags);
#endif /* TRE_DEBUG */

      /* Swap `reach' and `reach_next'. */
      reach_i = reach;
      reach = reach_next;
      reach_next = reach_i;

      /* For each state in `reach', weed out states that don't fulfill the
	 minimal matching conditions. */
      if (tnfa->num_minimals && new_match)
	{
	  new_match = 0;
	  reach_next_i = reach_next;
	  for (reach_i = reach; reach_i->state; reach_i++)
	    {
	      int skip = 0;
	      for (i = 0; tnfa->minimal_tags[i] >= 0; i += 2)
		{
		  int end = tnfa->minimal_tags[i];
		  int start = tnfa->minimal_tags[i + 1];
		  DPRINT(("  Minimal start %d, end %d\n", start, end));
		  if (end >= num_tags)
		    {
		      DPRINT(("	 Throwing %p out.\n", reach_i->state));
		      skip = 1;
		      break;
		    }
		  else if (reach_i->tags[start] == match_tags[start]
			   && reach_i->tags[end] < match_tags[end])
		    {
		      DPRINT(("	 Throwing %p out because t%d < %d\n",
			      reach_i->state, end, match_tags[end]));
		      skip = 1;
		      break;
		    }
		}
	      if (!skip)
		{
		  reach_next_i->state = reach_i->state;
		  tmp_iptr = reach_next_i->tags;
		  reach_next_i->tags = reach_i->tags;
		  reach_i->tags = tmp_iptr;
		  reach_next_i++;
		}
	    }
	  reach_next_i->state = NULL;

	  /* Swap `reach' and `reach_next'. */
	  reach_i = reach;
	  reach = reach_next;
	  reach_next = reach_i;
	}

      /* For each state in `reach' see if there is a transition leaving with
	 the current input symbol to a state not yet in `reach_next', and
	 add the destination states to `reach_next'. */
      reach_next_i = reach_next;
      for (reach_i = reach; reach_i->state; reach_i++)
	{
	  for (trans_i = reach_i->state; trans_i->state; trans_i++)
	    {
	      /* Does this transition match the input symbol? */
	      if (trans_i->code_min <= (tre_cint_t)prev_c &&
		  trans_i->code_max >= (tre_cint_t)prev_c)
		{
		  if (trans_i->assertions
		      && (CHECK_ASSERTIONS(trans_i->assertions)
			  || CHECK_CHAR_CLASSES(trans_i, tnfa, eflags)))
		    {
		      DPRINT(("assertion failed\n"));
		      continue;
		    }

		  /* Compute the tags after this transition. */
		  for (i = 0; i < num_tags; i++)
		    tmp_tags[i] = reach_i->tags[i];
		  tag_i = trans_i->tags;
		  if (tag_i != NULL)
		    while (*tag_i >= 0)
		      {
			if (*tag_i < num_tags)
			  tmp_tags[*tag_i] = pos;
			tag_i++;
		      }

		  if (reach_pos[trans_i->state_id].pos < pos)
		    {
		      /* Found an unvisited node. */
		      reach_next_i->state = trans_i->state;
		      tmp_iptr = reach_next_i->tags;
		      reach_next_i->tags = tmp_tags;
		      tmp_tags = tmp_iptr;
		      reach_pos[trans_i->state_id].pos = pos;
		      reach_pos[trans_i->state_id].tags = &reach_next_i->tags;

		      if (reach_next_i->state == tnfa->final
			  && (match_eo == -1
			      || (num_tags > 0
				  && reach_next_i->tags[0] <= match_tags[0])))
			{
			  DPRINT(("  found match %p\n", trans_i->state));
			  match_eo = pos;
			  new_match = 1;
			  for (i = 0; i < num_tags; i++)
			    match_tags[i] = reach_next_i->tags[i];
			}
		      reach_next_i++;

		    }
		  else
		    {
		      assert(reach_pos[trans_i->state_id].pos == pos);
		      /* Another path has also reached this state.  We choose
			 the winner by examining the tag values for both
			 paths. */
		      if (tre_tag_order(num_tags, tnfa->tag_directions,
					tmp_tags,
					*reach_pos[trans_i->state_id].tags))
			{
			  /* The new path wins. */
			  tmp_iptr = *reach_pos[trans_i->state_id].tags;
			  *reach_pos[trans_i->state_id].tags = tmp_tags;
			  if (trans_i->state == tnfa->final)
			    {
			      DPRINT(("	 found better match\n"));
			      match_eo = pos;
			      new_match = 1;
			      for (i = 0; i < num_tags; i++)
				match_tags[i] = tmp_tags[i];
			    }
			  tmp_tags = tmp_iptr;
			}
		    }
		}
	    }
	}
      reach_next_i->state = NULL;
    }

  DPRINT(("match end offset = %d\n", match_eo));

#ifndef TRE_USE_ALLOCA
  if (buf)
    xfree(buf);
#endif /* !TRE_USE_ALLOCA */

  *match_end_ofs = match_eo;
  return match_eo >= 0 ? REG_OK : REG_NOMATCH;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, 0x88(%rsp)
movq %r8, 0x20(%rsp)
movl %ecx, %r14d
movl %edx, 0x84(%rsp)
movq %rsi, 0x50(%rsp)
movb $0x0, 0x6(%rsp)
movl $0x1, 0x8c(%rsp)
testq %r8, %r8
je 0x74feb
movl 0x48(%rdi), %ecx
jmp 0x74fed
xorl %ecx, %ecx
movl 0x58(%rdi), %eax
movl %eax, 0x4c(%rsp)
leal (,%rcx,4), %ebx
movq %rdi, 0x30(%rsp)
movl 0x54(%rdi), %ebp
movl %ebp, %r13d
shll $0x4, %r13d
movl %ebx, %eax
imull %ebp, %eax
addl %r13d, %eax
addl $0x10, %eax
movq %rcx, 0x70(%rsp)
leal (%r13,%rcx,4), %ecx
leal (%rcx,%rax,2), %r15d
addl $0x1c, %r15d
movq %r15, %rdi
callq 0xbce8
testq %rax, %rax
je 0x751bd
movl %r14d, 0x80(%rsp)
movq %rax, 0xa0(%rsp)
leal 0x10(%r13), %r12d
movslq %ebx, %r14
movslq %r13d, %rax
movq %rax, 0x8(%rsp)
movslq %r15d, %rdx
xorl %ebx, %ebx
movq 0xa0(%rsp), %rdi
xorl %esi, %esi
callq 0xb2f0
movq 0xa0(%rsp), %rax
leaq (%rax,%r14), %rdx
movl %edx, %ecx
andl $0x7, %ecx
pushq $0x8
popq %rax
movq %rax, %rsi
subq %rcx, %rsi
testq %rcx, %rcx
cmoveq %rcx, %rsi
addq %rsi, %rdx
movslq %r12d, %rcx
movq 0xa0(%rsp), %r12
movq %rdx, 0x68(%rsp)
leaq (%rdx,%rcx), %r8
movl %r8d, %edi
andl $0x7, %edi
movq %rax, %rdx
subq %rdi, %rdx
testq %rdi, %rdi
cmoveq %rdi, %rdx
addq %rdx, %r8
movq %r8, 0x78(%rsp)
leaq (%r8,%rcx), %r9
movl %r9d, %edi
andl $0x7, %edi
movq %rax, %r8
subq %rdi, %r8
testq %rdi, %rdi
cmoveq %rdi, %r8
addq %r8, %r9
movq %r9, 0x90(%rsp)
addl %r9d, %r13d
andl $0x7, %r13d
movq %rax, %rdi
subq %r13, %rdi
testl %r13d, %r13d
movl $0x0, %r9d
cmovneq %rdi, %r9
testl %ebp, %ebp
cmovgl %ebp, %ebx
addq %rsi, %rdx
leaq (%r14,%rcx), %rdi
addq %rax, %rdi
addq %rdx, %rdi
addq %r14, %rax
addq %rsi, %rax
addq %r8, %rdx
addq %rdx, %r9
leaq (%r14,%r14), %rsi
leaq (%r9,%rcx,2), %r8
addq 0x8(%rsp), %r8
leaq (%r8,%r14,2), %r9
addq %r14, %r8
movq %rbx, %r10
movq 0x70(%rsp), %r15
subq $0x1, %r10
jb 0x7515a
leaq (%r12,%r8), %r11
movq %r11, (%r12,%rdi)
leaq (%r12,%r9), %r11
movq %r11, (%r12,%rax)
addq $0x10, %rdi
addq $0x10, %rax
addq %rsi, %r9
addq %rsi, %r8
jmp 0x75134
shlq $0x4, %rbx
leaq (%rdx,%rcx,2), %rcx
addq %r14, %rcx
movq %r12, %rax
addq %rcx, %rax
xorl %ecx, %ecx
movq 0x20(%rsp), %r11
movl 0x80(%rsp), %ebp
movl 0x84(%rsp), %r14d
cmpq %rcx, %rbx
je 0x75190
orl $-0x1, (%rax,%rcx)
addq $0x10, %rcx
jmp 0x75181
cmpl $0x1, %ebp
jne 0x751c4
cmpq $0x0, 0x50(%rsp)
je 0x751c4
movq 0x30(%rsp), %rax
movl 0x30(%rax), %esi
testl %esi, %esi
js 0x751c4
testl %r14d, %r14d
js 0x75225
movl %r14d, %edx
movq 0x50(%rsp), %rdi
callq 0xb710
jmp 0x7522f
pushq $0xc
jmp 0x75285
cmpl $0x1, %ebp
jne 0x751e5
testl %r14d, %r14d
je 0x7528b
movq 0x50(%rsp), %rax
leaq 0x1(%rax), %rbx
movb (%rax), %al
movb %al, 0x6(%rsp)
xorl %esi, %esi
jmp 0x75221
xorl %esi, %esi
movl $0x0, %edi
movq 0x50(%rsp), %rbx
movl $0x0, 0x14(%rsp)
cmpl $0x3, %ebp
jne 0x752a1
movq 0x50(%rsp), %rbx
movq 0x18(%rbx), %rdx
leaq 0x6(%rsp), %rdi
leaq 0x8c(%rsp), %rsi
callq *(%rbx)
movq 0x20(%rsp), %r11
movl %eax, %esi
xorl %edi, %edi
jmp 0x75299
movq 0x50(%rsp), %rdi
callq 0xb210
testq %rax, %rax
movq 0x20(%rsp), %r11
je 0x7527b
movq 0x50(%rsp), %rcx
incq %rcx
xorl %esi, %esi
movl $0x0, 0x14(%rsp)
cmpq %rcx, %rax
jb 0x75257
movb -0x1(%rax), %cl
movl %ecx, 0x14(%rsp)
movb (%rax), %cl
movb %cl, 0x6(%rsp)
movl %eax, %edx
subl 0x50(%rsp), %edx
testl %r14d, %r14d
sets %cl
movl %edx, %edi
cmpl %r14d, %edx
setl %dl
orb %cl, %dl
movzbl %dl, %ebx
addq %rax, %rbx
jmp 0x752a1
movq %r12, %rdi
callq 0xb790
pushq $0x1
popq %rcx
jmp 0x75e43
movb $0x0, 0x6(%rsp)
xorl %esi, %esi
xorl %edi, %edi
movq 0x50(%rsp), %rbx
movl $0x0, 0x14(%rsp)
movq %rbx, 0xb0(%rsp)
movl %esi, 0x9c(%rsp)
movq $0x0, 0x58(%rsp)
testl %r15d, %r15d
movl $0x0, %r13d
cmovgl %r15d, %r13d
pushq $-0x1
popq %rax
movl %eax, 0x3c(%rsp)
movl 0x4c(%rsp), %eax
andl $0x4, %eax
shrl $0x2, %eax
movl %eax, 0x4c(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movl %edi, %esi
cmpl $0x0, 0x3c(%rsp)
js 0x7530c
testl %r15d, %r15d
je 0x75e25
movq 0x18(%rsp), %rax
cmpq %rax, 0x68(%rsp)
jne 0x756a0
jmp 0x75e25
movl 0x88(%rsp), %ecx
testb $0x2, %cl
sete %al
testb $0x1, %cl
sete %cl
movq 0x30(%rsp), %rdx
movq 0x10(%rdx), %r15
testl %esi, %esi
setle %dl
sete %r8b
andb %cl, %dl
movl 0x14(%rsp), %edi
cmpb $0xa, %dil
sete %r9b
movl %esi, 0x8(%rsp)
movl 0x4c(%rsp), %esi
andb %sil, %r9b
movzbl 0x6(%rsp), %r10d
cmpq $0xa, %r10
sete %bl
testq %r10, %r10
sete %cl
andb %cl, %al
andb %sil, %bl
movl 0x8(%rsp), %esi
orb %al, %bl
movzbl %dil, %eax
movq %rax, 0x60(%rsp)
orb %cl, %r8b
movb %r8b, 0xa8(%rsp)
movl %ebx, %r8d
orb %dl, %r9b
movq 0x90(%rsp), %rbp
movb %r9b, 0x7(%rsp)
movq %r10, 0x28(%rsp)
movb %bl, 0x40(%rsp)
addq $0x40, %r15
movq -0x38(%r15), %r14
testq %r14, %r14
je 0x75683
movslq -0x30(%r15), %rax
shlq $0x4, %rax
cmpl %esi, (%rbp,%rax)
jge 0x75398
movl -0x18(%r15), %ebx
testl %ebx, %ebx
je 0x75510
testb $0x1, %bl
sete %al
orb %r9b, %al
testb $0x1, %al
je 0x75398
testb $0x2, %bl
sete %al
orb %r8b, %al
testb $0x1, %al
je 0x75398
testb $0x10, %bl
jne 0x75533
testb $0x20, %bl
jne 0x75587
testb %r10b, %r10b
setne %al
testl %esi, %esi
setne %cl
movl %ebx, %edx
shrb $0x6, %dl
andb %al, %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x75485
pushq $0x1
popq %rbp
cmpb $0x5f, 0x14(%rsp)
je 0x75441
callq 0xb6e0
movb 0x40(%rsp), %r8b
movq 0x28(%rsp), %r10
movb 0x7(%rsp), %r9b
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
movq (%rax), %rax
movq 0x60(%rsp), %rcx
movzwl (%rax,%rcx,2), %ebp
shrl $0x3, %ebp
andl $0x1, %ebp
pushq $0x1
popq %rax
cmpl $0x5f, %r10d
je 0x75475
callq 0xb6e0
movb 0x40(%rsp), %r8b
movq 0x28(%rsp), %r10
movb 0x7(%rsp), %r9b
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
movq (%rax), %rax
movzwl (%rax,%r10,2), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl %eax, %ebp
movq 0x90(%rsp), %rbp
je 0x75398
testb %bl, %bl
jns 0x75510
testb $0x1, 0xa8(%rsp)
jne 0x75398
pushq $0x1
popq %rbx
cmpb $0x5f, 0x14(%rsp)
je 0x754d4
callq 0xb6e0
movb 0x40(%rsp), %r8b
movq 0x28(%rsp), %r10
movb 0x7(%rsp), %r9b
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
movq (%rax), %rax
movq 0x60(%rsp), %rcx
movzwl (%rax,%rcx,2), %ebx
shrl $0x3, %ebx
andl $0x1, %ebx
pushq $0x1
popq %rax
cmpl $0x5f, %r10d
je 0x75508
callq 0xb6e0
movb 0x40(%rsp), %r8b
movq 0x28(%rsp), %r10
movb 0x7(%rsp), %r9b
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
movq (%rax), %rax
movzwl (%rax,%r10,2), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl %eax, %ebx
jne 0x75398
movq 0x68(%rsp), %rax
movq %r14, (%rax)
addq $0x8, %rax
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x7560f
movq (%rax), %rdx
orl $-0x1, (%rdx,%rcx,4)
incq %rcx
jmp 0x7551e
cmpb $0x5f, 0x14(%rsp)
je 0x75398
callq 0xb6e0
movb 0x40(%rsp), %r8b
movq 0x28(%rsp), %r10
movb 0x7(%rsp), %r9b
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
movq (%rax), %rax
movq 0x60(%rsp), %rcx
testb $0x8, (%rax,%rcx,2)
jne 0x75398
cmpl $0x5f, %r10d
je 0x753e6
testb $0x8, (%rax,%r10,2)
je 0x75398
jmp 0x753e6
cmpb $0x5f, 0x14(%rsp)
jne 0x755b7
cmpl $0x5f, %r10d
je 0x75398
callq 0xb6e0
movb 0x40(%rsp), %r8b
movq 0x28(%rsp), %r10
movb 0x7(%rsp), %r9b
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
jmp 0x755fc
cmpb $0x5f, %r10b
sete %bpl
callq 0xb6e0
movb 0x40(%rsp), %r8b
movq 0x28(%rsp), %r10
movb 0x7(%rsp), %r9b
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
movq (%rax), %rcx
movq 0x60(%rsp), %rdx
testb $0x8, (%rcx,%rdx,2)
sete %cl
orb %bpl, %cl
movq 0x90(%rsp), %rbp
jne 0x75398
movq (%rax), %rax
testb $0x8, (%rax,%r10,2)
jne 0x75398
jmp 0x753ef
movq -0x28(%r15), %rcx
testq %rcx, %rcx
je 0x7563a
movslq (%rcx), %rdx
testq %rdx, %rdx
js 0x7563a
cmpl 0x70(%rsp), %edx
jge 0x75634
movq (%rax), %rsi
movl 0x8(%rsp), %edi
movl %edi, (%rsi,%rdx,4)
movl 0x8(%rsp), %esi
addq $0x4, %rcx
jmp 0x75618
movq 0x30(%rsp), %rcx
cmpq 0x18(%rcx), %r14
jne 0x75667
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x7565b
movq (%rax), %rdx
movl (%rdx,%rcx,4), %edx
movl %edx, (%r11,%rcx,4)
incq %rcx
jmp 0x75647
movl %esi, 0x3c(%rsp)
pushq $0x1
popq %rcx
movq %rcx, 0x58(%rsp)
movslq -0x30(%r15), %rcx
shlq $0x4, %rcx
movl %esi, (%rbp,%rcx)
movq %rax, 0x8(%rbp,%rcx)
addq $0x10, 0x68(%rsp)
jmp 0x75398
movq 0x68(%rsp), %rax
andq $0x0, (%rax)
movl 0x80(%rsp), %ebp
movl 0x84(%rsp), %r14d
movq 0x70(%rsp), %r15
testl %r14d, %r14d
js 0x756e3
cmpl %r14d, %esi
jge 0x75e25
movb 0x6(%rsp), %al
movl %eax, 0x14(%rsp)
cmpl $0x1, %ebp
jne 0x75705
incl %esi
testl %r14d, %r14d
js 0x7576c
cmpl %r14d, %esi
movq 0x78(%rsp), %r14
jl 0x75765
movb $0x0, 0x6(%rsp)
movq 0x30(%rsp), %rbx
jmp 0x7578f
cmpl $0x3, %ebp
jne 0x75740
cmpl $0x0, 0x9c(%rsp)
movq 0x30(%rsp), %rbx
jne 0x75e25
movb 0x6(%rsp), %al
movl %eax, 0x14(%rsp)
jmp 0x7570f
cmpl $0x3, %ebp
movq 0x30(%rsp), %rbx
jne 0x7575e
addl 0x8c(%rsp), %esi
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x6(%rsp), %rdi
movl %esi, %ebp
leaq 0x8c(%rsp), %rsi
callq *(%rax)
movl %ebp, %esi
movq 0x20(%rsp), %r11
movl %eax, 0x9c(%rsp)
jmp 0x7575e
movb 0x6(%rsp), %al
movl %eax, 0x14(%rsp)
testb %al, %al
movq 0x30(%rsp), %rbx
je 0x75e25
cmpl $0x1, %ebp
jne 0x7575e
incl %esi
jmp 0x75771
movq 0x78(%rsp), %r14
jmp 0x7578f
movq 0x30(%rsp), %rbx
jmp 0x75776
movq 0x30(%rsp), %rbx
movq 0x78(%rsp), %r14
movq 0xb0(%rsp), %rcx
movb (%rcx), %al
incq %rcx
movq %rcx, 0xb0(%rsp)
movb %al, 0x6(%rsp)
movq 0x58(%rsp), %rax
cmpl $0x0, 0x4c(%rbx)
movl %esi, 0x8(%rsp)
je 0x75806
testl %eax, %eax
je 0x75806
movq %r14, %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x75810
movq 0x40(%rbx), %rsi
addq $0x4, %rsi
movslq -0x4(%rsi), %rdi
testq %rdi, %rdi
js 0x757e9
cmpl %r15d, %edi
jge 0x75800
movslq (%rsi), %r9
movq 0x8(%rcx), %r8
movl (%r8,%r9,4), %r10d
cmpl (%r11,%r9,4), %r10d
jne 0x757e3
movl (%r8,%rdi,4), %r8d
cmpl (%r11,%rdi,4), %r8d
jl 0x75800
addq $0x8, %rsi
jmp 0x757ba
movq %rdx, (%rax)
movq 0x8(%rax), %rdx
movq 0x8(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq %rdx, 0x8(%rcx)
addq $0x10, %rax
addq $0x10, %rcx
jmp 0x757aa
movq %r14, %rdx
movq 0x18(%rsp), %r14
jmp 0x75826
andq $0x0, (%rax)
movq $0x0, 0x58(%rsp)
movq 0x18(%rsp), %rdx
movl 0x8(%rsp), %esi
testb $0x1, 0x88(%rsp)
sete %al
movzbl 0x14(%rsp), %edi
testl %esi, %esi
setle %cl
andb %al, %cl
cmpb $0xa, %dil
sete %al
andb 0x4c(%rsp), %al
orb %cl, %al
movb %al, 0x7(%rsp)
movq %rdx, 0xa8(%rsp)
movq %rdx, 0x68(%rsp)
movq %r14, 0x78(%rsp)
movq %rdi, 0x18(%rsp)
movq (%r14), %rbp
testq %rbp, %rbp
je 0x75dfb
cmpq $0x0, 0x8(%rbp)
je 0x75df2
movswl (%rbp), %eax
cmpl %edi, %eax
jg 0x7588c
movswl 0x2(%rbp), %eax
cmpl %edi, %eax
jge 0x75898
movq %r12, %rax
addq $0x40, %rbp
movq %rax, %r12
jmp 0x75871
movl 0x28(%rbp), %ebx
testl %ebx, %ebx
je 0x75a1b
testb $0x1, %bl
sete %al
orb 0x7(%rsp), %al
testb $0x1, %al
je 0x75ab1
testb $0x2, %bl
movq 0x70(%rsp), %r15
jne 0x75b06
testb $0x10, %bl
jne 0x75b47
testb $0x20, %bl
jne 0x75bce
movb 0x6(%rsp), %r8b
testl %esi, %esi
setne %al
movl %ebx, %ecx
shrb $0x6, %cl
andb %al, %cl
testb %r8b, %r8b
setne %al
andb %cl, %al
movzbl %r8b, %ecx
movq %rcx, 0x40(%rsp)
cmpb $0x1, %al
jne 0x75972
pushq $0x1
popq %rcx
cmpb $0x5f, 0x14(%rsp)
movb %r8b, 0x28(%rsp)
je 0x7592f
callq 0xb6e0
movb 0x28(%rsp), %r8b
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
movq (%rax), %rax
movzwl (%rax,%rdi,2), %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
pushq $0x1
popq %rax
cmpb $0x5f, %r8b
je 0x7596a
movl %ecx, 0x60(%rsp)
callq 0xb6e0
movb 0x28(%rsp), %r8b
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
movq (%rax), %rax
movq 0x40(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movl 0x60(%rsp), %ecx
shrl $0x3, %eax
andl $0x1, %eax
cmpl %eax, %ecx
je 0x7588c
testb %bl, %bl
js 0x75caf
movzwl %di, %eax
movl %eax, 0x60(%rsp)
testb $0x4, %bl
je 0x75a11
movq 0x30(%rsp), %rax
testb $0x2, 0x58(%rax)
jne 0x759b8
movl 0x60(%rsp), %edi
callq *0x30(%rbp)
testl %eax, %eax
je 0x75dcc
testb $0x4, 0x28(%rbp)
movq 0x20(%rsp), %r11
movl 0x8(%rsp), %esi
movq 0x18(%rsp), %rdi
je 0x75a11
movq 0x30(%rsp), %rax
testb $0x2, 0x58(%rax)
je 0x75a11
movq 0x30(%rbp), %rbx
movq 0x18(%rsp), %rdi
callq 0xb8f0
movswl %ax, %edi
callq *%rbx
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
testl %eax, %eax
jne 0x75a11
movq 0x30(%rbp), %rbx
movq 0x18(%rsp), %rdi
callq 0xbbe0
movswl %ax, %edi
callq *%rbx
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
testl %eax, %eax
je 0x7588c
testb $0x8, 0x28(%rbp)
jne 0x75d4a
xorl %eax, %eax
movq 0x70(%rsp), %r15
cmpq %rax, %r13
je 0x75a37
movq 0x8(%r14), %rcx
movl (%rcx,%rax,4), %ecx
movl %ecx, (%r12,%rax,4)
incq %rax
jmp 0x75a22
movq 0x18(%rbp), %rax
testq %rax, %rax
je 0x75a57
movslq (%rax), %rcx
testq %rcx, %rcx
js 0x75a57
cmpl %r15d, %ecx
jge 0x75a51
movl %esi, (%r12,%rcx,4)
addq $0x4, %rax
jmp 0x75a40
movslq 0x10(%rbp), %rcx
shlq $0x4, %rcx
movq 0x90(%rsp), %r8
leaq (%r8,%rcx), %rdx
cmpl %esi, (%r8,%rcx)
jge 0x75abe
movl %esi, %r10d
movq 0x8(%rbp), %rsi
movq 0x68(%rsp), %r9
movq %rsi, (%r9)
leaq 0x8(%r9), %rdi
movq 0x8(%r9), %rax
movq %r12, 0x8(%r9)
movl %r10d, (%rdx)
movq %rdi, 0x8(%r8,%rcx)
movq 0x30(%rsp), %rcx
cmpq 0x18(%rcx), %rsi
je 0x75b90
movl 0x8(%rsp), %esi
movq 0x18(%rsp), %rdi
jmp 0x75c50
movq %r12, %rax
movq 0x70(%rsp), %r15
jmp 0x7588f
jne 0x75e57
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rdx), %rdx
movq (%rdx), %rdx
xorl %esi, %esi
cmpq %rsi, %r13
je 0x75b36
cmpl $0x0, (%rax,%rsi,4)
movl (%r12,%rsi,4), %edi
movl (%rdx,%rsi,4), %r8d
je 0x75af6
cmpl %r8d, %edi
jg 0x75bfd
jge 0x75b01
jmp 0x75b36
cmpl %r8d, %edi
jl 0x75bfd
jg 0x75b36
incq %rsi
jmp 0x75ad6
testb $0x2, 0x88(%rsp)
sete %cl
movb 0x6(%rsp), %al
testb %al, %al
sete %dl
cmpb $0xa, %al
sete %al
testb %dl, %cl
jne 0x758c3
andb 0x4c(%rsp), %al
je 0x7588c
jmp 0x758c3
movq %r12, %rax
movl 0x8(%rsp), %esi
movq 0x18(%rsp), %rdi
jmp 0x7588f
cmpb $0x5f, 0x14(%rsp)
je 0x7588c
callq 0xb6e0
movq 0x18(%rsp), %rdi
movq (%rax), %rax
testb $0x8, (%rax,%rdi,2)
jne 0x75c7f
movzbl 0x6(%rsp), %ecx
cmpq $0x5f, %rcx
movq 0x20(%rsp), %r11
movl 0x8(%rsp), %esi
je 0x758cc
testb $0x8, (%rax,%rcx,2)
je 0x7588c
jmp 0x758cc
cmpl $-0x1, 0x3c(%rsp)
movl 0x8(%rsp), %esi
movq 0x18(%rsp), %rdi
je 0x75bb6
testl %r15d, %r15d
jle 0x75c50
movl (%r12), %ecx
cmpl (%r11), %ecx
jg 0x75c50
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x75c44
movl (%r12,%rcx,4), %edx
movl %edx, (%r11,%rcx,4)
incq %rcx
jmp 0x75bb8
cmpb $0x5f, 0x14(%rsp)
jne 0x75c5b
movb 0x6(%rsp), %al
cmpb $0x5f, %al
je 0x7588c
movb %al, 0x28(%rsp)
callq 0xb6e0
movb 0x28(%rsp), %r8b
movq 0x18(%rsp), %rdi
jmp 0x75c90
movq 0x90(%rsp), %rax
movq 0x8(%rax,%rcx), %rcx
movq (%rcx), %rax
movq %r12, (%rcx)
movq 0x8(%rbp), %rcx
movq 0x30(%rsp), %rdx
cmpq 0x18(%rdx), %rcx
movl 0x8(%rsp), %esi
movq 0x18(%rsp), %rdi
jne 0x7588f
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x75d39
movl (%r12,%rcx,4), %edx
movl %edx, (%r11,%rcx,4)
incq %rcx
jmp 0x75c2e
movl %esi, 0x3c(%rsp)
pushq $0x1
popq %rcx
movq %rcx, 0x58(%rsp)
addq $0x10, 0x68(%rsp)
jmp 0x7588f
callq 0xb6e0
movq 0x18(%rsp), %rdi
movq (%rax), %rcx
testb $0x8, (%rcx,%rdi,2)
sete %cl
movb 0x6(%rsp), %r8b
cmpb $0x5f, %r8b
sete %dl
orb %cl, %dl
je 0x75c90
movq %r12, %rax
movq 0x20(%rsp), %r11
movl 0x8(%rsp), %esi
jmp 0x7588f
movl 0x8(%rsp), %esi
movq (%rax), %rax
movzbl %r8b, %ecx
testb $0x8, (%rax,%rcx,2)
movq 0x20(%rsp), %r11
jne 0x7588c
jmp 0x758da
testl %esi, %esi
sete %al
testb %r8b, %r8b
sete %cl
orb %al, %cl
jne 0x7588c
pushq $0x1
popq %rcx
cmpb $0x5f, 0x14(%rsp)
je 0x75cf6
movb %r8b, 0x28(%rsp)
callq 0xb6e0
movb 0x28(%rsp), %r8b
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
movq (%rax), %rax
movzwl (%rax,%rdi,2), %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
pushq $0x1
popq %rax
cmpb $0x5f, %r8b
je 0x75d2c
movl %ecx, 0x28(%rsp)
callq 0xb6e0
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x20(%rsp), %r11
movq (%rax), %rax
movq 0x40(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movl 0x28(%rsp), %ecx
shrl $0x3, %eax
andl $0x1, %eax
cmpl %eax, %ecx
jne 0x7588c
jmp 0x7597a
movl %esi, 0x3c(%rsp)
pushq $0x1
popq %rcx
movq %rcx, 0x58(%rsp)
jmp 0x7588f
movq 0x38(%rbp), %rbx
movq 0x30(%rsp), %rax
movl 0x58(%rax), %eax
movl %eax, 0x28(%rsp)
movq (%rbx), %r15
testq %r15, %r15
je 0x75a1b
testb $0x2, 0x28(%rsp)
jne 0x75d73
movl 0x60(%rsp), %edi
jmp 0x75d9f
movq %rbx, 0x40(%rsp)
movq %rdi, %rbx
callq 0xbbe0
movswl %ax, %edi
callq *%r15
testl %eax, %eax
jne 0x75dd9
movq 0x40(%rsp), %rax
movq (%rax), %r15
movl %ebx, %edi
movq %rax, %rbx
callq 0xb8f0
movswl %ax, %edi
callq *%r15
testl %eax, %eax
jne 0x75dba
addq $0x8, %rbx
movq 0x20(%rsp), %r11
movl 0x8(%rsp), %esi
movq 0x18(%rsp), %rdi
jmp 0x75d5a
movq %r12, %rax
movq 0x20(%rsp), %r11
movq 0x70(%rsp), %r15
jmp 0x75b39
movq %r12, %rax
movq 0x20(%rsp), %r11
jmp 0x75b39
movq %r12, %rax
movq 0x20(%rsp), %r11
movq 0x70(%rsp), %r15
movl 0x8(%rsp), %esi
movq %rbx, %rdi
jmp 0x7588f
addq $0x10, %r14
jmp 0x75865
movq 0x68(%rsp), %rax
andq $0x0, (%rax)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x80(%rsp), %ebp
movl 0x84(%rsp), %r14d
jmp 0x752e7
movq 0xa0(%rsp), %rdi
callq 0xb790
movq 0xf0(%rsp), %rax
movl 0x3c(%rsp), %ecx
movl %ecx, (%rax)
shrl $0x1f, %ecx
movl %ecx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6a925(%rip), %rdi     # 0xe0783
leaq 0x6a946(%rip), %rsi     # 0xe07ab
leaq 0x6a969(%rip), %rcx     # 0xe07d5
movl $0x1cf, %edx            # imm = 0x1CF
callq 0xb400
nop