// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/contrib/sais-lite-lcp/sais.c
// Function: induceSAandLCP
static void induceSAandLCP(const void *T, sais_index_type *SA,
			   sais_index_type *LCP,
			   sais_index_type *C, sais_index_type *B,
			   sais_index_type n, sais_index_type k, int cs) {
  /*
    When entering this procedure, we are in the following situation:
    all S*-suffixes have been sorted and put at the end of their
    corresponding buckets in SA. Further, all their LCP-values have been
    computed (in LCP). A value of -1 in LCP means that "this is the first
    S*-suffix in its bucket." As in in the inducing step an L-suffix
    can be placed before the leftmost S*-suffix, this means that the actual
    LCP-value at this "L/S-seam" has to be recomputed. All other uncomputed
    LCP-entries are marked -2.
  */

  sais_index_type i, bb;         /* indices in SA/LCP (origin/target) */
  sais_index_type j;             /* position in text */
  sais_index_type c0, c1;        /* characters (new/last) */
  
  sais_index_type lcp;           /* LCP-value */
  sais_index_type l;             /* for finding LCP at L/S-seam */
  sais_index_type start, end, stack_end; /* for inducing the LCP-values */

  sais_index_type *D; /* store beginnings of buckets (not CURRENT beginnings!) */
  sais_index_type *LastW; /* store last written L or S-suffix for every bucket */
  sais_index_type sigma;       /* (true) alphabet size */
  sais_index_type *TranslateSigma; /* general to effective alphabet ([0..k-1] |--> [0..sigma-1]) */
  sais_index_type *LastOcc; /* store last occurrences of characters */
  const sais_index_type stack_extra_space = 1024; /* this is the same Min-Stack as in Gog's sdsl */
  sais_index_type stack_size;
  sais_index_type *MinStack; /* Min-Stack */

  if ((D = SAIS_MYMALLOC(k, sais_index_type)) == NULL) { exit(-1); } /* TODO: check if D is necessary!!! (first write to bucket=>0) */
  if ((LastW = SAIS_MYMALLOC(k, sais_index_type)) == NULL) { exit(-1); }
  for (i = 0; i < k; ++i) LastW[i] = n-1; /* point to $ */
  /* todo: move memory management to sais_main */

  /* compute SAl and LCPl*/
  if(C == B) { getCounts(T, C, n, k, cs); }  /* re-calculate character counts */
  getBuckets(C, B, k, 0);                    /* find starts of buckets */
  memcpy(D,B,k*sizeof(sais_index_type));     /* store starts of buckets */
  j = n - 1;                                 /* go to last character $ */
  bb = B[c1 = chr(j)];        /* bb = position in induced bucket */
  LCP[bb]  = 0;               /* set LCP-value of $ (first value in bucket => 0) */
  SA[bb++] = (chr(j - 1) < c1) ? ~j : j; /* put last character $ into its bucket */
                        /* negative values mean "don't induce from here anymore" */

  /* in case LCP[0], which is always 0, hadn't been set yet */
  LCP[0] = 0;

  /* Variant 3: stack */
  sigma = 0;       /* (true) alphabet size */
  if ((TranslateSigma = SAIS_MYMALLOC(k, sais_index_type)) == NULL) { exit(-1); }
  for (i = 0; i < k; ++i)  {   /* calculate effective alphabet size */
    TranslateSigma[i] = sigma; /* (also stores values for unused characters) */
    if (C[i] > 0) ++sigma;     /* count characters */
  }
  if ((LastOcc = SAIS_MYMALLOC(sigma, sais_index_type)) == NULL) { exit(-1); }
  for (i = 0; i < sigma; ++i) LastOcc[i] = -1; /* init with impossible values */

  stack_size = 2 * (stack_extra_space + sigma + 4);
  if ((MinStack = SAIS_MYMALLOC(stack_size+4, sais_index_type)) == NULL) { exit(-1); }
  MinStack[0] = -1; MinStack[1] = -1; /* (pos, LCP-value) */
  stack_end = 1;

  for(i = 0; i < n; ++i) {
    j = SA[i], SA[i] = ~j;
    if(0 < j) { /* otherwise don't induce anymore from j */
      lcp = LCP[i];
      if (lcp == -1) {
	/* here we are at the seam between L and S in the same bucket */
	c0 = chr(j);  /* i's bucket */
	lcp = 0;
	while (chr(j+lcp) == chr(LastW[c0]+lcp)) lcp++; /* naive LCP-computation (overall linear!) */
	/* no need to store LCP[i]=lcp (will be re-calculated in right-to-left scan!) */
      }
      --j;      /* move to suffix T[SA[i]-1] */
      assert(chr(j) >= chr(j + 1));   /* induced suffix must be type L */
      if((c0 = chr(j)) != c1) {       /* induced SA-value in new bucket c0 */
	B[c1] = bb;                   /* store current end in old bucket */
	bb = B[c1 = c0];              /* go to position in new bucket */
      }
      assert(i < bb);                 /* can only induce to the right */
      LastW[c0] = j;                  /* store last written L-suffix for every bucket */
      SA[bb] = ((0 < j) && (chr(j - 1) < c0)) ? ~j : j;

      /* Variant 3: use stack: */
      assert(lcp >= 0);                                 /* lcp already computed */
      while (lcp <= MinStack[stack_end]) stack_end -= 2; /* pop from stack */
      MinStack[++stack_end] = i;   /* push position on stack */
      MinStack[++stack_end] = lcp; /* push lcp-value */

      start = LastOcc[TranslateSigma[c0]] + 1; /* start of query */
      assert(stack_end-3 >= 0);                /* stopper (-1) and last (i) are on stack */
      end = stack_end - 3;
      while (start <= MinStack[end]) end -= 2; /* search until smaller element found */
      if (bb == D[c0]) LCP[bb] = 0;            /* store 0 at bucket beginnings */
      else LCP[bb] = MinStack[end+3] + 1;      /* induce LCP-value! */

      LastOcc[TranslateSigma[c0]] = i; /* store origin of last occurrence of c0 */
      ++bb;                            /* advance in bucket */
    }
    else { /* don't induce, but update stack with LCP[i] */
      lcp = LCP[i];      /* get current LCP-value */
      assert(lcp != -1); /* -1 only for S*, but we induce from S* */
      if (lcp >= 0) {    /* check if already computed */
	while (lcp <= MinStack[stack_end]) stack_end -= 2; /* pop from stack */
	MinStack[++stack_end] = i;   /* push position on stack */
	MinStack[++stack_end] = lcp; /* push lcp-value */
      }
    }
    if (stack_end > stack_size) { /* re-adjust stack: */
      sais_index_type *LastOccCopy; /* Copy of LastOcc */
      if ((LastOccCopy = SAIS_MYMALLOC(sigma, sais_index_type)) == NULL) { exit(-1); }
      memcpy(LastOccCopy, LastOcc, sigma*sizeof(sais_index_type));
      qsort(LastOccCopy, sigma, sizeof(sais_index_type), int_cmp);

      end = 1;
      for (j = 0, l=2; j < sigma; ++j) {
	start = LastOccCopy[j] + 1; /* start of next largest query */
	if (start > MinStack[end-1]) {         /* otherwise correct element already taken */
	  while (l < stack_end && start > MinStack[l]) l += 2;
	  if (l > stack_end) break;
	  assert(l < stack_end);
	  MinStack[++end] = MinStack[l];       /* take first element >= start */
	  MinStack[++end] = MinStack[l+1];
	}
      }
      stack_end = end;
      free(LastOccCopy);
    }
  }

  /* compute SAs and LCPl */
  if(C == B) { getCounts(T, C, n, k, cs); }
  getBuckets(C, B, k, 1); /* find ends of buckets */
  for (i = 0; i < sigma; ++i) LastOcc[i] = n-1; /* init with impossible values */
  MinStack[0] = n; MinStack[1] = -1; /* (pos, LCP-value) */
  stack_end = 1;

  for(i = n - 1, bb = B[c1 = 0]; 0 <= i; --i) {
    lcp = LCP[i];
    if (0 < i && lcp < 0 && LCP[i-1] >= 0) { /* calculate LCP at L/S-seam */
      j = SA[i];         /* go to suffix */
      if (j < 0) j = ~j; /* entry in SA could be negative => adjust */
      l = SA[i-1];       /* go to lex. previous suffix */
      if (l < 0) l = ~l; /* entry in SA could be negative => adjust */
      lcp = 0;
      while (chr(j+lcp) == chr(l+lcp)) lcp++; /* naive LCP-computation (overall linear!) */
      LCP[i] = lcp;                           /* this time set LCP-value at seam */
    }
    if(0 < (j = SA[i])) { /* induce SA and LCP */
      --j;                           /* go to suffix T[SA[i]-1] (to be induced) */
      assert(chr(j) <= chr(j + 1));  /* must be type S */
      if((c0 = chr(j)) != c1) {
	B[c1] = bb; bb = B[c1 = c0]; /* switch bucket */
      }
      assert(bb <= i); /* induced suffix must be placed to the left of i */
      SA[--bb] = ((j == 0) || (chr(j - 1) > c0)) ? ~j : j; /* continue if type L */
      assert(c0+1<k);        /* we cannot induce into the last bucket */

      /* search MinStack: */
      start = LastOcc[TranslateSigma[c0]];     /* end of query */
      assert(stack_end-1 >= 0);                /* stopper (-1) is on stack */
      end = stack_end - 1;
      while (start >= MinStack[end]) end -= 2; /* search until smaller element found */
      if (bb+1 == D[c0+1]) LCP[bb+1] = 0;      /* store 0 at bucket beginnings */
      else LCP[bb+1] = MinStack[end+3] + 1;    /* induce LCP-value! */
      if (bb+1 == i) lcp = LCP[i];             /* update if inducing changed my LCP-value */
      LastOcc[TranslateSigma[c0]] = i;         /* store origin of last occurrence of c0 */
    } else { /* don't induce */
      SA[i] = ~j;
    }
    /* update MinStack: */
    assert(lcp >= 0); /* LCP must already have been computed */
    while ((lcp <= MinStack[stack_end]) && (stack_end >= 0))  stack_end -= 2; /* pop from stack */
    MinStack[++stack_end] = i;   /* push position on stack */
    MinStack[++stack_end] = lcp; /* push lcp-value */

    if (stack_end > stack_size) { /* re-adjust stack: */
      sais_index_type *LastOccCopy; /* Copy of LastOcc */
      if ((LastOccCopy = SAIS_MYMALLOC(sigma, sais_index_type)) == NULL) { exit(-1); }
      memcpy(LastOccCopy, LastOcc, sigma*sizeof(sais_index_type));
      qsort(LastOccCopy, sigma, sizeof(sais_index_type), int_cmp);

      end = 1;
      for (j = sigma-1, l=2; j >= 0; --j) {
	start = LastOccCopy[j]; /* start of next largest query */
	if (start < MinStack[end-1]) {         /* otherwise correct element already taken */
	  while (l < stack_end && start < MinStack[l]) l += 2;
	  if (l > stack_end) break;
	  assert(l < stack_end);
	  MinStack[++end] = MinStack[l];       /* take first element >= start */
	  MinStack[++end] = MinStack[l+1];
	}
      }
      stack_end = end;
      free(LastOccCopy);
    }
  }

  free(D);
  free(LastOcc);
  free(MinStack);
  free(TranslateSigma);
  free(LastW);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl $0x400, -0x84(%rbp)     # imm = 0x400
movslq 0x10(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2af400
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
jne 0x2c9a34
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2af3b0
movslq 0x10(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2af400
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
jne 0x2c9a55
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2af3b0
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x2c9a80
movl -0x2c(%rbp), %edx
subl $0x1, %edx
movq -0x68(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2c9a5c
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x2c9aa1
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %edx
movl 0x10(%rbp), %ecx
movl 0x18(%rbp), %r8d
callq 0x2c85e0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl 0x10(%rbp), %edx
xorl %ecx, %ecx
callq 0x2c8680
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq 0x10(%rbp), %rdx
shlq $0x2, %rdx
callq 0x2af230
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2c9af9
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xac(%rbp)
jmp 0x2c9b0b
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xac(%rbp)
movq -0xa8(%rbp), %rax
movl -0xac(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2c9b55
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xb0(%rbp)
jmp 0x2c9b6c
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xb0(%rbp)
movl -0xb0(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0x2c9b85
movl -0x38(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0x2c9b8e
movl -0x38(%rbp), %eax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x34(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x6c(%rbp)
movslq 0x10(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2af400
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
jne 0x2c9bdb
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2af3b0
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl 0x10(%rbp), %eax
jge 0x2c9c1c
movl -0x6c(%rbp), %edx
movq -0x78(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x2c9c0f
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x2c9c11
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2c9be2
movslq -0x6c(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2af400
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
jne 0x2c9c3d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2af3b0
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jge 0x2c9c66
movq -0x80(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2c9c44
movl -0x6c(%rbp), %eax
addl $0x400, %eax            # imm = 0x400
addl $0x4, %eax
shll %eax
movl %eax, -0x88(%rbp)
movl -0x88(%rbp), %eax
addl $0x4, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x2af400
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
jne 0x2c9ca5
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2af3b0
movq -0x90(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x90(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movl $0x1, -0x54(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x2ca349
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %edx
xorl $-0x1, %edx
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
xorl %eax, %eax
cmpl -0x38(%rbp), %eax
jge 0x2ca10a
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
jne 0x2c9e09
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2c9d39
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xb8(%rbp)
jmp 0x2c9d4b
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xb8(%rbp)
movl -0xb8(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x44(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2c9d7d
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl -0x44(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xbc(%rbp)
jmp 0x2c9d94
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl -0x44(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
movl %eax, -0xc0(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2c9dca
movq -0x8(%rbp), %rax
movq -0x68(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
addl -0x44(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc4(%rbp)
jmp 0x2c9de9
movq -0x8(%rbp), %rax
movq -0x68(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
addl -0x44(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xc4(%rbp)
movl -0xc0(%rbp), %eax
movl -0xc4(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2c9e07
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2c9d5b
jmp 0x2c9e09
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2c9e2f
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc8(%rbp)
jmp 0x2c9e41
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xc8(%rbp)
movl -0xc8(%rbp), %eax
movl %eax, -0xcc(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2c9e6f
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xd0(%rbp)
jmp 0x2c9e86
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xd0(%rbp)
movl -0xcc(%rbp), %eax
movl -0xd0(%rbp), %ecx
cmpl %ecx, %eax
jl 0x2c9e98
jmp 0x2c9eb7
leaq 0xae5e80(%rip), %rdi    # 0xdafd1f
leaq 0xae5d35(%rip), %rsi    # 0xdafbdb
movl $0x17a, %edx            # imm = 0x17A
leaq 0xae5f72(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2c9ed4
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xd4(%rbp)
jmp 0x2c9ee6
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xd4(%rbp)
movl -0xd4(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl -0x40(%rbp), %eax
je 0x2c9f15
movl -0x34(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x2c9f1f
jmp 0x2c9f3e
leaq 0xae5eb8(%rip), %rdi    # 0xdafdde
leaq 0xae5cae(%rip), %rsi    # 0xdafbdb
movl $0x17f, %edx            # imm = 0x17F
leaq 0xae5eeb(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
movl -0x38(%rbp), %edx
movq -0x68(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
xorl %eax, %eax
cmpl -0x38(%rbp), %eax
jge 0x2c9fa5
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2c9f75
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xd8(%rbp)
jmp 0x2c9f8c
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xd8(%rbp)
movl -0xd8(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x2c9fa5
movl -0x38(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0xdc(%rbp)
jmp 0x2c9fae
movl -0x38(%rbp), %eax
movl %eax, -0xdc(%rbp)
movl -0xdc(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x0, -0x44(%rbp)
jl 0x2c9fc7
jmp 0x2c9fe6
leaq 0xae5ea3(%rip), %rdi    # 0xdafe71
leaq 0xae5c06(%rip), %rsi    # 0xdafbdb
movl $0x184, %edx            # imm = 0x184
leaq 0xae5e43(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
jmp 0x2c9fe8
movl -0x44(%rbp), %eax
movq -0x90(%rbp), %rcx
movslq -0x54(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jg 0x2ca006
movl -0x54(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x54(%rbp)
jmp 0x2c9fe8
movl -0x30(%rbp), %edx
movq -0x90(%rbp), %rax
movl -0x54(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x54(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %edx
movq -0x90(%rbp), %rax
movl -0x54(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x54(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
movl -0x54(%rbp), %eax
subl $0x3, %eax
cmpl $0x0, %eax
jl 0x2ca05e
jmp 0x2ca07d
leaq 0xae5e15(%rip), %rdi    # 0xdafe7a
leaq 0xae5b6f(%rip), %rsi    # 0xdafbdb
movl $0x18a, %edx            # imm = 0x18A
leaq 0xae5dac(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
movl -0x54(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x50(%rbp)
movl -0x4c(%rbp), %eax
movq -0x90(%rbp), %rcx
movslq -0x50(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jg 0x2ca0a4
movl -0x50(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x50(%rbp)
jmp 0x2ca086
movl -0x34(%rbp), %eax
movq -0x60(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x2ca0c5
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x2ca0e6
movq -0x90(%rbp), %rax
movl -0x50(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %edx
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq -0x3c(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2ca199
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
je 0x2ca120
jmp 0x2ca13f
leaq 0xae5d64(%rip), %rdi    # 0xdafe8b
leaq 0xae5aad(%rip), %rsi    # 0xdafbdb
movl $0x195, %edx            # imm = 0x195
leaq 0xae5cea(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
cmpl $0x0, -0x44(%rbp)
jl 0x2ca197
jmp 0x2ca147
movl -0x44(%rbp), %eax
movq -0x90(%rbp), %rcx
movslq -0x54(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jg 0x2ca165
movl -0x54(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x54(%rbp)
jmp 0x2ca147
movl -0x30(%rbp), %edx
movq -0x90(%rbp), %rax
movl -0x54(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x54(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %edx
movq -0x90(%rbp), %rax
movl -0x54(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x54(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2ca199
movl -0x54(%rbp), %eax
cmpl -0x88(%rbp), %eax
jle 0x2ca339
movslq -0x6c(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2af400
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
jne 0x2ca1cc
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2af3b0
movq -0x98(%rbp), %rdi
movq -0x80(%rbp), %rsi
movslq -0x6c(%rbp), %rdx
shlq $0x2, %rdx
callq 0x2af230
movq -0x98(%rbp), %rdi
movslq -0x6c(%rbp), %rsi
movl $0x4, %edx
leaq -0x36ab(%rip), %rcx     # 0x2c6b50
callq 0x2af580
movl $0x1, -0x50(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x2, -0x48(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jge 0x2ca327
movq -0x98(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x90(%rbp), %rcx
movl -0x50(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x2ca317
jmp 0x2ca253
movl -0x48(%rbp), %ecx
xorl %eax, %eax
cmpl -0x54(%rbp), %ecx
movb %al, -0xdd(%rbp)
jge 0x2ca27d
movl -0x4c(%rbp), %eax
movq -0x90(%rbp), %rcx
movslq -0x48(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
setg %al
movb %al, -0xdd(%rbp)
movb -0xdd(%rbp), %al
testb $0x1, %al
jne 0x2ca289
jmp 0x2ca294
movl -0x48(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x48(%rbp)
jmp 0x2ca253
movl -0x48(%rbp), %eax
cmpl -0x54(%rbp), %eax
jle 0x2ca2a1
jmp 0x2ca327
movl -0x48(%rbp), %eax
cmpl -0x54(%rbp), %eax
jge 0x2ca2ab
jmp 0x2ca2ca
leaq 0xae5be3(%rip), %rdi    # 0xdafe95
leaq 0xae5922(%rip), %rsi    # 0xdafbdb
movl $0x1a8, %edx            # imm = 0x1A8
leaq 0xae5b5f(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
movq -0x90(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x90(%rbp), %rax
movl -0x50(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x50(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x90(%rbp), %rax
movl -0x48(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x90(%rbp), %rax
movl -0x50(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x50(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2ca319
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2ca215
movl -0x50(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x98(%rbp), %rdi
callq 0x2af3a0
jmp 0x2ca33b
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2c9cce
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x2ca36a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %edx
movl 0x10(%rbp), %ecx
movl 0x18(%rbp), %r8d
callq 0x2c85e0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl 0x10(%rbp), %edx
movl $0x1, %ecx
callq 0x2c8680
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x6c(%rbp), %eax
jge 0x2ca3aa
movl -0x2c(%rbp), %edx
subl $0x1, %edx
movq -0x80(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2ca386
movl -0x2c(%rbp), %ecx
movq -0x90(%rbp), %rax
movl %ecx, (%rax)
movq -0x90(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movl $0x1, -0x54(%rbp)
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, -0x40(%rbp)
movl (%rax), %eax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
cmpl -0x30(%rbp), %eax
jg 0x2caa52
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
xorl %eax, %eax
cmpl -0x30(%rbp), %eax
jge 0x2ca519
cmpl $0x0, -0x44(%rbp)
jge 0x2ca519
movq -0x18(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0x2ca519
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x2ca446
movl -0x38(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jge 0x2ca468
movl -0x48(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x48(%rbp)
movl $0x0, -0x44(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2ca491
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl -0x44(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xe4(%rbp)
jmp 0x2ca4a8
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl -0x44(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %eax
movl %eax, -0xe8(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2ca4d6
movq -0x8(%rbp), %rax
movl -0x48(%rbp), %ecx
addl -0x44(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xec(%rbp)
jmp 0x2ca4ed
movq -0x8(%rbp), %rax
movl -0x48(%rbp), %ecx
addl -0x44(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xec(%rbp)
movl -0xe8(%rbp), %eax
movl -0xec(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2ca50b
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2ca46f
movl -0x44(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movl %ecx, -0x38(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
jge 0x2ca7fa
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2ca557
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xf0(%rbp)
jmp 0x2ca569
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xf0(%rbp)
movl -0xf0(%rbp), %eax
movl %eax, -0xf4(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2ca597
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xf8(%rbp)
jmp 0x2ca5ae
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xf8(%rbp)
movl -0xf4(%rbp), %eax
movl -0xf8(%rbp), %ecx
cmpl %ecx, %eax
jg 0x2ca5c0
jmp 0x2ca5df
leaq 0xae577a(%rip), %rdi    # 0xdafd41
leaq 0xae560d(%rip), %rsi    # 0xdafbdb
movl $0x1c6, %edx            # imm = 0x1C6
leaq 0xae584a(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2ca5fc
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xfc(%rbp)
jmp 0x2ca60e
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0xfc(%rbp)
movl -0xfc(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl -0x40(%rbp), %eax
je 0x2ca63d
movl -0x34(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jg 0x2ca647
jmp 0x2ca666
leaq 0xae5855(%rip), %rdi    # 0xdafea3
leaq 0xae5586(%rip), %rsi    # 0xdafbdb
movl $0x1ca, %edx            # imm = 0x1CA
leaq 0xae57c3(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
cmpl $0x0, -0x38(%rbp)
je 0x2ca6b0
movslq 0x18(%rbp), %rax
cmpq $0x4, %rax
jne 0x2ca68e
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x100(%rbp)
jmp 0x2ca6a5
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x100(%rbp)
movl -0x100(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jle 0x2ca6be
movl -0x38(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x104(%rbp)
jmp 0x2ca6c7
movl -0x38(%rbp), %eax
movl %eax, -0x104(%rbp)
movl -0x104(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x34(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
cmpl 0x10(%rbp), %eax
jge 0x2ca6ed
jmp 0x2ca70c
leaq 0xae57b7(%rip), %rdi    # 0xdafeab
leaq 0xae54e0(%rip), %rsi    # 0xdafbdb
movl $0x1cc, %edx            # imm = 0x1CC
leaq 0xae571d(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4c(%rbp)
movl -0x54(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jl 0x2ca72f
jmp 0x2ca74e
leaq 0xae577c(%rip), %rdi    # 0xdafeb2
leaq 0xae549e(%rip), %rsi    # 0xdafbdb
movl $0x1d0, %edx            # imm = 0x1D0
leaq 0xae56db(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
movl -0x54(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x50(%rbp)
movl -0x4c(%rbp), %eax
movq -0x90(%rbp), %rcx
movslq -0x50(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0x2ca775
movl -0x50(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x50(%rbp)
jmp 0x2ca757
movl -0x34(%rbp), %eax
addl $0x1, %eax
movq -0x60(%rbp), %rcx
movl -0x3c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x2ca7a3
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x2ca7c9
movq -0x90(%rbp), %rax
movl -0x50(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
cmpl -0x30(%rbp), %eax
jne 0x2ca7e2
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x44(%rbp)
movl -0x30(%rbp), %edx
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movslq -0x3c(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2ca80b
movl -0x38(%rbp), %edx
xorl $-0x1, %edx
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x0, -0x44(%rbp)
jl 0x2ca813
jmp 0x2ca832
leaq 0xae5657(%rip), %rdi    # 0xdafe71
leaq 0xae53ba(%rip), %rsi    # 0xdafbdb
movl $0x1db, %edx            # imm = 0x1DB
leaq 0xae55f7(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
jmp 0x2ca834
movl -0x44(%rbp), %ecx
movq -0x90(%rbp), %rdx
movslq -0x54(%rbp), %rsi
xorl %eax, %eax
cmpl (%rdx,%rsi,4), %ecx
movb %al, -0x105(%rbp)
jg 0x2ca85c
cmpl $0x0, -0x54(%rbp)
setge %al
movb %al, -0x105(%rbp)
movb -0x105(%rbp), %al
testb $0x1, %al
jne 0x2ca868
jmp 0x2ca873
movl -0x54(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x54(%rbp)
jmp 0x2ca834
movl -0x30(%rbp), %edx
movq -0x90(%rbp), %rax
movl -0x54(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x54(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %edx
movq -0x90(%rbp), %rax
movl -0x54(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x54(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x54(%rbp), %eax
cmpl -0x88(%rbp), %eax
jle 0x2caa42
movslq -0x6c(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2af400
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
jne 0x2ca8d8
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2af3b0
movq -0xa0(%rbp), %rdi
movq -0x80(%rbp), %rsi
movslq -0x6c(%rbp), %rdx
shlq $0x2, %rdx
callq 0x2af230
movq -0xa0(%rbp), %rdi
movslq -0x6c(%rbp), %rsi
movl $0x4, %edx
leaq -0x3db7(%rip), %rcx     # 0x2c6b50
callq 0x2af580
movl $0x1, -0x50(%rbp)
movl -0x6c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movl $0x2, -0x48(%rbp)
cmpl $0x0, -0x38(%rbp)
jl 0x2caa30
movq -0xa0(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x90(%rbp), %rcx
movl -0x50(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2caa20
jmp 0x2ca95c
movl -0x48(%rbp), %ecx
xorl %eax, %eax
cmpl -0x54(%rbp), %ecx
movb %al, -0x106(%rbp)
jge 0x2ca986
movl -0x4c(%rbp), %eax
movq -0x90(%rbp), %rcx
movslq -0x48(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
setl %al
movb %al, -0x106(%rbp)
movb -0x106(%rbp), %al
testb $0x1, %al
jne 0x2ca992
jmp 0x2ca99d
movl -0x48(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x48(%rbp)
jmp 0x2ca95c
movl -0x48(%rbp), %eax
cmpl -0x54(%rbp), %eax
jle 0x2ca9aa
jmp 0x2caa30
movl -0x48(%rbp), %eax
cmpl -0x54(%rbp), %eax
jge 0x2ca9b4
jmp 0x2ca9d3
leaq 0xae54da(%rip), %rdi    # 0xdafe95
leaq 0xae5219(%rip), %rsi    # 0xdafbdb
movl $0x1ec, %edx            # imm = 0x1EC
leaq 0xae5456(%rip), %rcx    # 0xdafe24
callq 0x2af1a0
movq -0x90(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x90(%rbp), %rax
movl -0x50(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x50(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x90(%rbp), %rax
movl -0x48(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x90(%rbp), %rax
movl -0x50(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x50(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2caa22
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2ca923
movl -0x50(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x2af3a0
jmp 0x2caa44
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2ca3e4
movq -0x60(%rbp), %rdi
callq 0x2af3a0
movq -0x80(%rbp), %rdi
callq 0x2af3a0
movq -0x90(%rbp), %rdi
callq 0x2af3a0
movq -0x78(%rbp), %rdi
callq 0x2af3a0
movq -0x68(%rbp), %rdi
callq 0x2af3a0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax,%rax)