// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/contrib/sais-lite-lcp/sais.c
// Function: sais_main
static sais_index_type sais_main(const void *T, sais_index_type *SA,
				 sais_index_type *LCP,
				 sais_index_type fs, sais_index_type n, sais_index_type k, int cs,
				 sais_bool_type isbwt,
				 sais_bool_type level0) { /* level0 = 1 iff recursion depth is 0 */
  sais_index_type *C, *B, *D, *RA, *PLCP, *PHI, *DELTA, *b;
  sais_index_type i, j, m, /* m: number of S*-suffixes */
    p, q, t, name, pidx = 0, newfs;
  sais_index_type c0, c1;
  unsigned int flags;

  assert((T != NULL) && (SA != NULL));
  assert((0 <= fs) && (0 < n) && (1 <= k));

  if(k <= MINBUCKETSIZE) {
    if((C = SAIS_MYMALLOC(k, sais_index_type)) == NULL) { return -2; }
    if(k <= fs) {
      B = SA + (n + fs - k);
      flags = 1;
    } else {
      if((B = SAIS_MYMALLOC(k, sais_index_type)) == NULL) { SAIS_MYFREE(C, k, sais_index_type); return -2; }
      flags = 3;
    }
  } else if(k <= fs) {
    C = SA + (n + fs - k);
    if(k <= (fs - k)) {
      B = C - k;
      flags = 0;
    } else if(k <= (MINBUCKETSIZE * 4)) {
      if((B = SAIS_MYMALLOC(k, sais_index_type)) == NULL) { return -2; }
      flags = 2;
    } else {
      B = C;
      flags = 8;
    }
  } else {
    if((C = B = SAIS_MYMALLOC(k, sais_index_type)) == NULL) { return -2; }
    flags = 4 | 8;
  }
  if((n <= SAIS_LMSSORT2_LIMIT) && (2 <= (n / k))) {
    if(flags & 1) { flags |= ((k * 2) <= (fs - k)) ? 32 : 16; }
    else if((flags == 0) && ((k * 2) <= (fs - k * 2))) { flags |= 32; }
  }

  /* stage 1: reduce the problem by at least 1/2
     sort all the LMS-substrings */
  getCounts(T, C, n, k, cs); getBuckets(C, B, k, 1); /* find ends of buckets */

  for(i = 0; i < n; ++i) { SA[i] = 0; }
  b = &t; i = n - 1; j = n; m = 0; c0 = chr(n - 1);
  do { c1 = c0; } while((0 <= --i) && ((c0 = chr(i)) >= c1));
  for(; 0 <= i;) {
    do { c1 = c0; } while((0 <= --i) && ((c0 = chr(i)) <= c1));
    if(0 <= i) {
      *b = j;
      b = SA + --B[c1]; j = i; ++m;
      do { c1 = c0; } while((0 <= --i) && ((c0 = chr(i)) >= c1));
    }
  }

  if(1 < m) {
    if(flags & (16 | 32)) {
      if(flags & 16) {
        if((D = SAIS_MYMALLOC(k * 2, sais_index_type)) == NULL) {
          if(flags & (1 | 4)) { SAIS_MYFREE(C, k, sais_index_type); }
          if(flags & 2) { SAIS_MYFREE(B, k, sais_index_type); }
          return -2;
        }
      } else {
        D = B - k * 2;
      }
      assert((j + 1) < n);
      ++B[chr(j + 1)];
      for(i = 0, j = 0; i < k; ++i) {
        j += C[i];
        if(B[i] != j) { assert(SA[B[i]] != 0); SA[B[i]] += n; }
        D[i] = D[i + k] = 0;
      }
      LMSsort2(T, SA, C, B, D, n, k, cs);
      name = LMSpostproc2(SA, n, m);
      if(flags & 16) { SAIS_MYFREE(D, k * 2, sais_index_type); }
    } else {
      LMSsort1(T, SA, C, B, n, k, cs);
      name = LMSpostproc1(T, SA, n, m, cs);
    }
  } else if (m == 1) { /* only one S*-suffix => set immediately */
    *b = j + 1;        /* set entry in SA */
    if (level0) { LCP[b-SA] = -1; } /* mark first (=only) S*-suffix in bucket */
    name = 1;
  } else {
    name = 0;
  }

  /* stage 2: solve the reduced problem
     recurse if names are not yet unique */
  if(name < m) {
    if(flags & 4) { SAIS_MYFREE(C, k, sais_index_type); }
    if(flags & 2) { SAIS_MYFREE(B, k, sais_index_type); }
    newfs = (n + fs) - (m * 2);
    if((flags & (1 | 4 | 8)) == 0) {
      if((k + name) <= newfs) { newfs -= k; }
      else { flags |= 8; }
    }
    assert((n >> 1) <= (newfs + m));
    RA = SA + m + newfs;
    for(i = m + (n >> 1) - 1, j = m - 1; m <= i; --i) {
      if(SA[i] != 0) {
        RA[j--] = SA[i] - 1;
      }
    }
    
    if(sais_main(RA, SA, NULL, newfs, m, name, sizeof(sais_index_type), 0, 0) != 0) {
      if(flags & 1) { SAIS_MYFREE(C, k, sais_index_type); }
      return -2;
    }

    /* (re)compute starting positions of S*-suffixes (stored in RA): */
    i = n - 1; j = m - 1; c0 = chr(n - 1);
    do { c1 = c0; } while((0 <= --i) && ((c0 = chr(i)) >= c1));
    for(; 0 <= i;) {
      do { c1 = c0; } while((0 <= --i) && ((c0 = chr(i)) <= c1));
      if(0 <= i) {
        RA[j--] = i + 1;
        do { c1 = c0; } while((0 <= --i) && ((c0 = chr(i)) >= c1));
      }
    }

    /* construct LCP for S*-suffixes: */
    /* PHI: "to whom I want to be compared" (pos. in T) */
    /* DELTA: "distance (in T) to next S*" (in PHI-order) */
    if (level0) {
      if (m < n/3) { /* hence we can store PHI and DELTA interleaved */
	PHI = LCP+m;       /* use space in LCP-array for PHI and DELTA */
	RA[m] = n;         /* stopper */
	j = SA[0];         /* j stores SA[i-1] in the following loop */
	PHI[j<<1] = n-1;   /* set PHI[SA[0]] to $ (causes mismatch in char. comp.) */
	PHI[(j<<1)+1] = 0; /* set DELTA */
	for (i = 1; i < m; ++i) {
	  q = SA[i];                /* text position */
	  p = q<<1;                 /* for interleaving */
	  PHI[p]=RA[j];             /* set PHI-array */
	  PHI[p+1]=RA[j+1]-RA[j];   /* set DELTA */
	  j = q;                    /* store for next loop iteration */
	}

	PLCP = PHI; /* overwrite DELTA in following loop */
	p = 0; /* guaranteed LCP-value */
	j = 0; /* position in PLCP and RA */
	for (i = 0; i < n; ++i) {
	  if (i == RA[j]) {
	    sais_index_type twoj = j << 1;
	    if (p < 0) p = 0;
	    while (chr(i+p) == chr(PHI[twoj]+p)) ++p;
	    t = PHI[twoj+1];      /* accesses DELTA-value */
	    q = RA[j+1]-RA[j];    /* length difference */
	    PLCP[twoj] = p;       /* overwrite PHI with PLCP */
	    ++j;
	    p -= (t > q) ? t : q; /* decrease p by larger of t and q */
	  }
	}

	/* translate PLCP-values to SA-order: */
	for (j = 0; j < m; ++j) LCP[j] = PLCP[SA[j]<<1];
      }
      else { /* non-interleaved */
	PHI = LCP;     /* use space in LCP-array for PHI */
	DELTA = LCP+m; /* because we compute only m < n/2 values, this is valid */
	RA[m] = n;     /* stopper */
	j = SA[0];     /* j stores SA[i-1] in the following loop */
	PHI[j] = n-1;  /* set PHI[SA[0]] to $ (causes mismatch in char. comp.) */
	DELTA[j] = 0;
	for (i = 1; i < m; ++i) {
	  q = SA[i];              /* text position */
	  PHI[q]=RA[j];           /* set PHI-array */
	  DELTA[q]=RA[j+1]-RA[j]; /* set DELTA */
	  j = q;                  /* store for next loop iteration */
	}

	PLCP = DELTA; /* overwrite DELTA in following loop */
	p = 0; /* guaranteed LCP-value */
	j = 0; /* position in PLCP and RA */
	for (i = 0; i < n; ++i) {
	  if (i == RA[j]) {
	    if (p < 0) p = 0;
	    while (chr(i+p) == chr(PHI[j]+p)) ++p;
	    t = PLCP[j];          /* accesses DELTA-value */
	    q = RA[j+1]-RA[j];    /* length difference */
	    PLCP[j++] = p;
	    p -= (t > q) ? t : q; /* decrease p by larger of t and q */
	  }
	}

	/* translate PLCP-values to SA-order: */
	for (j = 0; j < m; ++j) LCP[j] = PLCP[SA[j]];
      }
    }

    /* translate indices in RA to indices in T: */
    for(i = 0; i < m; ++i) SA[i] = RA[SA[i]];

    if(flags & 4) {
      if((C = B = SAIS_MYMALLOC(k, int)) == NULL) { return -2; }
    }
    if(flags & 2) {
      if((B = SAIS_MYMALLOC(k, int)) == NULL) {
        if(flags & 1) { SAIS_MYFREE(C, k, sais_index_type); }
        return -2;
      }
    }
  } /* endif (name < m) */
  else if (level0) { /* this should only occur for small or pathetic inputs */
    /* all names unique => computing LCP for *S naively takes linear time */
    /*printf("*** computing LCP naively..."); */
    j = SA[0]; /* j = SA[i-1] in the following loop */
    for (i = 1; i < m; ++i) {
      p = 0;
      while (chr(SA[i]+p) == chr(j+p)) p++;
      LCP[i] = p;
      j = SA[i];
    }
    /*printf("done.\n"); */
  }

  /* stage 3: induce the result for the original problem */
  if(flags & 8) { getCounts(T, C, n, k, cs); }
  /* put all S*-suffixes (and their LCP-values) into their buckets */
  if(1 < m) { /* otherwise SA (and LCP) is already correct */
    getBuckets(C, B, k, 1); /* find ends of buckets */
    i = m - 1, j = n, p = SA[m - 1], c1 = chr(p);
    if (level0) {
      newfs = LCP[m-1]; /* newfs stores LCP[i] in the following loop */
      do {
	q = B[c0 = c1];
	while(q < j) {
	  SA[--j] = 0; LCP[j] = -2; /* set remaining entries in old bucket to 0/-2 */
	}
	
	do { /* step through bucket c0 and write S*-suffixes to SA: */
	  SA[--j] = p; LCP[j] = newfs;
	  if(--i < 0) break;
	  newfs = LCP[i]; p = SA[i];
	} while((c1 = chr(p)) == c0);
	/*assert(LCP[j]==0); *//* first S*-suffix in bucket must have LCP-value 0 */
	LCP[j] = -1;       /* mark first S*-suffix in every bucket */
      } while(0 <= i);
      while(0 < j) {
	SA[--j] = 0; LCP[j] = -2; /* set remaining entries in smallest buckets to 0/-2 */
      }
    }
    else {
      do {
	q = B[c0 = c1];
	while(q < j) SA[--j] = 0; /* set remaining entries in old bucket to 0 */
	do { /* step through bucket c0 */
	  SA[--j] = p;
	  if(--i < 0) break;
	  p = SA[i];
	} while((c1 = chr(p)) == c0);
      } while(0 <= i);
      while(0 < j) SA[--j] = 0; /* set remaining entries in 1st bucket to 0 */
    }
  }

  if(isbwt == 0) {
    if (level0) induceSAandLCP(T, SA, LCP, C, B, n, k, cs);
    else induceSA(T, SA, C, B, n, k, cs);
  }
  else { pidx = computeBWT(T, SA, C, B, n, k, cs); }
  if(flags & (1 | 4)) { SAIS_MYFREE(C, k, sais_index_type); }
  if(flags & 2) { SAIS_MYFREE(B, k, sais_index_type); }

  return pidx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
testq %rdi, %rdi
je 0x2ab199
testl %ecx, %ecx
js 0x2ab1b8
testl %r8d, %r8d
jle 0x2ab1b8
movl %r9d, %ebx
testl %r9d, %r9d
jle 0x2ab1b8
movq %rsi, %r13
movq %rdi, %r14
movl %ebx, %esi
pushq $-0x2
popq %r15
cmpl $0x100, %ebx            # imm = 0x100
movq %r8, 0x18(%rsp)
movq %rdx, 0x48(%rsp)
movq %rsi, 0x70(%rsp)
movq %rcx, 0x78(%rsp)
ja 0x2a8b89
movl %r15d, %ebp
leal (,%rbx,4), %r15d
movq %r15, %rdi
callq 0x2a0350
testq %rax, %rax
je 0x2a98ad
movq %rax, %r12
movq 0x78(%rsp), %rcx
cmpl %ebx, %ecx
jae 0x2a8c02
movq %r15, %rdi
callq 0x2a0350
testq %rax, %rax
je 0x2a98a5
xorl %edi, %edi
pushq $0x3
popq %rdx
movq %rdx, 0x28(%rsp)
jmp 0x2a8bb2
movl %ecx, %eax
subl %ebx, %eax
jae 0x2a8bc1
leaq (,%rsi,4), %rdi
callq 0x2a0350
testq %rax, %rax
je 0x2aac1c
pushq $0xc
popq %rcx
movq %rcx, 0x28(%rsp)
xorl %edi, %edi
movq %rax, %r12
movq 0x18(%rsp), %r8
movq 0x78(%rsp), %rcx
jmp 0x2a8c4f
leal (%r8,%rcx), %edx
subl %ebx, %edx
movslq %edx, %rdx
leaq (,%rdx,4), %r12
addq %r13, %r12
cmpl %ebx, %eax
jge 0x2a8c26
cmpl $0x400, %ebx            # imm = 0x400
ja 0x2a8c42
leal (,%rbx,4), %edi
callq 0x2a0350
testq %rax, %rax
je 0x2aac1c
pushq $0x2
popq %rcx
movq %rcx, 0x28(%rsp)
xorl %edi, %edi
jmp 0x2a8bb2
pushq $0x1
popq %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %r8
leal (%r8,%rcx), %eax
subl %ebx, %eax
cltq
leaq (,%rax,4), %rax
addq %r13, %rax
xorl %edi, %edi
jmp 0x2a8c4f
leaq (,%rsi,4), %rdx
movq %r12, %rax
subq %rdx, %rax
movq $0x0, 0x28(%rsp)
movb $0x1, %dil
jmp 0x2a8c4f
pushq $0x8
popq %rax
movq %rax, 0x28(%rsp)
xorl %edi, %edi
movq %r12, %rax
movq %rax, 0x20(%rsp)
movl 0xf0(%rsp), %ebp
cmpl $0x3fffffff, %r8d       # imm = 0x3FFFFFFF
ja 0x2a8caf
movl %r8d, %eax
xorl %edx, %edx
divl %ebx
cmpl $0x2, %eax
jb 0x2a8caf
movq 0x28(%rsp), %rsi
testb $0x1, %sil
jne 0x2a8c96
testb %dil, %dil
je 0x2a8caf
leal (%rbx,%rbx), %eax
subl %eax, %ecx
xorl %edx, %edx
cmpl %ecx, %eax
setle %dl
shll $0x5, %edx
movq %rdx, 0x28(%rsp)
jmp 0x2a8caf
leal (%rbx,%rbx), %eax
subl %ebx, %ecx
xorl %edx, %edx
cmpl %ecx, %eax
setle %dl
shll $0x4, %edx
addl %edx, %esi
addl $0x10, %esi
movq %rsi, 0x28(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movl %r8d, %edx
movl %ebx, %ecx
movl %ebp, %r8d
callq 0x2ab41f
pushq $0x1
popq %r15
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movl %ebx, %edx
movl %r15d, %ecx
callq 0x2ab45b
movq 0x18(%rsp), %r9
movl %r9d, %ecx
xorl %eax, %eax
cmpq %rax, %rcx
je 0x2a8cf2
andl $0x0, (%r13,%rax,4)
incq %rax
jmp 0x2a8ce2
leal -0x1(%r9), %r8d
cmpl $0x4, %ebp
movq %rcx, 0x38(%rsp)
jne 0x2a8d06
movl (%r14,%r8,4), %edx
jmp 0x2a8d0b
movzbl (%r14,%r8), %edx
movq 0x20(%rsp), %r11
leaq -0x1(%r8), %rdi
pushq $-0x1
popq %rax
movl %r8d, %ecx
testl %ecx, %ecx
jle 0x2a8d3d
movl %edi, %esi
cmpl $0x4, %ebp
jne 0x2a8d2b
movl (%r14,%rsi,4), %esi
jmp 0x2a8d30
movzbl (%r14,%rsi), %esi
decl %ecx
decq %rdi
cmpl %edx, %esi
movl %esi, %edx
jge 0x2a8d1a
jmp 0x2a8d41
movl %eax, %ecx
movl %edx, %esi
movq %rbx, 0x50(%rsp)
movq %r8, 0x40(%rsp)
leaq 0x8c(%rsp), %rdx
movq $0x0, 0x30(%rsp)
movl %r9d, %ebx
movl %ecx, %r9d
testl %r9d, %r9d
js 0x2a8e0d
movl %r9d, %r10d
decl %r9d
movq %r10, %rdi
movl %esi, %r8d
subq $0x1, %rdi
jb 0x2a8d9f
movl %r9d, %ecx
cmpl $0x4, %ebp
jne 0x2a8d8b
movl (%r14,%rdi,4), %esi
jmp 0x2a8d91
movzbl -0x1(%r14,%r10), %esi
leal -0x1(%rcx), %r9d
movq %rdi, %r10
cmpl %r8d, %esi
jle 0x2a8d74
jmp 0x2a8da7
movl %eax, %r9d
movl %r8d, %esi
jmp 0x2a8d62
movl %ebx, (%rdx)
movslq %r8d, %rdx
movslq (%r11,%rdx,4), %r8
leaq -0x1(%r8), %r9
movl %r9d, (%r11,%rdx,4)
leaq -0x4(,%r8,4), %rdx
addq %r13, %rdx
movq 0x30(%rsp), %r10
incq %r10
movl %ecx, %r8d
decq %r8
movq %r10, 0x30(%rsp)
testl %ecx, %ecx
jle 0x2a8e04
movl %r8d, %r9d
cmpl $0x4, %ebp
jne 0x2a8de8
movl (%r14,%r9,4), %r9d
jmp 0x2a8ded
movzbl (%r14,%r9), %r9d
decl %ecx
decq %r8
cmpl %esi, %r9d
movl %r9d, %esi
jge 0x2a8dd6
movl %edi, %ebx
movl %r9d, %esi
jmp 0x2a8d5f
movl %eax, %ecx
movl %edi, %ebx
jmp 0x2a8d5f
movq 0x30(%rsp), %rax
movl %eax, %r9d
cmpl $0x2, %eax
movq %r13, 0x80(%rsp)
movq %r12, 0x58(%rsp)
movq %r9, 0x60(%rsp)
jb 0x2a8e59
movq 0x28(%rsp), %rax
testb $0x30, %al
movq 0x18(%rsp), %r9
je 0x2a8e95
movq 0x50(%rsp), %rcx
leal (%rcx,%rcx), %edi
shlq $0x2, %rdi
testb $0x10, %al
jne 0x2a8ef3
movq %r11, %r15
subq %rdi, %r15
jmp 0x2a8f0e
xorl %r12d, %r12d
cmpl $0x1, %eax
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %r8
jne 0x2a978c
incl %ebx
movl %ebx, (%rdx)
cmpl $0x0, 0x100(%rsp)
je 0x2a9392
subq %r13, %rdx
movq 0x48(%rsp), %rcx
orl $-0x1, (%rcx,%rdx)
movl %r15d, %r12d
jmp 0x2a978c
cmpq %r11, %r12
movq 0x50(%rsp), %rbx
jne 0x2a8eb9
movq %r14, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movl %ebx, %ecx
movl %ebp, %r8d
callq 0x2ab41f
movq 0x20(%rsp), %r11
movq %r12, %rdi
movq %r11, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x2ab45b
movq 0x18(%rsp), %r8
movslq %r8d, %rdi
cmpl $0x4, %ebp
movq 0x40(%rsp), %rbx
jne 0x2a93a1
movl (%r14,%rbx,4), %edx
movslq %edx, %rax
leal -0x2(%r8), %esi
movl -0x8(%r14,%rdi,4), %ecx
jmp 0x2a93b4
callq 0x2a0350
movq 0x18(%rsp), %r9
movq 0x20(%rsp), %r11
movq %rax, %r15
testq %rax, %rax
je 0x2a9aaa
movl %ebx, %eax
leaq 0x1(%rax), %rcx
cmpl %r9d, %ecx
jge 0x2ab215
cmpl $0x4, %ebp
movq 0x40(%rsp), %rbx
jne 0x2a8f2e
movl 0x4(%r14,%rax,4), %eax
jmp 0x2a8f33
movzbl (%r14,%rcx), %eax
cltq
incl (%r11,%rax,4)
movq 0x70(%rsp), %rcx
leaq (%r15,%rcx,4), %rax
leaq (,%rcx,4), %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %rcx
je 0x2a8f84
addl (%r12,%rdx), %esi
movslq (%r11,%rdx), %rdi
cmpl %esi, %edi
je 0x2a8f75
movl (%r13,%rdi,4), %r8d
testl %r8d, %r8d
je 0x2aaf60
addl %r9d, %r8d
movl %r8d, (%r13,%rdi,4)
andl $0x0, (%rax,%rdx)
andl $0x0, (%r15,%rdx)
addq $0x4, %rdx
jmp 0x2a8f4e
cmpq %r11, %r12
je 0x2ab234
movq %r12, %rdi
movq %r11, %rsi
movq 0x50(%rsp), %rdx
xorl %ecx, %ecx
callq 0x2ab45b
cmpl $0x4, %ebp
jne 0x2a8fba
movl (%r14,%rbx,4), %eax
movslq %eax, %rdx
movq 0x18(%rsp), %r9
leal -0x2(%r9), %ecx
movl (%r14,%rcx,4), %r8d
jmp 0x2a8fcf
movzbl (%r14,%rbx), %edx
movq 0x18(%rsp), %r9
leal -0x2(%r9), %ecx
movzbl (%r14,%rcx), %r8d
movl %edx, %eax
movq 0x20(%rsp), %rsi
movslq (%rsi,%rdx,4), %rdx
xorl %edi, %edi
cmpl %eax, %r8d
setl %dil
addl %r9d, %ecx
negl %edi
xorl %ecx, %edi
leaq 0x4(,%rdx,4), %rdx
addq %r13, %rdx
movl %edi, -0x4(%rdx)
xorl %ecx, %ecx
xorl %r12d, %r12d
movq 0x38(%rsp), %rdi
cmpq %rcx, %rdi
je 0x2a90fc
movl (%r13,%rcx,4), %edi
testl %edi, %edi
jle 0x2a9044
xorl %r11d, %r11d
cmpl %r9d, %edi
movq %r9, %r8
movl $0x0, %r9d
cmovgel %r8d, %r9d
setge %r8b
subl %r9d, %edi
movslq %edi, %r9
cmpl $0x4, %ebp
jne 0x2a9051
movl (%r14,%r9,4), %edi
cmpl 0x4(%r14,%r9,4), %edi
jge 0x2a9061
jmp 0x2aaee4
jns 0x2a90f4
notl %edi
jmp 0x2a90ef
movzbl (%r14,%r9), %edi
cmpb 0x1(%r14,%r9), %dil
jb 0x2aaee4
cmpl %eax, %edi
je 0x2a9085
subq %r13, %rdx
shrq $0x2, %rdx
cltq
movl %edx, (%rsi,%rax,4)
movslq %edi, %rax
movslq (%rsi,%rax,4), %rax
leaq (,%rax,4), %rdx
addq %r13, %rdx
movl %edi, %eax
movq %rdx, %r10
subq %r13, %r10
sarq $0x2, %r10
cmpq %rcx, %r10
jle 0x2aaec5
leaq -0x1(%r9), %r10
cmpl $0x4, %ebp
jne 0x2a90a8
movl -0x4(%r14,%r9,4), %r9d
jmp 0x2a90ad
movzbl (%r14,%r10), %r9d
movb %r8b, %r11b
addl %r11d, %r12d
addl %edi, %edi
xorl %r8d, %r8d
cmpl %eax, %r9d
setl %r8b
orl %edi, %r8d
movslq %r8d, %rdi
cmpl %r12d, (%r15,%rdi,4)
je 0x2a90d4
addl 0x18(%rsp), %r10d
movl %r12d, (%r15,%rdi,4)
xorl %edi, %edi
cmpl %eax, %r9d
setl %dil
negl %edi
xorl %r10d, %edi
movl %edi, (%rdx)
addq $0x4, %rdx
xorl %edi, %edi
movq 0x18(%rsp), %r9
movl %edi, (%r13,%rcx,4)
incq %rcx
jmp 0x2a8ffb
movl %ebx, %eax
testl %eax, %eax
js 0x2a913f
movl %eax, %ecx
movl (%r13,%rcx,4), %edx
testl %edx, %edx
setle %r8b
cmpl %r9d, %edx
setge %dil
orb %r8b, %dil
jne 0x2a913b
addl %r9d, %edx
leaq (,%rcx,4), %rcx
addq %r13, %rcx
movl %edx, (%rcx)
movl -0x4(%rcx), %edx
addq $-0x4, %rcx
decl %eax
subl %r9d, %edx
jl 0x2a912b
movl %edx, (%rcx)
decl %eax
jmp 0x2a90fe
pushq $0x1
popq %rcx
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rdx
callq 0x2ab45b
movq 0x20(%rsp), %r11
incl %r12d
movslq (%r11), %rax
leaq (,%rax,4), %rcx
addq %r13, %rcx
xorl %esi, %esi
pushq $-0x2
popq %rax
movl %ebx, %edx
movq 0x30(%rsp), %r10
testl %edx, %edx
js 0x2a9276
movl %edx, %edi
movl (%r13,%rdi,4), %r9d
testl %r9d, %r9d
jle 0x2a926f
xorl %r8d, %r8d
movq 0x18(%rsp), %r10
cmpl %r10d, %r9d
movl $0x0, %r11d
cmovgel %r10d, %r11d
setge %r10b
subl %r11d, %r9d
movslq %r9d, %r11
cmpl $0x4, %ebp
jne 0x2a91bf
movl (%r14,%r11,4), %r9d
cmpl 0x4(%r14,%r11,4), %r9d
jle 0x2a91cf
jmp 0x2aaf03
movzbl (%r14,%r11), %r9d
cmpb 0x1(%r14,%r11), %r9b
ja 0x2aaf03
cmpl %esi, %r9d
je 0x2a91fb
subq %r13, %rcx
shrq $0x2, %rcx
movslq %esi, %rsi
movq 0x20(%rsp), %rbx
movl %ecx, (%rbx,%rsi,4)
movslq %r9d, %rcx
movslq (%rbx,%rcx,4), %rcx
leaq (,%rcx,4), %rcx
addq %r13, %rcx
movl %r9d, %esi
movq %rcx, %rbx
subq %r13, %rbx
sarq $0x2, %rbx
cmpq %rdi, %rbx
jg 0x2aaf22
leaq -0x1(%r11), %rbx
cmpl $0x4, %ebp
jne 0x2a921e
movl -0x4(%r14,%r11,4), %r11d
jmp 0x2a9223
movzbl (%r14,%rbx), %r11d
movb %r10b, %r8b
addl %r8d, %r12d
addl %r9d, %r9d
xorl %r8d, %r8d
cmpl %esi, %r11d
setg %r8b
orl %r9d, %r8d
movslq %r8d, %r8
cmpl %r12d, (%r15,%r8,4)
je 0x2a924a
addl 0x18(%rsp), %ebx
movl %r12d, (%r15,%r8,4)
movl %eax, %r8d
subl %ebx, %r8d
cmpl %esi, %r11d
cmovlel %ebx, %r8d
movl %r8d, -0x4(%rcx)
addq $-0x4, %rcx
andl $0x0, (%r13,%rdi,4)
movq 0x20(%rsp), %r11
movq 0x30(%rsp), %r10
decl %edx
jmp 0x2a9173
xorl %eax, %eax
xorl %r12d, %r12d
movq 0x18(%rsp), %r8
movq 0x38(%rsp), %rdi
movl (%r13,%rax,4), %ecx
testl %ecx, %ecx
jns 0x2a92c7
notl %ecx
xorl %edx, %edx
cmpl %r8d, %ecx
setge %dl
addl %edx, %r12d
movl %ecx, (%r13,%rax,4)
incq %rax
cmpq %rdi, %rax
jb 0x2a9285
leaq 0x3ccaf4(%rip), %rdi    # 0x675da3
leaq 0x3cc942(%rip), %rsi    # 0x675bf8
leaq 0x3ccac4(%rip), %rcx    # 0x675d81
movl $0xe8, %edx
callq 0x2a0190
cmpl %eax, %r10d
jle 0x2a930d
movl %eax, %ecx
movq %rax, %rsi
leaq 0x1(%rsi), %rax
cmpq %rdi, %rax
jae 0x2aae03
movl 0x4(%r13,%rsi,4), %edx
movq %rax, %rsi
testl %edx, %edx
jns 0x2a92d1
notl %edx
xorl %esi, %esi
cmpl %r8d, %edx
setge %sil
addl %esi, %r12d
movslq %ecx, %rsi
incl %ecx
movl %edx, (%r13,%rsi,4)
andl $0x0, (%r13,%rax,4)
cmpl %r10d, %ecx
jne 0x2a92ce
cmpl %r10d, %r12d
jge 0x2a934d
leal 0x1(%r12), %eax
movq 0x60(%rsp), %rcx
testl %ecx, %ecx
jle 0x2a9368
movl -0x4(%r13,%rcx,4), %edx
decq %rcx
xorl %esi, %esi
cmpl %r8d, %edx
setge %sil
movl $0x0, %edi
cmovgel %r8d, %edi
subl %edi, %edx
subl %esi, %eax
sarl %edx
addl %r10d, %edx
movslq %edx, %rdx
movl %eax, (%r13,%rdx,4)
jmp 0x2a931c
xorl %eax, %eax
cmpq %rax, %r10
je 0x2a9368
movl (%r13,%rax,4), %ecx
subl %r8d, %ecx
jl 0x2a9363
movl %ecx, (%r13,%rax,4)
incq %rax
jmp 0x2a934f
movq 0x28(%rsp), %rax
testb $0x10, %al
je 0x2a9388
movq %r15, %rdi
callq 0x2a02f0
movq 0x18(%rsp), %r8
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %r11
movq 0x60(%rsp), %r9
jmp 0x2a978c
movq 0x58(%rsp), %r12
movq 0x40(%rsp), %rbx
jmp 0x2a9d49
movzbl (%r14,%rbx), %eax
movzbl -0x2(%r14,%rdi), %ecx
addq $-0x2, %rdi
movl %edi, %esi
movl %eax, %edx
pushq $0x1
popq %rdi
subl %r8d, %edi
cmpl %edx, %ecx
cmovgel %esi, %edi
movq 0x20(%rsp), %rsi
movslq (%rsi,%rax,4), %rcx
leal 0x1(%rcx), %eax
movl %edi, (%r13,%rcx,4)
xorl %ecx, %ecx
movq 0x38(%rsp), %rdi
cmpq %rcx, %rdi
je 0x2a9474
movslq (%r13,%rcx,4), %r9
testq %r9, %r9
jle 0x2a93ff
cmpl $0x4, %ebp
jne 0x2a9409
movl (%r14,%r9,4), %edi
cmpl 0x4(%r14,%r9,4), %edi
jge 0x2a9419
jmp 0x2aaf98
testl %r9d, %r9d
jns 0x2a946c
notl %r9d
jmp 0x2a9467
movzbl (%r14,%r9), %edi
cmpb 0x1(%r14,%r9), %dil
jb 0x2aaf98
cmpl %edx, %edi
jne 0x2a9421
movl %edx, %edi
jmp 0x2a942d
movslq %edx, %rdx
movl %eax, (%rsi,%rdx,4)
movslq %edi, %rax
movl (%rsi,%rax,4), %eax
cltq
cmpq %rax, %rcx
jge 0x2aaf7f
leal -0x1(%r9), %edx
cmpl $0x4, %ebp
jne 0x2a9447
movl (%r14,%rdx,4), %r8d
jmp 0x2a944c
movzbl (%r14,%rdx), %r8d
negl %r9d
cmpl %edi, %r8d
cmovgel %edx, %r9d
movl %r9d, (%r13,%rax,4)
incl %eax
xorl %r9d, %r9d
movl %edi, %edx
movq 0x38(%rsp), %rdi
movl %r9d, (%r13,%rcx,4)
incq %rcx
jmp 0x2a93d7
cmpq %rsi, %r12
jne 0x2a9496
movq %r14, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movq 0x50(%rsp), %rcx
movl %ebp, %r8d
callq 0x2ab41f
movq 0x20(%rsp), %rsi
pushq $0x1
popq %rcx
movq %r12, %rdi
movq 0x50(%rsp), %rdx
callq 0x2ab45b
movq 0x20(%rsp), %r11
movl (%r11), %eax
xorl %r8d, %r8d
movl %ebx, %ecx
movq 0x38(%rsp), %rdi
testl %ecx, %ecx
js 0x2a954d
movl %ecx, %edx
movslq (%r13,%rdx,4), %rsi
testq %rsi, %rsi
jle 0x2a9546
cmpl $0x4, %ebp
jne 0x2a94e1
movl (%r14,%rsi,4), %edi
cmpl 0x4(%r14,%rsi,4), %edi
jle 0x2a94f1
jmp 0x2aafb1
movzbl (%r14,%rsi), %edi
cmpb 0x1(%r14,%rsi), %dil
ja 0x2aafb1
cmpl %r8d, %edi
jne 0x2a94fb
movl %r8d, %edi
jmp 0x2a9509
movslq %r8d, %r8
movl %eax, (%r11,%r8,4)
movslq %edi, %rax
movl (%r11,%rax,4), %eax
cmpl %ecx, %eax
jg 0x2aafca
leal -0x1(%rsi), %r8d
cmpl $0x4, %ebp
jne 0x2a9520
movl (%r14,%r8,4), %r9d
jmp 0x2a9525
movzbl (%r14,%r8), %r9d
cmpl %edi, %r9d
notl %esi
cmovlel %r8d, %esi
movslq %eax, %r8
decl %eax
movl %esi, -0x4(%r13,%r8,4)
andl $0x0, (%r13,%rdx,4)
movl %edi, %r8d
movq 0x38(%rsp), %rdi
decl %ecx
jmp 0x2a94b8
xorl %eax, %eax
movl (%r13,%rax,4), %ecx
testl %ecx, %ecx
jns 0x2a9583
notl %ecx
movl %ecx, (%r13,%rax,4)
incq %rax
cmpq %rdi, %rax
jb 0x2a954f
leaq 0x3cc835(%rip), %rdi    # 0x675da3
leaq 0x3cc683(%rip), %rsi    # 0x675bf8
leaq 0x3cc88a(%rip), %rcx    # 0x675e06
pushq $0x7f
jmp 0x2aafe1
cmpl %eax, 0x30(%rsp)
jle 0x2a95bf
movl %eax, %ecx
movq %rax, %rsi
leaq 0x1(%rsi), %rax
cmpq %rdi, %rax
jae 0x2aae22
movl 0x4(%r13,%rsi,4), %edx
movq %rax, %rsi
testl %edx, %edx
jns 0x2a958e
notl %edx
movslq %ecx, %rsi
incl %ecx
movl %edx, (%r13,%rsi,4)
andl $0x0, (%r13,%rax,4)
cmpl 0x30(%rsp), %ecx
jne 0x2a958b
cmpl $0x4, %ebp
jne 0x2a95ca
movl (%r14,%rbx,4), %edx
jmp 0x2a95cf
movzbl (%r14,%rbx), %edx
leaq -0x1(%rbx), %rdi
pushq $-0x1
popq %rax
movl %ebx, %ecx
testl %ecx, %ecx
jle 0x2a95fb
movl %edi, %esi
cmpl $0x4, %ebp
jne 0x2a95e9
movl (%r14,%rsi,4), %esi
jmp 0x2a95ee
movzbl (%r14,%rsi), %esi
decl %ecx
decq %rdi
cmpl %edx, %esi
movl %esi, %edx
jge 0x2a95d8
jmp 0x2a95ff
movl %eax, %ecx
movl %edx, %esi
movl %ebx, %edx
movq 0x30(%rsp), %rbx
movl %ecx, %r9d
movl %esi, %edi
testl %r9d, %r9d
js 0x2a969b
movl %r9d, %r10d
decl %r9d
movq %r10, %r8
subq $0x1, %r8
jb 0x2a9646
movl %r9d, %ecx
cmpl $0x4, %ebp
jne 0x2a9631
movl (%r14,%r8,4), %esi
jmp 0x2a9637
movzbl -0x1(%r14,%r10), %esi
leal -0x1(%rcx), %r9d
movq %r8, %r10
cmpl %edi, %esi
movl %esi, %edi
jle 0x2a961d
jmp 0x2a964b
movl %eax, %r9d
jmp 0x2a960b
movl %edx, %edi
subl %r8d, %edi
movl %r8d, %edx
incl %edx
movl %edx, %r8d
shrl %r8d
addl %ebx, %r8d
movl %edi, (%r13,%r8,4)
movl %ecx, %edi
decq %rdi
testl %ecx, %ecx
jle 0x2a9694
movl %edi, %r8d
cmpl $0x4, %ebp
jne 0x2a967a
movl (%r14,%r8,4), %r8d
jmp 0x2a967f
movzbl (%r14,%r8), %r8d
decl %ecx
decq %rdi
cmpl %esi, %r8d
movl %r8d, %esi
jge 0x2a9668
movl %r8d, %esi
jmp 0x2a9606
movl %eax, %ecx
jmp 0x2a9606
xorl %eax, %eax
movq 0x18(%rsp), %r8
movl %r8d, %r10d
xorl %esi, %esi
xorl %r12d, %r12d
movq 0x60(%rsp), %r9
cmpq %r9, %rax
je 0x2a9787
movl (%r13,%rax,4), %ecx
movl %ecx, %edx
sarl %edx
addl %ebx, %edx
movslq %edx, %r15
movl (%r13,%r15,4), %edi
cmpl %esi, %edi
jne 0x2a9772
leal (%rdi,%r10), %edx
cmpl %r8d, %edx
jge 0x2a9772
movq %r15, 0x98(%rsp)
movslq %ecx, %rdx
movq %r10, 0x68(%rsp)
movslq %r10d, %r8
testl %esi, %esi
movl $0x0, %r9d
cmovgl %esi, %r9d
leaq (%r14,%rdx), %r10
leaq (%r14,%r8), %r11
leaq (%r14,%rdx,4), %rbx
leaq (%r14,%r8,4), %r13
xorl %r15d, %r15d
cmpq %r15, %r9
je 0x2a973e
cmpl $0x4, %ebp
jne 0x2a9727
movl (%rbx,%r15,4), %edx
movl (%r13,%r15,4), %r8d
jmp 0x2a9731
movzbl (%r10,%r15), %edx
movzbl (%r11,%r15), %r8d
cmpl %r8d, %edx
jne 0x2a973b
incq %r15
jmp 0x2a9712
movl %r15d, %r9d
cmpl %esi, %r9d
movq 0x80(%rsp), %r13
movq 0x20(%rsp), %r11
movq 0x18(%rsp), %r8
movq 0x30(%rsp), %rbx
movq 0x60(%rsp), %r9
movq 0x68(%rsp), %rdx
movq 0x98(%rsp), %r15
jne 0x2a9772
movl %edx, %ecx
movl %esi, %edi
jmp 0x2a9775
incl %r12d
movl %r12d, (%r13,%r15,4)
incq %rax
movl %ecx, %r10d
movl %edi, %esi
jmp 0x2a96af
movq 0x28(%rsp), %rax
cmpl 0x30(%rsp), %r12d
jge 0x2a980a
testb $0x4, %al
movq 0x50(%rsp), %rbx
je 0x2a97ba
movq 0x58(%rsp), %rdi
callq 0x2a02f0
movq 0x60(%rsp), %r9
movq 0x18(%rsp), %r8
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %r11
testb $0x2, %al
je 0x2a97d0
movq %r11, %rdi
callq 0x2a02f0
movq 0x60(%rsp), %r9
movq 0x18(%rsp), %r8
movq 0x78(%rsp), %rcx
addl %r8d, %ecx
movq 0x30(%rsp), %rax
addl %eax, %eax
subl %eax, %ecx
testb $0xd, 0x28(%rsp)
jne 0x2a98b7
leal (%r12,%rbx), %eax
cmpl %ecx, %eax
jle 0x2a98b5
movq 0x28(%rsp), %rax
orl $0x8, %eax
movq %rax, 0x28(%rsp)
jmp 0x2a98b7
cmpl $0x0, 0x100(%rsp)
movq 0x48(%rsp), %r15
je 0x2a9896
pushq $0x1
popq %rax
movq %r13, %rcx
movq 0x58(%rsp), %r12
movq 0x40(%rsp), %rbx
cmpq %r9, %rax
jae 0x2a988c
movslq (%rcx), %rsi
leaq (,%rax,4), %rcx
addq %r13, %rcx
leaq (%r14,%rsi), %rdx
leaq (%r14,%rsi,4), %rsi
movslq (%rcx), %rdi
leaq (%r14,%rdi), %r8
leaq (%r14,%rdi,4), %r9
xorl %edi, %edi
cmpl $0x4, %ebp
jne 0x2a9860
movl (%r9,%rdi,4), %r10d
movl (%rsi,%rdi,4), %r11d
jmp 0x2a986a
movzbl (%r8,%rdi), %r10d
movzbl (%rdx,%rdi), %r11d
incq %rdi
cmpl %r11d, %r10d
je 0x2a9851
decl %edi
movl %edi, (%r15,%rax,4)
incq %rax
movq 0x20(%rsp), %r11
movq 0x18(%rsp), %r8
movq 0x60(%rsp), %r9
jmp 0x2a9829
movq 0x28(%rsp), %rax
jmp 0x2a9d7d
movq 0x58(%rsp), %r12
movq 0x40(%rsp), %rbx
jmp 0x2a9d7d
movq %r12, %rdi
callq 0x2a02f0
movl %ebp, %r15d
jmp 0x2aac1c
subl %ebx, %ecx
movl %r8d, %eax
shrl %eax
movq 0x30(%rsp), %rsi
leal (%rcx,%rsi), %edx
cmpl %edx, %eax
jg 0x2ab1f6
leaq (,%r9,4), %rdi
addq %r13, %rdi
movslq %ecx, %rdx
leaq (%rdi,%rdx,4), %r15
addl %esi, %eax
leal -0x1(%rsi), %ebx
cltq
movl %ebx, %edi
cmpq %r9, %rax
jle 0x2a9905
movl -0x4(%r13,%rax,4), %edx
decq %rax
testl %edx, %edx
je 0x2a98e7
decl %edx
movslq %edi, %rsi
decl %edi
movl %edx, (%r15,%rsi,4)
jmp 0x2a98e7
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movl $0x4, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq 0x30(%rsp), %r8
movl %r12d, %r9d
callq 0x2a8ae1
testl %eax, %eax
je 0x2a9949
testb $0x1, 0x28(%rsp)
movq 0x58(%rsp), %rdi
je 0x2a9940
callq 0x2a02f0
pushq $-0x2
popq %r15
jmp 0x2aac1c
cmpl $0x4, %ebp
movq 0x58(%rsp), %r12
jne 0x2a995e
movq 0x40(%rsp), %rcx
movl (%r14,%rcx,4), %esi
jmp 0x2a9968
movq 0x40(%rsp), %rcx
movzbl (%r14,%rcx), %esi
movq 0x20(%rsp), %r11
movq 0x60(%rsp), %r10
leaq -0x1(%rcx), %rdi
pushq $-0x1
popq %rax
testl %ecx, %ecx
jle 0x2a999c
movl %edi, %edx
cmpl $0x4, %ebp
jne 0x2a998a
movl (%r14,%rdx,4), %edx
jmp 0x2a998f
movzbl (%r14,%rdx), %edx
decl %ecx
decq %rdi
cmpl %esi, %edx
movl %edx, %esi
jge 0x2a9979
jmp 0x2a99a0
movl %eax, %ecx
movl %esi, %edx
movl %ecx, %r8d
movl %edx, %esi
testl %r8d, %r8d
js 0x2a9a1a
movl %r8d, %r9d
decl %r8d
movq %r9, %rdi
subq $0x1, %rdi
jb 0x2a99dc
movl %r8d, %ecx
cmpl $0x4, %ebp
jne 0x2a99c7
movl (%r14,%rdi,4), %edx
jmp 0x2a99cd
movzbl -0x1(%r14,%r9), %edx
leal -0x1(%rcx), %r8d
movq %rdi, %r9
cmpl %esi, %edx
movl %edx, %esi
jle 0x2a99b3
jmp 0x2a99e1
movl %eax, %r8d
jmp 0x2a99a5
incl %edi
movslq %ebx, %rsi
decl %ebx
movl %edi, (%r15,%rsi,4)
movl %ecx, %esi
decq %rsi
testl %ecx, %ecx
jle 0x2a9a16
movl %esi, %edi
cmpl $0x4, %ebp
jne 0x2a9a02
movl (%r14,%rdi,4), %edi
jmp 0x2a9a07
movzbl (%r14,%rdi), %edi
decl %ecx
decq %rsi
cmpl %edx, %edi
movl %edi, %edx
jge 0x2a99f1
movl %edi, %edx
jmp 0x2a99a0
movl %eax, %ecx
jmp 0x2a99a0
cmpl $0x0, 0x100(%rsp)
movq 0x40(%rsp), %rbx
movq 0x18(%rsp), %r8
je 0x2a9cf4
movl %r8d, %eax
xorl %edx, %edx
pushq $0x3
popq %rcx
divl %ecx
movq 0x48(%rsp), %rsi
leaq (%rsi,%r10,4), %rcx
movl %r8d, (%r15,%r10,4)
movl (%r13), %edx
cmpl %eax, 0x30(%rsp)
jae 0x2a9ad9
leal (%rdx,%rdx), %eax
cltq
movl %ebx, (%rcx,%rax,4)
leal 0x1(,%rdx,2), %eax
cltq
andl $0x0, (%rcx,%rax,4)
pushq $0x1
popq %rax
cmpq %r10, %rax
jae 0x2a9b15
movslq %edx, %rdx
movl (%r13,%rax,4), %esi
leal (%rsi,%rsi), %edi
movl (%r15,%rdx,4), %r8d
movslq %edi, %rdi
movl %r8d, (%rcx,%rdi,4)
movl 0x4(%r15,%rdx,4), %edx
subl %r8d, %edx
leal 0x1(,%rsi,2), %edi
movslq %edi, %rdi
movl %edx, (%rcx,%rdi,4)
incq %rax
movl %esi, %edx
jmp 0x2a9a6f
movq 0x28(%rsp), %rax
testb $0x5, %al
je 0x2a9ac5
movq %r12, %rdi
callq 0x2a02f0
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %r11
testb $0x2, %al
pushq $-0x2
popq %r15
je 0x2aac1c
movq %r11, %rdi
jmp 0x2aac17
movslq %edx, %rax
movl %ebx, (%rsi,%rax,4)
andl $0x0, (%rcx,%rax,4)
pushq $0x1
popq %rax
movq 0x48(%rsp), %r8
cmpq %r10, %rax
jae 0x2a9bdd
movslq %edx, %rdx
movslq (%r13,%rax,4), %rsi
movl (%r15,%rdx,4), %edi
movl %edi, (%r8,%rsi,4)
movl 0x4(%r15,%rdx,4), %edx
subl %edi, %edx
movl %edx, (%rcx,%rsi,4)
incq %rax
movl %esi, %edx
jmp 0x2a9aeb
xorl %eax, %eax
movq %r14, %rdx
movq %r14, %rsi
xorl %edi, %edi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq 0x38(%rsp), %rdi
je 0x2a9c9f
movslq %r8d, %r11
movl (%r15,%r11,4), %r10d
cmpq %r10, %rdi
jne 0x2a9bce
leal (%r8,%r8), %ebx
testl %r9d, %r9d
cmovlel %eax, %r9d
movslq %ebx, %rbx
cmpl $0x4, %ebp
jne 0x2a9b67
movl (%rsi,%r9,4), %r12d
movl (%rcx,%rbx,4), %r13d
addl %r9d, %r13d
movslq %r13d, %r13
movl (%r14,%r13,4), %r13d
jmp 0x2a9b7b
movzbl (%rdx,%r9), %r12d
movl (%rcx,%rbx,4), %r13d
addl %r9d, %r13d
movslq %r13d, %r13
movzbl (%r14,%r13), %r13d
incq %r9
cmpl %r13d, %r12d
je 0x2a9b4e
leal -0x1(%r9), %r12d
movl %ebx, %r13d
orl $0x1, %r13d
movslq %r13d, %r13
movl (%rcx,%r13,4), %r13d
movl %r13d, 0x8c(%rsp)
incl %r8d
movl 0x4(%r15,%r11,4), %r11d
subl %r10d, %r11d
cmpl %r11d, %r13d
cmovgl %r13d, %r11d
movl %r12d, (%rcx,%rbx,4)
notl %r11d
addl %r9d, %r11d
movl %r11d, %r9d
movq 0x80(%rsp), %r13
movq 0x58(%rsp), %r12
movq 0x40(%rsp), %rbx
incq %rdi
addq $0x4, %rsi
incq %rdx
jmp 0x2a9b25
xorl %eax, %eax
movq %r14, %rdx
movq %r14, %rsi
xorl %edi, %edi
xorl %r11d, %r11d
xorl %r8d, %r8d
cmpq 0x38(%rsp), %rdi
je 0x2a9ccc
movslq %r11d, %r9
movl (%r15,%r9,4), %r10d
cmpq %r10, %rdi
jne 0x2a9c90
testl %r8d, %r8d
cmovlel %eax, %r8d
cmpl $0x4, %ebp
jne 0x2a9c2d
movl (%rsi,%r8,4), %r11d
movq 0x48(%rsp), %rbx
movl (%rbx,%r9,4), %ebx
addl %r8d, %ebx
movslq %ebx, %rbx
movl (%r14,%rbx,4), %ebx
jmp 0x2a9c46
movzbl (%rdx,%r8), %r11d
movq 0x48(%rsp), %rbx
movl (%rbx,%r9,4), %ebx
addl %r8d, %ebx
movslq %ebx, %rbx
movzbl (%r14,%rbx), %ebx
incq %r8
cmpl %ebx, %r11d
je 0x2a9c0f
leal -0x1(%r8), %ebx
movl (%rcx,%r9,4), %r12d
movl %r12d, 0x8c(%rsp)
leal 0x1(%r9), %r11d
movl 0x4(%r15,%r9,4), %r13d
subl %r10d, %r13d
cmpl %r13d, %r12d
cmovgl %r12d, %r13d
movq 0x58(%rsp), %r12
movl %ebx, (%rcx,%r9,4)
notl %r13d
addl %r8d, %r13d
movl %r13d, %r8d
movq 0x80(%rsp), %r13
movq 0x40(%rsp), %rbx
incq %rdi
addq $0x4, %rsi
incq %rdx
jmp 0x2a9bed
xorl %eax, %eax
movq 0x20(%rsp), %r11
movq 0x18(%rsp), %r8
movq 0x48(%rsp), %rsi
cmpq %rax, 0x30(%rsp)
je 0x2a9cf4
movl (%r13,%rax,4), %edx
addl %edx, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %edx
movl %edx, (%rsi,%rax,4)
incq %rax
jmp 0x2a9cb0
xorl %eax, %eax
movq 0x20(%rsp), %r11
movq 0x18(%rsp), %r8
movq 0x48(%rsp), %rsi
cmpq %rax, 0x30(%rsp)
je 0x2a9cf4
movslq (%r13,%rax,4), %rdx
movl (%rcx,%rdx,4), %edx
movl %edx, (%rsi,%rax,4)
incq %rax
jmp 0x2a9cdd
movq %r13, %rax
movq 0x30(%rsp), %rcx
subq $0x1, %rcx
jb 0x2a9d11
movslq (%rax), %rdx
movl (%r15,%rdx,4), %edx
movl %edx, (%rax)
addq $0x4, %rax
jmp 0x2a9cfc
movq 0x28(%rsp), %rax
testb $0x4, %al
je 0x2a9d45
movq 0x70(%rsp), %rax
leaq (,%rax,4), %rdi
callq 0x2a0350
movq 0x18(%rsp), %r8
movq %rax, %r11
movq 0x28(%rsp), %rax
movq %r11, %r12
testq %r11, %r11
je 0x2a9940
testb $0x2, %al
jne 0x2a9d50
movq 0x48(%rsp), %r15
jmp 0x2a9d7d
movq 0x70(%rsp), %rax
leaq (,%rax,4), %rdi
callq 0x2a0350
testq %rax, %rax
movq 0x48(%rsp), %r15
je 0x2aadf0
movq %rax, %r11
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %r8
movq %rax, 0x28(%rsp)
testb $0x8, %al
movq %r11, 0x20(%rsp)
je 0x2a9da6
movq %r14, %rdi
movq %r12, %rsi
movl %r8d, %edx
movq 0x50(%rsp), %rcx
movl %ebp, %r8d
callq 0x2ab41f
movq 0x20(%rsp), %r11
movq %r12, 0x58(%rsp)
movq 0x30(%rsp), %r12
cmpl $0x2, %r12d
jb 0x2a9f58
pushq $0x1
popq %rcx
movq 0x58(%rsp), %rdi
movq %r11, %rsi
movq 0x50(%rsp), %rdx
callq 0x2ab45b
leal -0x1(%r12), %eax
movl (%r13,%rax,4), %ecx
movslq %ecx, %rdx
cmpl $0x4, %ebp
jne 0x2a9de7
movl (%r14,%rdx,4), %edx
jmp 0x2a9dec
movzbl (%r14,%rdx), %edx
cmpl $0x0, 0x100(%rsp)
movq 0x20(%rsp), %r9
je 0x2a9ec2
movl (%r15,%rax,4), %r8d
movq 0x18(%rsp), %rsi
movslq %edx, %rdi
movslq (%r9,%rdi,4), %r10
movslq %esi, %r11
cmpq %r10, %r11
movq %r10, %rdi
cmovlq %r11, %rdi
decl %edi
leaq -0x1(%r11), %r9
cmpq %r10, %r11
jle 0x2a9e40
andl $0x0, -0x4(%r13,%r11,4)
movl $0xfffffffe, -0x4(%r15,%r11,4) # imm = 0xFFFFFFFE
decq %r11
decq %r9
decl %esi
jmp 0x2a9e22
movl %eax, %r10d
decq %r10
movl %ecx, (%r13,%r9,4)
movl %r8d, (%r15,%r9,4)
testl %eax, %eax
jle 0x2a9e9a
movl %r10d, %r8d
shlq $0x2, %r8
movl (%r13,%r8), %ecx
movslq %ecx, %r11
cmpl $0x4, %ebp
jne 0x2a9e6d
movl (%r14,%r11,4), %r11d
jmp 0x2a9e72
movzbl (%r14,%r11), %r11d
movl (%r15,%r8), %r8d
decl %edi
decq %r9
decl %esi
decl %eax
decq %r10
cmpl %edx, %r11d
je 0x2a9e46
orl $-0x1, 0x4(%r15,%r9,4)
movl %r11d, %edx
movq 0x20(%rsp), %r9
jmp 0x2a9e08
orl $-0x1, (%r15,%r9,4)
movl %edi, %eax
movq 0x20(%rsp), %r11
testl %eax, %eax
jle 0x2a9f58
andl $0x0, -0x4(%r13,%rax,4)
movl $0xfffffffe, -0x4(%r15,%rax,4) # imm = 0xFFFFFFFE
decq %rax
jmp 0x2a9ea6
leaq -0x4(%r13), %rsi
movq 0x18(%rsp), %rdi
movl %edx, %r8d
movslq %edx, %rdx
movq 0x20(%rsp), %r9
movslq (%r9,%rdx,4), %rdx
movslq %edi, %r11
cmpq %rdx, %r11
movq %rdx, %r9
cmovlq %r11, %r9
decl %r9d
leaq (%rsi,%r11,4), %r10
cmpq %rdx, %r11
jle 0x2a9f04
andl $0x0, -0x4(%r13,%r11,4)
decq %r11
decl %edi
addq $-0x4, %r10
jmp 0x2a9eee
movl %eax, %r11d
decq %r11
movl %ecx, (%r10)
testl %eax, %eax
jle 0x2a9f41
movl %r11d, %ecx
movl (%r13,%rcx,4), %ecx
movslq %ecx, %rdx
cmpl $0x4, %ebp
jne 0x2a9f27
movl (%r14,%rdx,4), %edx
jmp 0x2a9f2c
movzbl (%r14,%rdx), %edx
decl %r9d
decl %edi
addq $-0x4, %r10
decl %eax
decq %r11
cmpl %r8d, %edx
je 0x2a9f0a
jmp 0x2a9ecb
movl %r9d, %eax
movq 0x20(%rsp), %r11
testl %eax, %eax
jle 0x2a9f58
andl $0x0, -0x4(%r13,%rax,4)
decq %rax
jmp 0x2a9f49
cmpl $0x0, 0xf8(%rsp)
je 0x2a9fde
movq 0x58(%rsp), %r12
cmpq %r11, %r12
movq 0x50(%rsp), %rbx
jne 0x2a9f8b
movq %r14, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movl %ebx, %ecx
movl %ebp, %r8d
callq 0x2ab41f
movq 0x20(%rsp), %r11
movq %r12, %rdi
movq %r11, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
movq %r11, %rbx
callq 0x2ab45b
cmpl $0x4, %ebp
jne 0x2aa055
movq 0x40(%rsp), %rdi
movslq (%r14,%rdi,4), %r11
movslq (%rbx,%r11,4), %rax
leaq (,%rax,4), %rax
addq %r13, %rax
movq 0x18(%rsp), %rdx
cmpl $0x1, %edx
movq %rbx, %rsi
jle 0x2aa097
movq 0x38(%rsp), %rcx
movl -0x8(%r14,%rcx,4), %edi
jmp 0x2aa086
cmpl $0x0, 0x100(%rsp)
movq 0x58(%rsp), %r12
je 0x2aa30b
movq 0x70(%rsp), %rax
leaq (,%rax,4), %r15
movq %r15, %rdi
callq 0x2a0350
movq %rax, 0x90(%rsp)
testq %rax, %rax
je 0x2aaebd
movq %r15, %rdi
callq 0x2a0350
movq %rax, 0xa0(%rsp)
testq %rax, %rax
je 0x2aaebd
xorl %eax, %eax
movq 0x20(%rsp), %rsi
movq 0x70(%rsp), %rcx
movq 0xa0(%rsp), %rdx
cmpq %rax, %rcx
je 0x2aa293
movl %ebx, (%rdx,%rax,4)
incq %rax
jmp 0x2aa044
movq 0x40(%rsp), %rdi
movzbl (%r14,%rdi), %r11d
movslq (%rbx,%r11,4), %rax
leaq (,%rax,4), %rax
addq %r13, %rax
movq 0x18(%rsp), %rdx
cmpl $0x1, %edx
movq %rbx, %rsi
jle 0x2aa097
movq 0x38(%rsp), %rcx
movzbl -0x2(%r14,%rcx), %edi
movl %edx, %ecx
negl %ecx
cmpl %r11d, %edi
movq 0x40(%rsp), %rbx
cmovgel %ebx, %ecx
jmp 0x2aa09c
movl %edi, %ecx
movq %rdi, %rbx
movl %ecx, (%rax)
addq $0x4, %rax
xorl %ecx, %ecx
movq 0x38(%rsp), %rdi
cmpq %rcx, %rdi
je 0x2aa17e
movslq (%r13,%rcx,4), %r10
testq %r10, %r10
jle 0x2aa0d4
leal -0x1(%r10), %r8d
cmpl $0x4, %ebp
jne 0x2aa0e9
movl (%r14,%r8,4), %edi
cmpl (%r14,%r10,4), %edi
jge 0x2aa0f8
jmp 0x2aae60
testl %r10d, %r10d
je 0x2aa0e1
notl %r10d
movl %r10d, (%r13,%rcx,4)
movl %r11d, %edi
jmp 0x2aa173
movzbl (%r14,%r8), %edi
cmpb (%r14,%r10), %dil
jb 0x2aae60
movl %edi, %r9d
notl %r9d
movl %r9d, (%r13,%rcx,4)
cmpl %r11d, %edi
jne 0x2aa10d
movl %r11d, %edi
jmp 0x2aa12c
subq %r13, %rax
shrq $0x2, %rax
movslq %r11d, %rdx
movl %eax, (%rsi,%rdx,4)
movslq %edi, %rax
movslq (%rsi,%rax,4), %rax
leaq (,%rax,4), %rax
addq %r13, %rax
movq %rax, %rdx
subq %r13, %rdx
sarq $0x2, %rdx
cmpq %rcx, %rdx
movq 0x18(%rsp), %rdx
jle 0x2aae41
xorl %r9d, %r9d
cmpl $0x1, %r10d
je 0x2aa16c
cmpl $0x4, %ebp
jne 0x2aa159
movl -0x8(%r14,%r10,4), %r9d
jmp 0x2aa15f
movzbl -0x2(%r14,%r10), %r9d
negl %r10d
cmpl %edi, %r9d
cmovgel %r8d, %r10d
movl %r10d, %r9d
movl %r9d, (%rax)
addq $0x4, %rax
incq %rcx
movl %edi, %r11d
jmp 0x2aa0a4
cmpq %rsi, %r12
jne 0x2aa19b
movq %r14, %rdi
movq %r12, %rsi
movq 0x50(%rsp), %rcx
movl %ebp, %r8d
callq 0x2ab41f
movq 0x20(%rsp), %rsi
pushq $0x1
popq %rcx
movq %r12, %rdi
movq 0x50(%rsp), %rdx
callq 0x2ab45b
movq 0x20(%rsp), %r9
movslq (%r9), %rax
leaq (,%rax,4), %rax
addq %r13, %rax
xorl %esi, %esi
pushq $-0x1
popq %r15
testl %ebx, %ebx
js 0x2aabf8
movl %ebx, %r8d
movslq (%r13,%r8,4), %rdx
testq %rdx, %rdx
jle 0x2aa1f0
leal -0x1(%rdx), %edi
cmpl $0x4, %ebp
jne 0x2aa204
movl (%r14,%rdi,4), %ecx
cmpl (%r14,%rdx,4), %ecx
jle 0x2aa213
jmp 0x2aae9e
testl %edx, %edx
je 0x2aa285
notl %edx
movl %edx, (%r13,%r8,4)
jmp 0x2aa288
movzbl (%r14,%rdi), %ecx
cmpb (%r14,%rdx), %cl
ja 0x2aae9e
movl %ecx, (%r13,%r8,4)
cmpl %esi, %ecx
jne 0x2aa220
movl %esi, %ecx
jmp 0x2aa240
subq %r13, %rax
shrq $0x2, %rax
movslq %esi, %rsi
movl %eax, (%r9,%rsi,4)
movslq %ecx, %rax
movslq (%r9,%rax,4), %rax
leaq (,%rax,4), %rax
addq %r13, %rax
movq %rax, %rsi
subq %r13, %rsi
sarq $0x2, %rsi
cmpq %r8, %rsi
jg 0x2aae7f
xorl %esi, %esi
cmpl $0x1, %edx
je 0x2aa27c
cmpl $0x4, %ebp
jne 0x2aa26c
movl -0x8(%r14,%rdx,4), %edx
movl %edi, %esi
cmpl %ecx, %edx
jg 0x2aa278
jmp 0x2aa27c
movzbl -0x2(%r14,%rdx), %edx
movl %edi, %esi
cmpl %edx, %ecx
jge 0x2aa27c
notl %edx
movl %edx, %esi
movl %esi, -0x4(%rax)
addq $-0x4, %rax
jmp 0x2aa28a
movl %ebx, %r15d
movl %esi, %ecx
decl %ebx
movl %ecx, %esi
jmp 0x2aa1c4
cmpq %rsi, %r12
movq 0x50(%rsp), %rbx
jne 0x2aa2b7
movq %r14, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movl %ebx, %ecx
movl %ebp, %r8d
callq 0x2ab41f
movq 0x20(%rsp), %rsi
movq %r12, %rdi
movl %ebx, %edx
xorl %ecx, %ecx
movq %rsi, %rbx
callq 0x2ab45b
movq 0x90(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2a0200
cmpl $0x4, %ebp
jne 0x2aa376
movq 0x40(%rsp), %rsi
movslq (%r14,%rsi,4), %r8
movl (%rbx,%r8,4), %eax
movl %eax, %ebx
cltq
movq 0x48(%rsp), %rdi
andl $0x0, (%rdi,%rax,4)
movq 0x38(%rsp), %rcx
movl -0x8(%r14,%rcx,4), %ecx
jmp 0x2aa39c
cmpq %r11, %r12
movq 0x50(%rsp), %rbx
jne 0x2aa32f
movq %r14, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movl %ebx, %ecx
movl %ebp, %r8d
callq 0x2ab41f
movq 0x20(%rsp), %r11
movq %r12, %rdi
movq %r11, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
movq %r11, %rbx
callq 0x2ab45b
cmpl $0x4, %ebp
jne 0x2aac31
movq 0x40(%rsp), %rdi
movslq (%r14,%rdi,4), %rcx
movl (%rbx,%rcx,4), %eax
movq 0x18(%rsp), %rdx
cmpl $0x1, %edx
movq %rbx, %rsi
jle 0x2aac69
movq 0x38(%rsp), %rdi
movl -0x8(%r14,%rdi,4), %edi
jmp 0x2aac56
movq 0x40(%rsp), %rsi
movzbl (%r14,%rsi), %r8d
movl (%rbx,%r8,4), %eax
movl %eax, %ebx
cltq
movq 0x48(%rsp), %rdi
andl $0x0, (%rdi,%rax,4)
movq 0x38(%rsp), %rcx
movzbl -0x2(%r14,%rcx), %ecx
movq 0x18(%rsp), %rdx
negl %edx
movq %r8, 0xa8(%rsp)
cmpl %r8d, %ecx
cmovgel %esi, %edx
movl %edx, (%r13,%rax,4)
andl $0x0, (%rdi)
movq %r15, %rdi
callq 0x2a0350
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x2aaebd
movl %ebx, %esi
incl %esi
xorl %eax, %eax
xorl %ebx, %ebx
movq 0x70(%rsp), %rdx
cmpq %rax, %rdx
je 0x2aa3fa
movq 0x60(%rsp), %rcx
movl %ebx, (%rcx,%rax,4)
xorl %ecx, %ecx
cmpl $0x0, (%r12,%rax,4)
setg %cl
addl %ecx, %ebx
incq %rax
jmp 0x2aa3dc
movl %esi, 0x68(%rsp)
movl %ebx, %eax
movq %rax, 0x70(%rsp)
leaq (,%rax,4), %rdi
movq %rdi, 0xb0(%rsp)
callq 0x2a0350
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x2aaebd
xorl %eax, %eax
movq 0x70(%rsp), %rcx
movq 0x30(%rsp), %rdx
cmpq %rax, %rcx
je 0x2aa442
orl $-0x1, (%rdx,%rax,4)
incq %rax
jmp 0x2aa434
leal 0x80c(,%rbx,2), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x2a0350
testq %rax, %rax
je 0x2aaebd
movq %rax, %r15
leal 0x808(,%rbx,2), %eax
movl %eax, 0x78(%rsp)
orq $-0x1, (%r15)
movabsq $-0x200000000, %r8      # imm = 0xFFFFFFFE00000000
movabsq $0x200000000, %rsi      # imm = 0x200000000
pushq $0x1
popq %rbx
xorl %r10d, %r10d
movq 0x38(%rsp), %rdi
movl 0x68(%rsp), %r11d
cmpq %rdi, %r10
je 0x2aa81a
movslq (%r13,%r10,4), %rdx
movl %edx, %eax
notl %eax
movl %eax, (%r13,%r10,4)
movq 0x48(%rsp), %rax
movl (%rax,%r10,4), %eax
movslq %ebx, %rcx
testq %rdx, %rdx
movq %r10, 0x98(%rsp)
jle 0x2aa4e6
cmpl $-0x1, %eax
movq 0xa0(%rsp), %rbx
jne 0x2aa587
movq %r10, %r12
movl %r11d, %esi
cmpl $0x4, %ebp
jne 0x2aa533
movl (%r14,%rdx,4), %eax
jmp 0x2aa538
cmpl $-0x1, %eax
je 0x2ab17a
testl %eax, %eax
js 0x2aa70d
movq %rcx, %rdx
shlq $0x20, %rdx
addq %rsi, %rdx
leal 0x4(%rcx), %ebx
leaq (%r15,%rcx,4), %rcx
addq %r8, %rdx
addl $-0x2, %ebx
leaq -0x8(%rcx), %rdi
cmpl (%rcx), %eax
movq %rdi, %rcx
jle 0x2aa508
sarq $0x1e, %rdx
movl %r10d, 0x4(%r15,%rdx)
movslq %ebx, %rcx
movl %eax, (%r15,%rcx,4)
movq 0x38(%rsp), %rdi
jmp 0x2aa70d
movzbl (%r14,%rdx), %eax
movslq %eax, %r11
leaq (%r14,%rdx), %rdi
leaq (%r14,%rdx,4), %r8
xorl %eax, %eax
cmpl $0x4, %ebp
jne 0x2aa55e
movl (%r8,%rax,4), %r9d
movl (%rbx,%r11,4), %r10d
addl %eax, %r10d
movslq %r10d, %r10
movl (%r14,%r10,4), %r10d
jmp 0x2aa572
movzbl (%rdi,%rax), %r9d
movl (%rbx,%r11,4), %r10d
addl %eax, %r10d
movslq %r10d, %r10
movzbl (%r14,%r10), %r10d
incq %rax
cmpl %r10d, %r9d
je 0x2aa545
decl %eax
movl %esi, %r11d
movq %r12, %r10
movq 0x58(%rsp), %r12
leal -0x1(%rdx), %r8d
cmpl $0x4, %ebp
movq 0xa8(%rsp), %rdi
jne 0x2aa5a7
movl (%r14,%r8,4), %r9d
cmpl (%r14,%rdx,4), %r9d
jge 0x2aa5b6
jmp 0x2aafe7
movzbl (%r14,%r8), %r9d
cmpb (%r14,%rdx), %r9b
jb 0x2aafe7
movslq %r9d, %rsi
cmpl %edi, %r9d
je 0x2aa5ef
movslq %edi, %rdi
movq %rcx, 0x68(%rsp)
movq %r12, %rcx
movq %rsi, %r12
movq 0x20(%rsp), %rsi
movl %r11d, (%rsi,%rdi,4)
movl (%rsi,%r12,4), %r11d
movq %r12, %rsi
movq %rcx, %r12
movq 0x68(%rsp), %rcx
movl %r9d, %edi
movq %rdi, 0xa8(%rsp)
movslq %r11d, %rdi
cmpq %rdi, %r10
jge 0x2ab025
movl %r8d, (%rbx,%rsi,4)
xorl %r10d, %r10d
cmpl $0x1, %edx
je 0x2aa625
cmpl $0x4, %ebp
jne 0x2aa613
movl -0x8(%r14,%rdx,4), %r10d
jmp 0x2aa619
movzbl -0x2(%r14,%rdx), %r10d
negl %edx
cmpl %r9d, %r10d
cmovll %edx, %r8d
movl %r8d, %r10d
movl %r11d, 0x68(%rsp)
movl %r10d, (%r13,%rdi,4)
testl %eax, %eax
js 0x2ab006
movq %r12, %r11
leal 0x4(%rcx), %ebx
leaq 0x2(%rcx), %r8
movq %rcx, %rdx
shlq $0x20, %rdx
movabsq $0x200000000, %r9       # imm = 0x200000000
addq %r9, %rdx
leal -0x1(%rcx), %r9d
movabsq $-0x200000000, %r12     # imm = 0xFFFFFFFE00000000
movq %r8, %r10
movl %r9d, %ecx
addl $-0x2, %ebx
addq $-0x2, %r8
addq %r12, %rdx
leal -0x2(%rcx), %r9d
cmpl -0x8(%r15,%r10,4), %eax
jle 0x2aa663
sarq $0x1e, %rdx
movq 0x98(%rsp), %r10
movl %r10d, 0x4(%r15,%rdx)
movslq %ebx, %rdx
movl %eax, (%r15,%rdx,4)
testq %r8, %r8
jle 0x2ab044
movq 0x60(%rsp), %rax
movslq (%rax,%rsi,4), %rax
movq 0x30(%rsp), %rdx
movl (%rdx,%rax,4), %edx
movslq %ecx, %rcx
leaq (%r15,%rcx,4), %rcx
movq %r11, %r12
movq %rcx, %r8
addq $-0x8, %rcx
cmpl (%r8), %edx
jl 0x2aa6ba
xorl %edx, %edx
movq 0x90(%rsp), %r8
movl 0x68(%rsp), %r11d
cmpl (%r8,%rsi,4), %r11d
movabsq $0x200000000, %rsi      # imm = 0x200000000
je 0x2aa6ea
movl 0x14(%rcx), %edx
incl %edx
movq 0x48(%rsp), %rcx
movl %edx, (%rcx,%rdi,4)
movq 0x30(%rsp), %rcx
movl %r10d, (%rcx,%rax,4)
incl %r11d
movq 0x38(%rsp), %rdi
movabsq $-0x200000000, %r8      # imm = 0xFFFFFFFE00000000
cmpl 0x78(%rsp), %ebx
jle 0x2aa812
movl %r11d, 0x68(%rsp)
movq 0xb0(%rsp), %r13
movq %r13, %rdi
callq 0x2a0350
testq %rax, %rax
je 0x2aaebd
movq %rax, %r12
movq %rax, %rdi
movq 0x30(%rsp), %rsi
movq %r13, %rdx
callq 0x2a0200
movq %r12, %rdi
movq 0x70(%rsp), %r13
movq %r13, %rsi
pushq $0x4
popq %rdx
leaq -0x1ce5(%rip), %rcx     # 0x2a8a78
callq 0x2a04b0
movq %r13, %r9
movslq %ebx, %rax
xorl %ecx, %ecx
pushq $0x1
popq %r13
pushq $0x2
popq %rdx
movabsq $0x200000000, %r10      # imm = 0x200000000
cmpq %r9, %rcx
je 0x2aa7d4
movl (%r12,%rcx,4), %edi
movslq %r13d, %rsi
cmpl -0x4(%r15,%rsi,4), %edi
jl 0x2aa7c7
movslq %edx, %rdx
movq %rdx, %r8
shlq $0x20, %r8
cmpq %rax, %rdx
jge 0x2aa7cc
cmpl (%r15,%rdx,4), %edi
jl 0x2aa7ac
addq $0x2, %rdx
addq %r10, %r8
jmp 0x2aa798
sarq $0x1e, %r8
movl (%r15,%r8), %edi
movl %edi, 0x4(%r15,%rsi,4)
movl 0x4(%r15,%r8), %edi
leal 0x2(%rsi), %r13d
movl %edi, 0x8(%r15,%rsi,4)
incq %rcx
jmp 0x2aa77b
cmpl %edx, %ebx
jge 0x2ab0df
movq %r12, %rdi
callq 0x2a02f0
movabsq $0x200000000, %rsi      # imm = 0x200000000
movl %r13d, %ebx
movq 0x80(%rsp), %r13
movq 0x58(%rsp), %r12
movq 0x38(%rsp), %rdi
movabsq $-0x200000000, %r8      # imm = 0xFFFFFFFE00000000
movl 0x68(%rsp), %r11d
movq 0x98(%rsp), %r10
incq %r10
jmp 0x2aa494
movq 0x20(%rsp), %rsi
cmpq %rsi, %r12
movq 0x50(%rsp), %rbx
jne 0x2aa843
movq %r14, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movl %ebx, %ecx
movl %ebp, %r8d
callq 0x2ab41f
movq 0x20(%rsp), %rsi
pushq $0x1
popq %rcx
movq %r12, %rdi
movl %ebx, %edx
callq 0x2ab45b
xorl %eax, %eax
movq 0x40(%rsp), %rbx
movq 0x18(%rsp), %rcx
movq 0x70(%rsp), %rdx
movq 0x30(%rsp), %rsi
cmpq %rax, %rdx
je 0x2aa873
movl %ebx, (%rsi,%rax,4)
incq %rax
jmp 0x2aa866
movl %ecx, (%r15)
orl $-0x1, 0x4(%r15)
movq 0x20(%rsp), %r11
movl (%r11), %eax
movl %eax, 0x68(%rsp)
movq $0x0, 0x38(%rsp)
pushq $0x1
popq %rax
movq %rax, 0x18(%rsp)
movabsq $-0x200000000, %r8      # imm = 0xFFFFFFFE00000000
testl %ebx, %ebx
js 0x2aabbf
movl %ebx, %ecx
movq 0x48(%rsp), %rdi
movl (%rdi,%rcx,4), %eax
setne %dl
testl %eax, %eax
sets %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x2aa934
leal -0x1(%rbx), %edx
cmpl $0x0, (%rdi,%rdx,4)
js 0x2aa934
movl (%r13,%rcx,4), %eax
movl %eax, %esi
sarl $0x1f, %esi
xorl %eax, %esi
movl (%r13,%rdx,4), %eax
movl %eax, %edx
sarl $0x1f, %edx
xorl %eax, %edx
movslq %esi, %rax
movslq %edx, %r8
leaq (%r14,%rax), %rdx
leaq (%r14,%r8), %rsi
leaq (%r14,%rax,4), %rdi
leaq (%r14,%r8,4), %r8
xorl %eax, %eax
cmpl $0x4, %ebp
jne 0x2aa90e
movl (%rdi,%rax,4), %r9d
movl (%r8,%rax,4), %r10d
jmp 0x2aa918
movzbl (%rdx,%rax), %r9d
movzbl (%rsi,%rax), %r10d
incq %rax
cmpl %r10d, %r9d
je 0x2aa8ff
decl %eax
movq 0x48(%rsp), %rdx
movl %eax, (%rdx,%rcx,4)
movabsq $-0x200000000, %r8      # imm = 0xFFFFFFFE00000000
movslq (%r13,%rcx,4), %rdi
testq %rdi, %rdi
jle 0x2aa956
leal -0x1(%rdi), %r8d
cmpl $0x4, %ebp
jne 0x2aa962
movl (%r14,%r8,4), %edx
cmpl (%r14,%rdi,4), %edx
jle 0x2aa971
jmp 0x2ab063
notl %edi
movl %edi, (%r13,%rcx,4)
jmp 0x2aaa5f
movzbl (%r14,%r8), %edx
cmpb (%r14,%rdi), %dl
ja 0x2ab063
movslq %edx, %r9
movq 0x38(%rsp), %r10
cmpl %r10d, %edx
jne 0x2aa987
movl 0x68(%rsp), %esi
movq %r10, %r11
jmp 0x2aa99a
movslq %r10d, %rsi
movl 0x68(%rsp), %r10d
movl %r10d, (%r11,%rsi,4)
movl (%r11,%r9,4), %esi
movl %edx, %r11d
cmpl %ebx, %esi
jg 0x2ab082
testl %r8d, %r8d
je 0x2aa9be
cmpl $0x4, %ebp
jne 0x2aa9b3
movl -0x8(%r14,%rdi,4), %r10d
jmp 0x2aa9b9
movzbl -0x2(%r14,%rdi), %r10d
cmpl %edx, %r10d
jle 0x2aa9c3
negl %edi
movl %edi, %r8d
movslq %esi, %rdi
movl %r8d, -0x4(%r13,%rdi,4)
incl %edx
cmpl 0x50(%rsp), %edx
jge 0x2ab0a1
movq %r11, 0x38(%rsp)
movq 0x18(%rsp), %r11
testl %r11d, %r11d
jle 0x2ab0c0
leal -0x1(%rsi), %r8d
movl %r8d, 0x68(%rsp)
movq 0x60(%rsp), %r8
movslq (%r8,%r9,4), %r8
movq 0x30(%rsp), %r9
movl (%r9,%r8,4), %r10d
leal -0x1(%r11), %r9d
leaq (%r15,%r9,4), %r9
movq %r9, %r11
addq $-0x8, %r9
cmpl (%r11), %r10d
jge 0x2aaa0d
movslq %edx, %r10
xorl %edx, %edx
movq 0x90(%rsp), %r11
cmpl (%r11,%r10,4), %esi
je 0x2aaa32
movl 0x14(%r9), %edx
incl %edx
movq 0x48(%rsp), %r9
movl %edx, (%r9,%rdi,4)
cmpl %ebx, %esi
movq 0x20(%rsp), %r11
jne 0x2aaa4c
movq 0x48(%rsp), %rax
movl (%rax,%rcx,4), %eax
movq 0x30(%rsp), %rcx
movl %ebx, (%rcx,%r8,4)
movabsq $-0x200000000, %r8      # imm = 0xFFFFFFFE00000000
movq %rbx, 0x40(%rsp)
testl %eax, %eax
js 0x2aaf41
movq 0x18(%rsp), %rdi
movslq %edi, %rdx
movq %rdx, %rcx
shlq $0x20, %rcx
movabsq $0x200000000, %rsi      # imm = 0x200000000
addq %rsi, %rcx
addl $0x4, %edi
movl %edi, %ebx
addq %r8, %rcx
addl $-0x2, %ebx
testq %rdx, %rdx
js 0x2aaaa5
leaq -0x2(%rdx), %rsi
cmpl (%r15,%rdx,4), %eax
movq %rsi, %rdx
jle 0x2aaa8d
sarq $0x1e, %rcx
movq 0x40(%rsp), %rdx
movl %edx, 0x4(%r15,%rcx)
movslq %ebx, %r13
movl %eax, (%r15,%r13,4)
cmpl 0x78(%rsp), %r13d
jle 0x2aab79
movq 0xb0(%rsp), %rbp
movq %rbp, %rdi
callq 0x2a0350
testq %rax, %rax
je 0x2aaebd
movq %rax, %r12
movq %rax, %rdi
movq 0x30(%rsp), %rsi
movq %rbp, %rdx
callq 0x2a0200
movq %r12, %rdi
movq 0x70(%rsp), %rbp
movq %rbp, %rsi
pushq $0x4
popq %rdx
leaq -0x208e(%rip), %rcx     # 0x2a8a78
callq 0x2a04b0
movq %rbp, %rcx
pushq $0x1
popq %rax
movl %eax, %r9d
pushq $0x2
popq %rax
movl 0xf0(%rsp), %ebp
movabsq $0x200000000, %r8       # imm = 0x200000000
movl %r9d, %edx
testq %rcx, %rcx
jle 0x2aab8a
movl -0x4(%r12,%rcx,4), %esi
decq %rcx
cmpl -0x4(%r15,%rdx,4), %esi
jge 0x2aab2b
movq %rax, %rdi
shlq $0x20, %rdi
cltq
cmpq %r13, %rax
jge 0x2aab82
cmpl (%r15,%rax,4), %esi
jge 0x2aab5c
addq $0x2, %rax
addq %r8, %rdi
jmp 0x2aab48
sarq $0x1e, %rdi
movl (%r15,%rdi), %esi
movl %esi, 0x4(%r15,%rdx,4)
movl 0x4(%r15,%rdi), %esi
addl $0x2, %r9d
movl %esi, 0x8(%r15,%rdx,4)
jmp 0x2aab28
movl %ebx, %eax
movq %rax, 0x18(%rsp)
jmp 0x2aabab
cmpl %eax, %ebx
jge 0x2ab1d7
movq %r9, 0x18(%rsp)
movq %r12, %rdi
callq 0x2a02f0
movq 0x58(%rsp), %r12
movq 0x20(%rsp), %r11
movabsq $-0x200000000, %r8      # imm = 0xFFFFFFFE00000000
movq 0x40(%rsp), %rbx
decl %ebx
movq 0x80(%rsp), %r13
jmp 0x2aa8a2
movq 0x90(%rsp), %rdi
callq 0x2a02f0
movq 0x30(%rsp), %rdi
callq 0x2a02f0
movq %r15, %rdi
callq 0x2a02f0
movq 0x60(%rsp), %rdi
callq 0x2a02f0
movq 0xa0(%rsp), %rdi
callq 0x2a02f0
xorl %r15d, %r15d
movq 0x28(%rsp), %rax
testb $0x5, %al
je 0x2aac0e
movq %r12, %rdi
callq 0x2a02f0
movq 0x28(%rsp), %rax
testb $0x2, %al
je 0x2aac1c
movq 0x20(%rsp), %rdi
callq 0x2a02f0
movl %r15d, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%rsp), %rdi
movzbl (%r14,%rdi), %ecx
movl (%rbx,%rcx,4), %eax
movq 0x18(%rsp), %rdx
cmpl $0x1, %edx
movq %rbx, %rsi
jle 0x2aac69
movq 0x38(%rsp), %rdi
movzbl -0x2(%r14,%rdi), %edi
movl %edx, %r8d
negl %r8d
cmpl %ecx, %edi
movq 0x40(%rsp), %rbx
cmovgel %ebx, %r8d
jmp 0x2aac6f
movl %edi, %r8d
movq %rdi, %rbx
movslq %eax, %rdi
incl %eax
movl %r8d, (%r13,%rdi,4)
xorl %r10d, %r10d
movq 0x38(%rsp), %rdi
cmpq %r10, %rdi
je 0x2aad24
movslq (%r13,%r10,4), %r9
movl %r9d, %edi
notl %edi
movl %edi, (%r13,%r10,4)
testq %r9, %r9
jle 0x2aad17
leal -0x1(%r9), %edi
cmpl $0x4, %ebp
jne 0x2aacb6
movl (%r14,%rdi,4), %r8d
cmpl (%r14,%r9,4), %r8d
jge 0x2aacc5
jmp 0x2ab11d
movzbl (%r14,%rdi), %r8d
cmpb (%r14,%r9), %r8b
jb 0x2ab11d
cmpl %ecx, %r8d
jne 0x2aaccf
movl %ecx, %r8d
jmp 0x2aacdb
movslq %ecx, %rcx
movl %eax, (%rsi,%rcx,4)
movslq %r8d, %rax
movl (%rsi,%rax,4), %eax
cltq
cmpq %rax, %r10
jge 0x2ab0fe
xorl %ecx, %ecx
cmpl $0x1, %r9d
je 0x2aad0d
cmpl $0x4, %ebp
jne 0x2aacfa
movl -0x8(%r14,%r9,4), %ecx
jmp 0x2aad00
movzbl -0x2(%r14,%r9), %ecx
negl %r9d
cmpl %r8d, %ecx
cmovgel %edi, %r9d
movl %r9d, %ecx
movl %ecx, (%r13,%rax,4)
incl %eax
movl %r8d, %ecx
incq %r10
movq 0x18(%rsp), %rdx
jmp 0x2aac7c
cmpq %rsi, %r12
jne 0x2aad41
movq %r14, %rdi
movq %r12, %rsi
movq 0x50(%rsp), %rcx
movl %ebp, %r8d
callq 0x2ab41f
movq 0x20(%rsp), %rsi
pushq $0x1
popq %rcx
movq %r12, %rdi
movq 0x50(%rsp), %rdx
callq 0x2ab45b
movq 0x20(%rsp), %r8
movl (%r8), %eax
xorl %r15d, %r15d
xorl %esi, %esi
testl %ebx, %ebx
js 0x2aabf8
movl %ebx, %edx
movslq (%r13,%rdx,4), %rcx
testq %rcx, %rcx
jle 0x2aad89
leal -0x1(%rcx), %edx
cmpl $0x4, %ebp
jne 0x2aad92
movl (%r14,%rdx,4), %edi
cmpl (%r14,%rcx,4), %edi
jle 0x2aada1
jmp 0x2ab13c
notl %ecx
movl %ecx, (%r13,%rdx,4)
jmp 0x2aade9
movzbl (%r14,%rdx), %edi
cmpb (%r14,%rcx), %dil
ja 0x2ab13c
cmpl %esi, %edi
jne 0x2aada9
movl %esi, %edi
jmp 0x2aadb7
movslq %esi, %rsi
movl %eax, (%r8,%rsi,4)
movslq %edi, %rax
movl (%r8,%rax,4), %eax
cmpl %ebx, %eax
jg 0x2ab15b
testl %edx, %edx
je 0x2aadd9
cmpl $0x4, %ebp
jne 0x2aadcf
movl -0x8(%r14,%rcx,4), %esi
jmp 0x2aadd5
movzbl -0x2(%r14,%rcx), %esi
cmpl %edi, %esi
jle 0x2aaddd
negl %ecx
movl %ecx, %edx
movslq %eax, %rcx
decl %eax
movl %edx, -0x4(%r13,%rcx,4)
movl %edi, %esi
decl %ebx
jmp 0x2aad5e
testb $0x1, 0x28(%rsp)
je 0x2a9940
movq %r12, %rdi
jmp 0x2a993b
leaq 0x3cafa5(%rip), %rdi    # 0x675daf
leaq 0x3cade7(%rip), %rsi    # 0x675bf8
leaq 0x3caf69(%rip), %rcx    # 0x675d81
movl $0xec, %edx
callq 0x2a0190
leaq 0x3caf86(%rip), %rdi    # 0x675daf
leaq 0x3cadc8(%rip), %rsi    # 0x675bf8
leaq 0x3cafcf(%rip), %rcx    # 0x675e06
movl $0x82, %edx
callq 0x2a0190
leaq 0x3caf09(%rip), %rdi    # 0x675d51
leaq 0x3cada9(%rip), %rsi    # 0x675bf8
leaq 0x3cb0c4(%rip), %rcx    # 0x675f1a
movl $0x210, %edx            # imm = 0x210
callq 0x2a0190
leaq 0x3caed5(%rip), %rdi    # 0x675d3c
leaq 0x3cad8a(%rip), %rsi    # 0x675bf8
leaq 0x3cb0a5(%rip), %rcx    # 0x675f1a
movl $0x20d, %edx            # imm = 0x20D
callq 0x2a0190
leaq 0x3caeed(%rip), %rdi    # 0x675d73
leaq 0x3cad6b(%rip), %rsi    # 0x675bf8
leaq 0x3cb086(%rip), %rcx    # 0x675f1a
movl $0x21f, %edx            # imm = 0x21F
callq 0x2a0190
leaq 0x3caeb9(%rip), %rdi    # 0x675d5e
leaq 0x3cad4c(%rip), %rsi    # 0x675bf8
leaq 0x3cb067(%rip), %rcx    # 0x675f1a
movl $0x21c, %edx            # imm = 0x21C
callq 0x2a0190
pushq $-0x1
popq %rdi
callq 0x2a0300
leaq 0x3cae85(%rip), %rdi    # 0x675d51
leaq 0x3cad25(%rip), %rsi    # 0x675bf8
leaq 0x3cae1b(%rip), %rcx    # 0x675cf5
movl $0xb8, %edx
callq 0x2a0190
leaq 0x3cae51(%rip), %rdi    # 0x675d3c
leaq 0x3cad06(%rip), %rsi    # 0x675bf8
leaq 0x3cadfc(%rip), %rcx    # 0x675cf5
movl $0xb6, %edx
callq 0x2a0190
leaq 0x3cae54(%rip), %rdi    # 0x675d5e
leaq 0x3cace7(%rip), %rsi    # 0x675bf8
leaq 0x3caddd(%rip), %rcx    # 0x675cf5
movl $0xd2, %edx
callq 0x2a0190
leaq 0x3cae4a(%rip), %rdi    # 0x675d73
leaq 0x3cacc8(%rip), %rsi    # 0x675bf8
leaq 0x3cadbe(%rip), %rcx    # 0x675cf5
movl $0xd4, %edx
callq 0x2a0190
leaq 0x3caf40(%rip), %rdi    # 0x675e88
leaq 0x3caca9(%rip), %rsi    # 0x675bf8
leaq 0x3caee5(%rip), %rcx    # 0x675e3b
movl $0x1db, %edx            # imm = 0x1DB
callq 0x2a0190
leaq 0x3cad61(%rip), %rdi    # 0x675cc8
leaq 0x3cac8a(%rip), %rsi    # 0x675bf8
leaq 0x3cacde(%rip), %rcx    # 0x675c53
movl $0x276, %edx            # imm = 0x276
callq 0x2a0190
leaq 0x3cae6f(%rip), %rdi    # 0x675df5
leaq 0x3cac6b(%rip), %rsi    # 0x675bf8
leaq 0x3cae21(%rip), %rcx    # 0x675db5
pushq $0x5d
jmp 0x2aafe1
leaq 0x3cad9d(%rip), %rdi    # 0x675d3c
leaq 0x3cac52(%rip), %rsi    # 0x675bf8
leaq 0x3cae08(%rip), %rcx    # 0x675db5
pushq $0x5b
jmp 0x2aafe1
leaq 0x3cada6(%rip), %rdi    # 0x675d5e
leaq 0x3cac39(%rip), %rsi    # 0x675bf8
leaq 0x3cadef(%rip), %rcx    # 0x675db5
pushq $0x6b
jmp 0x2aafe1
leaq 0x3cae2b(%rip), %rdi    # 0x675dfc
leaq 0x3cac20(%rip), %rsi    # 0x675bf8
leaq 0x3cadd6(%rip), %rcx    # 0x675db5
pushq $0x6d
popq %rdx
callq 0x2a0190
leaq 0x3cad4e(%rip), %rdi    # 0x675d3c
leaq 0x3cac03(%rip), %rsi    # 0x675bf8
leaq 0x3cae3f(%rip), %rcx    # 0x675e3b
movl $0x17a, %edx            # imm = 0x17A
callq 0x2a0190
leaq 0x3cae7b(%rip), %rdi    # 0x675e88
leaq 0x3cabe4(%rip), %rsi    # 0x675bf8
leaq 0x3cae20(%rip), %rcx    # 0x675e3b
movl $0x184, %edx            # imm = 0x184
callq 0x2a0190
leaq 0x3cadc9(%rip), %rdi    # 0x675df5
leaq 0x3cabc5(%rip), %rsi    # 0x675bf8
leaq 0x3cae01(%rip), %rcx    # 0x675e3b
movl $0x17f, %edx            # imm = 0x17F
callq 0x2a0190
leaq 0x3cae46(%rip), %rdi    # 0x675e91
leaq 0x3caba6(%rip), %rsi    # 0x675bf8
leaq 0x3cade2(%rip), %rcx    # 0x675e3b
movl $0x18a, %edx            # imm = 0x18A
callq 0x2a0190
leaq 0x3cacf4(%rip), %rdi    # 0x675d5e
leaq 0x3cab87(%rip), %rsi    # 0x675bf8
leaq 0x3cadc3(%rip), %rcx    # 0x675e3b
movl $0x1c6, %edx            # imm = 0x1C6
callq 0x2a0190
leaq 0x3cae31(%rip), %rdi    # 0x675eba
leaq 0x3cab68(%rip), %rsi    # 0x675bf8
leaq 0x3cada4(%rip), %rcx    # 0x675e3b
movl $0x1ca, %edx            # imm = 0x1CA
callq 0x2a0190
leaq 0x3cae1a(%rip), %rdi    # 0x675ec2
leaq 0x3cab49(%rip), %rsi    # 0x675bf8
leaq 0x3cad85(%rip), %rcx    # 0x675e3b
movl $0x1cc, %edx            # imm = 0x1CC
callq 0x2a0190
leaq 0x3cae02(%rip), %rdi    # 0x675ec9
leaq 0x3cab2a(%rip), %rsi    # 0x675bf8
leaq 0x3cad66(%rip), %rcx    # 0x675e3b
movl $0x1d0, %edx            # imm = 0x1D0
callq 0x2a0190
leaq 0x3cadc6(%rip), %rdi    # 0x675eac
leaq 0x3cab0b(%rip), %rsi    # 0x675bf8
leaq 0x3cad47(%rip), %rcx    # 0x675e3b
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x2a0190
leaq 0x3cacf0(%rip), %rdi    # 0x675df5
leaq 0x3caaec(%rip), %rsi    # 0x675bf8
leaq 0x3cadc7(%rip), %rcx    # 0x675eda
movl $0x118, %edx            # imm = 0x118
callq 0x2a0190
leaq 0x3cac18(%rip), %rdi    # 0x675d3c
leaq 0x3caacd(%rip), %rsi    # 0x675bf8
leaq 0x3cada8(%rip), %rcx    # 0x675eda
movl $0x116, %edx            # imm = 0x116
callq 0x2a0190
leaq 0x3cac1b(%rip), %rdi    # 0x675d5e
leaq 0x3caaae(%rip), %rsi    # 0x675bf8
leaq 0x3cad89(%rip), %rcx    # 0x675eda
movl $0x123, %edx            # imm = 0x123
callq 0x2a0190
leaq 0x3cad58(%rip), %rdi    # 0x675eba
leaq 0x3caa8f(%rip), %rsi    # 0x675bf8
leaq 0x3cad6a(%rip), %rcx    # 0x675eda
movl $0x125, %edx            # imm = 0x125
callq 0x2a0190
leaq 0x3cad21(%rip), %rdi    # 0x675ea2
leaq 0x3caa70(%rip), %rsi    # 0x675bf8
leaq 0x3cacac(%rip), %rcx    # 0x675e3b
movl $0x195, %edx            # imm = 0x195
callq 0x2a0190
leaq 0x3caa3c(%rip), %rdi    # 0x675bdc
leaq 0x3caa51(%rip), %rsi    # 0x675bf8
leaq 0x3caaa5(%rip), %rcx    # 0x675c53
movl $0x236, %edx            # imm = 0x236
callq 0x2a0190
leaq 0x3caadc(%rip), %rdi    # 0x675c9b
leaq 0x3caa32(%rip), %rsi    # 0x675bf8
leaq 0x3caa86(%rip), %rcx    # 0x675c53
movl $0x237, %edx            # imm = 0x237
callq 0x2a0190
leaq 0x3cacce(%rip), %rdi    # 0x675eac
leaq 0x3caa13(%rip), %rsi    # 0x675bf8
leaq 0x3cac4f(%rip), %rcx    # 0x675e3b
movl $0x1ec, %edx            # imm = 0x1EC
callq 0x2a0190
leaq 0x3caad9(%rip), %rdi    # 0x675cd6
leaq 0x3ca9f4(%rip), %rsi    # 0x675bf8
leaq 0x3caa48(%rip), %rcx    # 0x675c53
movl $0x292, %edx            # imm = 0x292
callq 0x2a0190
leaq 0x3caaa0(%rip), %rdi    # 0x675cbc
leaq 0x3ca9d5(%rip), %rsi    # 0x675bf8
leaq 0x3caa29(%rip), %rcx    # 0x675c53
movl $0x272, %edx            # imm = 0x272
callq 0x2a0190
leaq 0x3caab3(%rip), %rdi    # 0x675cee
leaq 0x3ca9b6(%rip), %rsi    # 0x675bf8
leaq 0x3caaac(%rip), %rcx    # 0x675cf5
movl $0xa9, %edx
callq 0x2a0190