// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/extended/rmq.c
// Function: gt_rmq_new
GtRMQ* gt_rmq_new(const GtRMQvaluetype *data, GtUword size)
{
  GtRMQ *rmq;
  GtRMQvaluetype *rp;
  GtUword i, j,
                z = 0,            /* index in array a */
                start,            /* start of current block */
                end,              /* end of current block */
                q,                /* position in catalan triangle */
                p,                /* --------- " ---------------- */
                *gstack,
                gstacksize,
                g, /* first position to the left of i where a[g[i]] < a[i] */
                dist = 1UL; /* always 2^(j-1) */

  rmq = gt_calloc((size_t) 1, sizeof (*rmq));
  rmq->memorycount += sizeof (*rmq);
  rmq->arr_ptr = data;
  rmq->n = size;
  rmq->nb = gt_rmq_block(size-1) + 1;     /* number of blocks */
  rmq->nsb = gt_rmq_superblock(size-1)+1; /* number of superblocks */
  rmq->nmb = gt_rmq_microblock(size-1)+1; /* number of microblocks */

  /* The following is necessary because we've fixed s, s' and s'' according to
      the computer's word size and NOT according to the input size. This may
      cause the (super-)block-size to be too big, or, in other words, the
      array too small. If this code is compiled on a 32-bit computer, this
      happens iff n < 113. For such small instances it isn't advisable anyway
      to use this data structure, because simpler methods are faster and less
      space consuming. */
  if (rmq->nb < GT_RMQ_superblocksize/(GT_MULT2(GT_RMQ_blocksize)))
  {
    rmq->M = NULL;
    rmq->Mprime = NULL;
    rmq->type = NULL;
    rmq->Prec = NULL;
    rmq->naive_impl = true;
    return rmq;
  }
  rmq->naive_impl = false;
  /* Type-calculation for the microblocks and pre-computation of
      in-microblock-queries: */
  rmq->type = rmq_calloc(rmq,(size_t) rmq->nmb, sizeof (*rmq->type));

  /* prec[i]: the jth bit is 1 iff j is 1. pos. to the left of i
      where a[j] < a[i]  */
  gt_assert(GT_RMQ_microblocksize < (GtUword) GT_RMQ_CATALAN_MAX);
  rmq->Prec = rmq_calloc(rmq,(size_t) gt_rmq_catalan[GT_RMQ_microblocksize]
                                                    [GT_RMQ_microblocksize],
                         sizeof (*rmq->Prec));
  for (i = 0; i < gt_rmq_catalan[GT_RMQ_microblocksize][GT_RMQ_microblocksize];
       i++)
  {
    rmq->Prec[i] = rmq_calloc(rmq,(size_t) GT_RMQ_microblocksize,
                              sizeof (**rmq->Prec));
    rmq->Prec[i][0] = 1U; /* init with impossible value */
  }

  rp = rmq_calloc(rmq,(size_t) GT_RMQ_microblocksize+1, sizeof (*rp));
       /* rp: rightmost path in Cartesian tree */
  rp[0] = 0; /* originally LONG_MIN, but for GtUword 0 suffices */
  gstack = rmq_calloc(rmq,(size_t) GT_RMQ_microblocksize, sizeof (*gstack));

  for (i = 0; i < rmq->nmb; i++)
  {          /* step through microblocks */
    start = z;                              /* init start */
    end = start + GT_RMQ_microblocksize;    /* end of block (not inclusive) */
    if (end > size) end = size;       /* last block could be smaller than s */

    /* compute block type as in Fischer/Heun CPM'06: */
    q = GT_RMQ_microblocksize;          /* init q */
    p = GT_RMQ_microblocksize - 1;      /* init p */
    rmq->type[i] = 0;                 /* init type (will be increased!) */
    rp[1] = rmq->arr_ptr[z];          /* init rightmost path */
    while (++z < end)
    {   /* step through current block: */
      p--;
      while (rp[q-p-1] > rmq->arr_ptr[z])
      {
        rmq->type[i] += gt_rmq_catalan[p][q]; /* update type */
        q--;
      }
      gt_assert(q > p);
      rp[q-p] = rmq->arr_ptr[z]; /* add last element to rightmost path */
    }

    /* precompute in-block-queries for this microblock (if necessary) */
    /* as in Alstrup et al. SPAA'02: */
    if (rmq->Prec[rmq->type[i]][0] == 1U)
     {
      rmq->Prec[rmq->type[i]][0] = 0U;
      gstacksize = 0;
      for (j = start; j < end; j++)
      {
        while (gstacksize > 0U &&
               rmq->arr_ptr[j] < rmq->arr_ptr[gstack[gstacksize-1]]) {
          gstacksize--;
        }
        if (gstacksize > 0U)
        {
          g = gstack[gstacksize-1];
          rmq->Prec[rmq->type[i]][j-start]
            = rmq->Prec[rmq->type[i]][g-start] |
              (unsigned char) (1 << (g % GT_RMQ_microblocksize));
        } else
        {
          rmq->Prec[rmq->type[i]][j-start] = 0;
        }
        gstack[gstacksize++] = j;
      }
    }
  }
  gt_free(rp);
  gt_free(gstack);

  /* space for out-of-block- and out-of-superblock-queries: */
  rmq->M_depth = (GtUword) floor(GT_LOG2(((double) GT_RMQ_superblocksize
                                               / (double) GT_RMQ_blocksize)));
  rmq->M = rmq_calloc(rmq,(size_t) rmq->M_depth, sizeof (*rmq->M));
  rmq->M[0] = rmq_calloc(rmq,(size_t) rmq->nb, sizeof (**rmq->M));
  rmq->Mprime_depth = (GtUword) floor(GT_LOG2((double) rmq->nsb)) + 1;
  rmq->Mprime = rmq_calloc(rmq,(size_t) rmq->Mprime_depth,
                           sizeof (*rmq->Mprime));
  rmq->Mprime[0] = rmq_calloc(rmq,(size_t) rmq->nsb, sizeof (**rmq->Mprime));

  /* fill 0'th rows of M and Mprime: */
  z = 0; /* minimum in current block */
  q = 0; /* pos. of min in current superblock */
  g = 0; /* number of current superblock */
  for (i = 0; i < rmq->nb; i++)
  { /* step through blocks */
    start = z;              /* init start */
    p = start;              /* init minimum */
    end = start + GT_RMQ_blocksize;   /* end of block (not inclusive!) */
    if (end > size)
      end = size;   /* last block could be smaller than blocksize! */
    if (rmq->arr_ptr[z] < rmq->arr_ptr[q])
      q = z; /* update minimum in superblock */

    while (++z < end)
    { /* step through current block: */
      if (rmq->arr_ptr[z] < rmq->arr_ptr[p])
        p = z; /* update minimum in block */
      if (rmq->arr_ptr[z] < rmq->arr_ptr[q])
        q = z; /* update minimum in superblock */
    }
    rmq->M[0][i] = (unsigned char) (p-start); /* store index of block-minimum
                                                  (offset!) */
    if (z % GT_RMQ_superblocksize == 0 || z == size)
    {  /* end of superblock? */
      rmq->Mprime[0][g++] = q;       /* store index of superblock-minimum */
      q = z;
    }
  }

  /* fill M: */
  for (j = 1UL; j < rmq->M_depth; j++)
  {
    rmq->M[j] = rmq_calloc(rmq,(size_t) rmq->nb, sizeof (**rmq->M));
    for (i = 0; i < rmq->nb - dist; i++)
    { /* be careful: loop may go too far */
      rmq->M[j][i] = rmq->arr_ptr[gt_rmq_trueindex(rmq, j-1, i)] <=
                     rmq->arr_ptr[gt_rmq_trueindex(rmq, j-1,i+dist)]
                       ? rmq->M[j-1][i]
                       : (unsigned char) (rmq->M[j-1][i+dist] +
                                          GT_RMQ_MUL_blocksize(dist)); /* add
                                                                  'skipped'
                                                                  elements
                                                                  in a */
    }
    for (i = rmq->nb - dist; i < rmq->nb; i++)
    {
      rmq->M[j][i] = rmq->M[j-1][i]; /* fill overhang */
    }
    dist *= 2;
  }

  /* fill M': */
  dist = 1UL; /* always 2^(j-1) */
  for (j = 1UL; j < rmq->Mprime_depth; j++)
  {
    rmq->Mprime[j] = rmq_calloc(rmq,(size_t) rmq->nsb, sizeof (**rmq->Mprime));
    for (i = 0; i < rmq->nsb - dist; i++)
    {
      rmq->Mprime[j][i] =
         (rmq->arr_ptr[rmq->Mprime[j-1][i]] <=
          rmq->arr_ptr[rmq->Mprime[j-1][i+dist]]) ? rmq->Mprime[j-1][i]
                                                  : rmq->Mprime[j-1][i+dist];
    }
    for (i = rmq->nsb - dist; i < rmq->nsb; i++)
    {
      rmq->Mprime[j][i] = rmq->Mprime[j-1][i]; /* overhang */
    }
    dist *= 2;
  }
  return rmq;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq $0x0, 0x88(%rsp)
movq $0x1, 0x48(%rsp)
movl $0x1, %edi
movl $0x68, %esi
leaq 0x396aa6(%rip), %rdx    # 0x562dd3
movl $0x178, %ecx            # imm = 0x178
callq 0xe83c0
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq 0x58(%rax), %rcx
addq $0x68, %rcx
movq %rcx, 0x58(%rax)
movq 0xb8(%rsp), %rcx
movq 0xa8(%rsp), %rax
movq %rcx, (%rax)
movq 0xb0(%rsp), %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0xb0(%rsp), %rdi
subq $0x1, %rdi
callq 0x1cd230
movq %rax, %rcx
addq $0x1, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0xb0(%rsp), %rdi
subq $0x1, %rdi
callq 0x1cd240
movq %rax, %rcx
addq $0x1, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0xb0(%rsp), %rdi
subq $0x1, %rdi
callq 0x1cd250
movq %rax, %rcx
addq $0x1, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0xa8(%rsp), %rax
cmpq $0x8, 0x40(%rax)
jae 0x1cc456
movq 0xa8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0xa8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0xa8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0xa8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0xa8(%rsp), %rax
movb $0x1, 0x60(%rax)
movq 0xa8(%rsp), %rax
movq %rax, 0xc0(%rsp)
jmp 0x1cd219
movq 0xa8(%rsp), %rax
movb $0x0, 0x60(%rax)
movq 0xa8(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0x50(%rax), %rsi
movl $0x2, %edx
callq 0x1cd260
movq %rax, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x1cc491
movq 0xa8(%rsp), %rdi
movq 0x396e60(%rip), %rsi    # 0x563300
movl $0x8, %edx
callq 0x1cd260
movq %rax, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq $0x0, 0x98(%rsp)
movq 0x98(%rsp), %rax
cmpq 0x396e2c(%rip), %rax    # 0x563300
jae 0x1cc539
movq 0xa8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x1cd260
movq %rax, %rdx
movq 0xa8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x98(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0xa8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x98(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movb $0x1, (%rax)
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x1cc4c5
movq 0xa8(%rsp), %rdi
movl $0x9, %esi
movl $0x4, %edx
callq 0x1cd260
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movl $0x0, (%rax)
movq 0xa8(%rsp), %rdi
movl $0x8, %edx
movq %rdx, %rsi
callq 0x1cd260
movq %rax, 0x60(%rsp)
movq $0x0, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq 0xa8(%rsp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x1cc989
movq 0x88(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpq 0xb0(%rsp), %rax
jbe 0x1cc5e3
movq 0xb0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq $0x8, 0x70(%rsp)
movq $0x7, 0x68(%rsp)
movq 0xa8(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x98(%rsp), %rcx
movw $0x0, (%rax,%rcx,2)
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq 0x88(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq 0xa0(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
cmpq 0x78(%rsp), %rax
jae 0x1cc751
movq 0x68(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x68(%rsp)
movq 0xa0(%rsp), %rax
movq 0x70(%rsp), %rcx
subq 0x68(%rsp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
movq 0xa8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x88(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jbe 0x1cc6d9
leaq 0x3967eb(%rip), %rax    # 0x562e80
imulq $0x88, 0x68(%rsp), %rcx
addq %rcx, %rax
movq 0x70(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0xa8(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x98(%rsp), %rcx
movzwl (%rax,%rcx,2), %edx
addq %rsi, %rdx
movw %dx, (%rax,%rcx,2)
movq 0x70(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x1cc65d
jmp 0x1cc6db
movq 0x70(%rsp), %rax
cmpq 0x68(%rsp), %rax
ja 0x1cc71f
movq 0x46f8b2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x34991b(%rip), %rsi    # 0x516013
leaq 0x3966e7(%rip), %rdx    # 0x562de6
leaq 0x3966e6(%rip), %rcx    # 0x562dec
leaq 0x3966c6(%rip), %r8     # 0x562dd3
movl $0x1bb, %r9d            # imm = 0x1BB
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x1cc721
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq 0x88(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0xa0(%rsp), %rax
movq 0x70(%rsp), %rcx
subq 0x68(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1cc630
movq 0xa8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0xa8(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x98(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movq (%rax,%rcx,8), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x1cc96e
movq 0xa8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0xa8(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x98(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movq (%rax,%rcx,8), %rax
movb $0x0, (%rax)
movq $0x0, 0x58(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
cmpq 0x78(%rsp), %rax
jae 0x1cc96c
jmp 0x1cc7de
xorl %eax, %eax
cmpq $0x0, 0x58(%rsp)
movb %al, 0x47(%rsp)
jbe 0x1cc829
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq 0x90(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0xa8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rsi
subq $0x1, %rsi
movq (%rdx,%rsi,8), %rdx
cmpl (%rcx,%rdx,4), %eax
setb %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0x1cc833
jmp 0x1cc843
movq 0x58(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x1cc7de
cmpq $0x0, 0x58(%rsp)
jbe 0x1cc8f5
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x50(%rsp)
movq 0xa8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0xa8(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x98(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movq (%rax,%rcx,8), %rax
movq 0x50(%rsp), %rcx
subq 0x80(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq 0x50(%rsp), %rcx
andq $0x7, %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movzbl %cl, %ecx
orl %ecx, %eax
movb %al, %dl
movq 0xa8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0xa8(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x98(%rsp), %rsi
movzwl (%rcx,%rsi,2), %ecx
movq (%rax,%rcx,8), %rax
movq 0x90(%rsp), %rcx
subq 0x80(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1cc931
movq 0xa8(%rsp), %rax
movq 0x38(%rax), %rax
movq 0xa8(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x98(%rsp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movq (%rax,%rcx,8), %rax
movq 0x90(%rsp), %rcx
subq 0x80(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x90(%rsp), %rdx
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x58(%rsp)
movq %rdx, (%rax,%rcx,8)
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
jmp 0x1cc7c9
jmp 0x1cc96e
jmp 0x1cc970
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x1cc58c
movq 0xa0(%rsp), %rdi
leaq 0x39643b(%rip), %rsi    # 0x562dd3
movq %rsi, 0x28(%rsp)
movl $0x1d9, %edx            # imm = 0x1D9
callq 0xe88c0
movq 0x28(%rsp), %rsi
movq 0x60(%rsp), %rdi
movl $0x1da, %edx            # imm = 0x1DA
callq 0xe88c0
movsd 0x3963bd(%rip), %xmm0   # 0x562d80
callq 0x195c0
movsd 0x387b28(%rip), %xmm1   # 0x5544f8
movsd %xmm1, 0x30(%rsp)
divsd %xmm1, %xmm0
callq 0x19c60
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
movsd 0x34c37a(%rip), %xmm1   # 0x518d70
movsd %xmm1, 0x38(%rsp)
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rax, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0xa8(%rsp), %rdi
movq 0x18(%rdi), %rsi
movl $0x8, %edx
callq 0x1cd260
movq %rax, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0xa8(%rsp), %rdi
movq 0x40(%rdi), %rsi
movl $0x1, %edx
callq 0x1cd260
movq %rax, %rcx
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq 0xa8(%rsp), %rax
movq 0x48(%rax), %xmm0
movaps 0x34beb8(%rip), %xmm1   # 0x518930
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x34bebc(%rip), %xmm1   # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x195c0
movsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm0
callq 0x19c60
movsd 0x38(%rsp), %xmm1
movaps %xmm0, %xmm2
cvttsd2si %xmm2, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rax, %rcx
addq $0x1, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0xa8(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0x28(%rax), %rsi
movl $0x8, %edx
callq 0x1cd260
movq %rax, %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0xa8(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0x48(%rax), %rsi
movl $0x8, %edx
callq 0x1cd260
movq %rax, %rcx
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq $0x0, 0x88(%rsp)
movq $0x0, 0x70(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq 0xa8(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x1ccd30
movq 0x88(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
cmpq 0xb0(%rsp), %rax
jbe 0x1ccbc6
movq 0xb0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq 0x88(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0xa8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x70(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jae 0x1ccbfe
movq 0x88(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x1ccc00
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
cmpq 0x78(%rsp), %rax
jae 0x1ccc90
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq 0x88(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0xa8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x68(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jae 0x1ccc53
movq 0x88(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq 0x88(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0xa8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x70(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jae 0x1ccc8b
movq 0x88(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x1ccc00
movq 0x68(%rsp), %rax
subq 0x80(%rsp), %rax
movb %al, %dl
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x98(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x88(%rsp), %rax
andq $0xff, %rax
cmpq $0x0, %rax
je 0x1cccdf
movq 0x88(%rsp), %rax
cmpq 0xb0(%rsp), %rax
jne 0x1ccd15
movq 0x70(%rsp), %rdx
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0x50(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x50(%rsp)
movq %rdx, (%rax,%rcx,8)
movq 0x88(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x1ccd17
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x1ccb62
movq $0x1, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq 0xa8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x1ccfa9
movq 0xa8(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0x40(%rax), %rsi
movl $0x1, %edx
callq 0x1cd260
movq %rax, %rdx
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x90(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq $0x0, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq 0xa8(%rsp), %rcx
movq 0x40(%rcx), %rcx
subq 0x48(%rsp), %rcx
cmpq %rcx, %rax
jae 0x1ccef4
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x90(%rsp), %rsi
subq $0x1, %rsi
movq 0x98(%rsp), %rdx
callq 0x1cd2f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl (%rax,%rcx,4), %eax
movl %eax, 0x24(%rsp)
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x90(%rsp), %rsi
subq $0x1, %rsi
movq 0x98(%rsp), %rdx
addq 0x48(%rsp), %rdx
callq 0x1cd2f0
movq 0x18(%rsp), %rcx
movq %rax, %rdx
movl 0x24(%rsp), %eax
cmpl (%rcx,%rdx,4), %eax
ja 0x1cce72
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x90(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
jmp 0x1cceb2
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x90(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rsp), %rcx
addq 0x48(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq 0x48(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movb %al, %dl
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x90(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x1ccd9b
movq 0xa8(%rsp), %rax
movq 0x40(%rax), %rax
subq 0x48(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq 0xa8(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x1ccf83
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x90(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x90(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x1ccf0d
movq 0x48(%rsp), %rax
shlq %rax
movq %rax, 0x48(%rsp)
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
jmp 0x1ccd3c
movq $0x1, 0x48(%rsp)
movq $0x1, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq 0xa8(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x1cd209
movq 0xa8(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq 0x48(%rax), %rsi
movl $0x8, %edx
callq 0x1cd260
movq %rax, %rdx
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x90(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq $0x0, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq 0xa8(%rsp), %rcx
movq 0x48(%rcx), %rcx
subq 0x48(%rsp), %rcx
cmpq %rcx, %rax
jae 0x1cd152
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq 0xa8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq 0x90(%rsp), %rdx
subq $0x1, %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x98(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movl (%rax,%rcx,4), %eax
movq 0xa8(%rsp), %rcx
movq (%rcx), %rcx
movq 0xa8(%rsp), %rdx
movq 0x20(%rdx), %rdx
movq 0x90(%rsp), %rsi
subq $0x1, %rsi
movq (%rdx,%rsi,8), %rdx
movq 0x98(%rsp), %rsi
addq 0x48(%rsp), %rsi
movq (%rdx,%rsi,8), %rdx
cmpl (%rcx,%rdx,4), %eax
ja 0x1cd0e0
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x90(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x1cd111
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x90(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rsp), %rcx
addq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq (%rsp), %rdx
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x90(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x1cd01d
movq 0xa8(%rsp), %rax
movq 0x48(%rax), %rax
subq 0x48(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq 0xa8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x1cd1e3
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x90(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x90(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x98(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x1cd16b
movq 0x48(%rsp), %rax
shlq %rax
movq %rax, 0x48(%rsp)
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
jmp 0x1ccfbe
movq 0xa8(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
addq $0xc8, %rsp
retq
nopl (%rax)