// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: gt_newGenBlockEncIdxSeq
EISeq *
gt_newGenBlockEncIdxSeq(GtUword totalLen, const char *projectName,
                        MRAEnc *alphabet, const struct seqStats *stats,
                        SeqDataReader BWTGenerator,
                        const struct seqBaseParam *params,
                        size_t numExtHeaders, const uint16_t *headerIDs,
                        const uint32_t *extHeaderSizes,
                        headerWriteFunc *extHeaderCallbacks,
                        void **headerCBData,
                        bitInsertFunc biFunc, BitOffset cwExtBitsPerPos,
                        varExtBitsEstimator biVarBits, void *cbState,
                        GtError *err)
{
  struct blockCompositionSeq *newSeqIdx = NULL;
  AlphabetRangeSize blockMapAlphabetSize, totalAlphabetSize;
  size_t regionsEstimate=totalLen / 100;
  MRAEnc *blockMapAlphabet = NULL, *rangeMapAlphabet = NULL;
  BitOffset bitsPerComposition, bitsPerPermutation;
  unsigned compositionIdxBits, callBackDataOffsetBits,
    blockSize = params->encParams.blockEnc.blockSize,
    bucketBlocks = params->encParams.blockEnc.bucketBlocks;
  size_t bucketLen = (size_t)bucketBlocks * blockSize;
  int *modesCopy = NULL;
  struct varBitsEstimate biMaxExtSize;
  enum rangeStoreMode modes[] = { BLOCK_COMPOSITION_INCLUDE,
                                  REGIONS_LIST };
  gt_assert(projectName);
  gt_assert(params->encType == BWT_ON_BLOCK_ENC);
  gt_assert(blockSize > 0);
  gt_assert((biFunc && biVarBits) || (biFunc == NULL && biVarBits == NULL));
  gt_error_check(err);

  newSeqIdx = gt_calloc(sizeof (struct blockCompositionSeq), 1);
  newSeqIdx->bucketBlocks = bucketBlocks;
  newSeqIdx->bitsPerUlong = requiredUlongBits((newSeqIdx->baseClass.seqLen
                                                 = totalLen) - 1);
  newSeqIdx->baseClass.alphabet = alphabet;
  {
    size_t range, numAlphabetRanges = newSeqIdx->numModes =
      MRAEncGetNumRanges(alphabet);
    totalAlphabetSize = gt_MRAEncGetSize(alphabet);
    blockMapAlphabetSize = 0;
    newSeqIdx->modes = modesCopy = gt_malloc(sizeof (int) * numAlphabetRanges);
    for (range = 0; range < numAlphabetRanges; ++range)
    {
      modesCopy[range] = modes[range];
      switch (modes[range])
      {
      case BLOCK_COMPOSITION_INCLUDE:
        blockMapAlphabetSize += MRAEncGetRangeSize(alphabet, range);
        break;
      case DIRECT_SYM_ENCODE:
        /*< OUTLOOK: insert proper code to process ranges
         * to improve orthogonality */
        break;
      case REGIONS_LIST:
        /*< OUTLOOK: insert proper code to process ranges
         * to improve orthogonality */
        break;
      default:
        gt_log_log("Invalid encoding request.\n");
        newBlockEncIdxSeqErrRet();
        break;
      }
    }
    newSeqIdx->blockMapAlphabetSize = blockMapAlphabetSize;
    newSeqIdx->blockMapAlphabet = blockMapAlphabet =
      gt_MRAEncSecondaryMapping(alphabet, BLOCK_COMPOSITION_INCLUDE, modesCopy,
                             newSeqIdx->blockEncFallback = 0);
    newSeqIdx->rangeMapAlphabet = rangeMapAlphabet =
      gt_MRAEncSecondaryMapping(alphabet, REGIONS_LIST, modesCopy,
                             newSeqIdx->rangeEncFallback = 0);
    gt_assert(gt_MRAEncGetSize(blockMapAlphabet) == blockMapAlphabetSize);
    gt_assert(gt_MRAEncGetSize(rangeMapAlphabet)
           == totalAlphabetSize - blockMapAlphabetSize);
  }
  newSeqIdx->partialSymSumBits
    = gt_malloc(sizeof (newSeqIdx->partialSymSumBits[0])
                * blockMapAlphabetSize * 2);
  newSeqIdx->partialSymSumBitsSums
    = newSeqIdx->partialSymSumBits + blockMapAlphabetSize;
  if (stats)
  {
    GtUword *symCounts;
    symCounts = gt_malloc(sizeof (symCounts[0]) * blockMapAlphabetSize);
    switch (stats->sourceAlphaType)
    {
    case sourceUInt8:
      memset(symCounts, 0,
             sizeof (symCounts[0]) * blockMapAlphabetSize);
      {
        Symbol eSym, bSym;
        unsigned i;
        for (i = 0; i <= UINT8_MAX; ++i)
          if (gt_MRAEncSymbolIsInSelectedRanges(
                alphabet, eSym = MRAEncMapSymbol(alphabet, i),
                BLOCK_COMPOSITION_INCLUDE, modesCopy)
              && ((bSym = MRAEncMapSymbol(blockMapAlphabet, eSym))
                  < blockMapAlphabetSize))
            symCounts[bSym]
              += stats->symbolDistributionTable[i];
#ifdef EIS_DEBUG
        for (i = 0; i < blockMapAlphabetSize; ++i)
        {
          gt_log_log("symCount[%"PRIuSymbol"]="GT_WU"\n", (Symbol) i,
                  stats->symbolDistributionTable[i]);
        }
#endif /* EIS_DEBUG */
        if (blockMapAlphabetSize)
        {
          newSeqIdx->partialSymSumBitsSums[0] = 0;
          newSeqIdx->partialSymSumBits[0] = requiredUlongBits(symCounts[0]);
          for (i = 1; i < blockMapAlphabetSize; ++i)
          {
            newSeqIdx->partialSymSumBitsSums[i]
              = newSeqIdx->partialSymSumBitsSums[i - 1]
              + newSeqIdx->partialSymSumBits[i - 1];
            newSeqIdx->partialSymSumBits[i]
              = requiredUlongBits(symCounts[i]);
          }
#ifdef EIS_DEBUG
          for (i = 0; i < blockMapAlphabetSize; ++i)
          {
            gt_log_log("bitsPerSymSum[%"PRIuSymbol"]=%u\n", (Symbol)i,
                    newSeqIdx->partialSymSumBits[i]);
          }
#endif  /* EIS_DEBUG */
          newSeqIdx->symSumBits
            = newSeqIdx->partialSymSumBitsSums[blockMapAlphabetSize - 1]
            + newSeqIdx->partialSymSumBits[blockMapAlphabetSize - 1];
#ifdef EIS_DEBUG
          gt_log_log("symSumBits total: %u\n", newSeqIdx->symSumBits);
#endif  /* EIS_DEBUG */
        }
      }
      /* count special characters to estimate number of regions required */
      {
        Symbol eSym, rSym;
        GtUword regionSymCount = 0;
        AlphabetRangeSize rangeMapAlphabetSize
          = gt_MRAEncGetSize(rangeMapAlphabet);
        unsigned i;
        for (i = 0; i <= UINT8_MAX; ++i)
          if (gt_MRAEncSymbolIsInSelectedRanges(
               alphabet, eSym = MRAEncMapSymbol(alphabet, i),
               REGIONS_LIST, modesCopy)
             && ((rSym = MRAEncMapSymbol(rangeMapAlphabet, eSym))
                 < rangeMapAlphabetSize))
            regionSymCount += stats->symbolDistributionTable[i];
        regionsEstimate = regionSymCount/20;
#ifdef EIS_DEBUG
        gt_log_log("Expected "GT_WU" symbols to encode in regions.\n",
                    regionSymCount);
#endif
      }
      break;
    default:
      symSumBitsDefaultSetup(newSeqIdx);
    }
    gt_free(symCounts);
  }
  else
  {
    symSumBitsDefaultSetup(newSeqIdx);
  }
  {
    int regionFeatures = SRL_NO_FEATURES;
    if (params->EISFeatureSet & EIS_FEATURE_REGION_SUMS)
      regionFeatures |= SRL_PARTIAL_SYMBOL_SUMS;
    newSeqIdx->rangeEncs = gt_newSeqRangeList(regionsEstimate, rangeMapAlphabet,
                                           regionFeatures);
  }
  newSeqIdx->baseClass.classInfo = &blockCompositionSeqClass;
  if (!gt_initCompositionList(&newSeqIdx->compositionTable, blockSize,
                           blockMapAlphabetSize))
  {
    gt_error_set(err, "Insufficient memory for selected block size %u and "
              "alphabet size %u, try smaller block size?\n", blockSize,
              blockMapAlphabetSize);
    newBlockEncIdxSeqErrRet();
  }
  bitsPerComposition = newSeqIdx->compositionTable.bitsPerCount
    * blockMapAlphabetSize;
  compositionIdxBits = newSeqIdx->compositionTable.compositionIdxBits;
  bitsPerPermutation = newSeqIdx->compositionTable.bitsPerSymbol * blockSize;
  newSeqIdx->blockSize = blockSize;
  newSeqIdx->cwExtBitsPerBucket = cwExtBitsPerPos * bucketLen;
  newSeqIdx->callBackDataOffsetBits = callBackDataOffsetBits
    = biFunc ? gt_requiredUInt64Bits(newSeqIdx->compositionTable.maxPermIdxBits
                                  * bucketBlocks) : 0;
  {
    BitOffset maxVarBitsTotal =
      vwBits(totalLen, blockSize, bucketBlocks,
             newSeqIdx->compositionTable.maxPermIdxBits,
             biVarBits, cbState, &biMaxExtSize);
    newSeqIdx->bitsPerVarDiskOffset = gt_requiredUInt64Bits(maxVarBitsTotal);
  }
  newSeqIdx->maxVarExtBitsPerBucket = biMaxExtSize.maxBitsPerBucket;
  {
    size_t headerLen = blockEncIdxSeqHeaderLength(newSeqIdx, numExtHeaders,
                                                  extHeaderSizes);
    if (!openOnDiskData(projectName, &newSeqIdx->externalData, "wb+",err))
      newBlockEncIdxSeqErrRet();
    initOnDiskBlockCompIdx(&newSeqIdx->externalData,
                           headerLen, cwSize(newSeqIdx));
  }
  /* At this point everything should be ready to receive the actual sequence
   * information, steps: */
  {
    int hadGtError = 0;
    do
    {
      {
        Symbol *block;
        unsigned *compositionPreAlloc;
        BitString permCompBSPreAlloc;
        partialSymSum *buck, *buckLast;
        block = gt_malloc(sizeof (Symbol) * blockSize);
        compositionPreAlloc = gt_malloc(sizeof (compositionPreAlloc[0])
                                        * blockMapAlphabetSize);
        permCompBSPreAlloc =
          gt_malloc(bitElemsAllocSize(bitsPerComposition + bitsPerPermutation)
                    * sizeof (BitElem));
        buck = newPartialSymSums(totalAlphabetSize);
        buckLast = newPartialSymSums(totalAlphabetSize);
        /* 2. read block sized chunks from bwttab and suffix array */
        {
          GtUword numFullBlocks = totalLen / blockSize, blockNum,
            lastUpdatePos = 0;
          /* pos == totalLen - symbolsLeft */
          struct appendState aState;
          initAppendState(&aState, newSeqIdx);
          blockNum = 0;
          while (blockNum < numFullBlocks)
          {
            size_t readResult;
            /* 3. for each chunk: */
            readResult = SDRRead(BWTGenerator, block, blockSize);
            if (readResult != blockSize)
            {
              hadGtError = 1;
              perror("error condition while reading index data");
              break;
            }
            gt_MRAEncSymbolsTransform(alphabet, block, blockSize);
            addBlock2OutputBuffer(newSeqIdx, buck, blockNum,
                                  block, blockSize,
                                  alphabet, modesCopy,
                                  blockMapAlphabet, blockMapAlphabetSize,
                                  permCompBSPreAlloc, compositionPreAlloc,
                                  compositionIdxBits, &aState);
            /* update on-disk structure */
            if (!((++blockNum) % bucketBlocks))
            {
              GtUword pos = blockNum * blockSize;
              if (writeOutputBuffer(newSeqIdx, &aState, biFunc, lastUpdatePos,
                                    bucketLen, callBackDataOffsetBits, cbState,
                                    buckLast) < 0)
              {
                hadGtError = 1;
                break;
              }
              /* update retained data */
              copyPartialSymSums(totalAlphabetSize, buckLast, buck);
              lastUpdatePos = pos;
            }
          }
          /* handle last chunk */
          if (!hadGtError)
          {
            GtUword symbolsLeft = totalLen % blockSize;
            if (symbolsLeft)
            {
              size_t readResult;
              readResult = SDRRead(BWTGenerator, block, symbolsLeft);
              if (readResult < symbolsLeft)
              {
                hadGtError = 1;
                perror("error condition while reading index data");
                newBlockEncIdxSeqLoopErr();
              }
              else
              {
                gt_MRAEncSymbolsTransform(alphabet, block, symbolsLeft);
                memset(block + symbolsLeft, 0,
                       sizeof (Symbol) * (blockSize - symbolsLeft));
                addBlock2OutputBuffer(newSeqIdx, buck, blockNum,
                                      block, blockSize,
                                      alphabet, modesCopy,
                                      blockMapAlphabet, blockMapAlphabetSize,
                                      permCompBSPreAlloc, compositionPreAlloc,
                                      compositionIdxBits, &aState);
              }
            }
            if (lastUpdatePos <= totalLen)
            {
              /* one bucket still unfinished */
              if (writeOutputBuffer(newSeqIdx, &aState, biFunc, lastUpdatePos,
                                    totalLen - lastUpdatePos,
                                    callBackDataOffsetBits, cbState,
                                    buckLast) < 0)
              {
                hadGtError = 1;
                break;
              }
            }
            if (!finalizeIdxOutput(newSeqIdx, &aState))
            {
              hadGtError = 1;
              perror("error condition while writing block-compressed"
                     " index data");
              newBlockEncIdxSeqLoopErr();
            }
            if (!writeIdxHeader(newSeqIdx, numExtHeaders, headerIDs,
                                extHeaderSizes, extHeaderCallbacks,
                                headerCBData, err))
            {
              hadGtError = 1;
              perror("error condition while writing block-compressed"
                     " index header");
              newBlockEncIdxSeqLoopErr();
            }
            if (fflush(newSeqIdx->externalData.idxFP))
            {
              hadGtError = 1;
              perror("error condition while writing block-compressed"
                     " index header");
              newBlockEncIdxSeqLoopErr();
            }
            tryMMapOfIndex(&newSeqIdx->externalData);
          }
          if (hadGtError)
          {
            newBlockEncIdxSeqLoopErr();
          }
          /* 4. dealloc resources no longer required */
          destructAppendState(&aState);
          deletePartialSymSums(buck);
          deletePartialSymSums(buckLast);
        }
        /* 4. dealloc resources no longer required */
        gt_free(compositionPreAlloc);
        gt_free(permCompBSPreAlloc);
        gt_free(block);
      }
    } while (0);
    /* close bwttab and suffix array */
    if (hadGtError)
      newBlockEncIdxSeqErrRet();
  }
  return &(newSeqIdx->baseClass);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %r9, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq %rdx, %rbp
movq %rdi, %r14
pushq $0x64
popq %rdi
movq %r14, %rax
xorl %edx, %edx
divq %rdi
movq %rax, 0x18(%rsp)
testq %rsi, %rsi
je 0x2a8864
movq 0x170(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x2a8895
movl 0x8(%rax), %ebx
testl %ebx, %ebx
je 0x2a88c6
movq 0x1b0(%rsp), %rdx
movl 0xc(%rax), %r15d
cmpq $0x0, 0x1a0(%rsp)
setne %al
testq %rdx, %rdx
setne %dil
testb %dil, %al
jne 0x2a747d
movq 0x1a0(%rsp), %rax
orq %rdx, %rax
jne 0x2a898a
movq %rcx, 0x30(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x1c0(%rsp), %rdi
testq %rdi, %rdi
je 0x2a74a4
callq 0x89eb7
testb %al, %al
jne 0x2a8959
movq %r15, %rax
movq %rbx, 0x20(%rsp)
imulq %rbx, %rax
movq %rax, 0x90(%rsp)
leaq 0xd98c1(%rip), %r13     # 0x380d80
pushq $0x1
popq %r12
movl $0xe8, %edi
movq %r12, %rsi
movq %r13, %rdx
movl $0x150, %ecx            # imm = 0x150
callq 0x9334a
movq %rax, %rbx
movq %r15, 0x98(%rsp)
movl %r15d, 0xb0(%rax)
movq %r14, 0x10(%rax)
movq %r14, 0x88(%rsp)
leaq -0x1(%r14), %rdi
callq 0x28a939
movl %eax, 0xbc(%rbx)
movq %rbp, 0x8(%rbx)
movslq 0x4(%rbp), %r15
movl %r15d, 0xc8(%rbx)
movq %rbp, %rdi
callq 0x14906a
movw %ax, 0x38(%rsp)
leaq (,%r15,4), %rdi
movq %r13, %rsi
movl $0x15a, %edx            # imm = 0x15A
callq 0x93160
movq %rax, %rdx
movq %rbx, 0x8(%rsp)
movq %rax, 0xa8(%rbx)
leaq 0xd9814(%rip), %r14     # 0x380d60
xorl %r13d, %r13d
xorl %ebx, %ebx
movq %rax, 0x28(%rsp)
cmpq %r13, %r15
je 0x2a758f
movl (%r14), %eax
movl %eax, (%rdx,%r13,4)
testl %eax, %eax
je 0x2a7586
cmpl $0x2, %eax
je 0x2a7586
cmpl $0x1, %eax
jne 0x2a773a
movq %rbp, %rdi
movl %r13d, %esi
callq 0x2a8adf
addl %eax, %ebx
movq 0x28(%rsp), %rdx
incq %r13
addq $0x4, %r14
jmp 0x2a7556
movq 0x8(%rsp), %r15
movw %bx, 0xc4(%r15)
xorl %eax, %eax
movb %al, 0xc6(%r15)
pushq $0x1
popq %rsi
movq %rbp, %rdi
movq %rdx, %r13
xorl %ecx, %ecx
callq 0x149084
movq %rax, %r14
movq %rax, 0x98(%r15)
xorl %eax, %eax
movb %al, 0xc7(%r15)
pushq $0x2
popq %rsi
movq %rbp, %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x149084
movq %rax, %r13
movq %rax, 0xa0(%r15)
movq %r14, 0x60(%rsp)
movq %r14, %rdi
callq 0x14906a
cmpw %bx, %ax
jne 0x2a88f7
movzwl %bx, %r14d
movq %r13, 0x40(%rsp)
movq %r13, %rdi
callq 0x14906a
movzwl %ax, %eax
movzwl 0x38(%rsp), %ecx
movq %rcx, 0x78(%rsp)
subl %r14d, %ecx
cmpl %eax, %ecx
jne 0x2a8928
leal (,%r14,4), %r13d
movq %r14, 0x38(%rsp)
leal (,%r14,8), %r14d
leaq 0xd9743(%rip), %rsi     # 0x380d80
movq %r14, %rdi
movl $0x17e, %edx            # imm = 0x17E
callq 0x93160
movq 0x8(%rsp), %r15
movq %rax, 0xd0(%r15)
movq %r13, 0x58(%rsp)
addq %r13, %rax
movq %rax, 0xd8(%r15)
movq 0x30(%rsp), %r13
testq %r13, %r13
je 0x2a7713
leaq 0xd9706(%rip), %rsi     # 0x380d80
movq %r14, %rdi
movl $0x184, %edx            # imm = 0x184
callq 0x93160
cmpl $0x1, 0x8(%r13)
movq 0x40(%rsp), %r13
movq %rax, 0x10(%rsp)
jne 0x2a77fd
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x17380
pushq $0x1
popq %r14
cmpq $0x100, %r15            # imm = 0x100
je 0x2a7814
movzbl %r15b, %esi
movq %rbp, %rdi
callq 0x2a8b86
movzbl %al, %r13d
movq %rbp, %rdi
movl %r13d, %esi
movl %r14d, %edx
movq 0x28(%rsp), %rcx
callq 0x1493cf
testl %eax, %eax
je 0x2a770e
movq 0x60(%rsp), %rdi
movl %r13d, %esi
callq 0x2a8b86
movzbl %al, %eax
cmpw %ax, %bx
jbe 0x2a770e
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
movq (%rcx,%r15,8), %rcx
movq 0x10(%rsp), %rdx
addq %rcx, (%rdx,%rax,8)
incq %r15
jmp 0x2a76b0
movq %r15, %rdi
callq 0x2a8bac
movq %r15, %rbx
movq 0x20(%rsp), %r15
movq 0x40(%rsp), %r13
movq 0x170(%rsp), %rax
movq 0x18(%rsp), %r14
jmp 0x2a7930
leaq 0xd96ca(%rip), %rdi     # 0x380e0b
xorl %eax, %eax
callq 0x92a82
movq 0x8(%rsp), %r14
cmpq $0x0, 0x18(%r14)
je 0x2a775d
leaq 0x18(%r14), %rdi
callq 0x2a8b56
cmpl $0x0, 0x60(%r14)
je 0x2a7770
movq %r14, %rdi
addq $0x48, %rdi
callq 0x2ad242
movq 0x70(%r14), %rdi
testq %rdi, %rdi
je 0x2a777e
callq 0x2ad6ff
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0x2a7798
leaq 0xd95f2(%rip), %rsi     # 0x380d80
movl $0x16d, %edx            # imm = 0x16D
callq 0x936f9
movq 0xd0(%r14), %rdi
testq %rdi, %rdi
je 0x2a77b5
leaq 0xd95d5(%rip), %rsi     # 0x380d80
movl $0x16d, %edx            # imm = 0x16D
callq 0x936f9
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0x2a77cf
leaq 0xd95bb(%rip), %rsi     # 0x380d80
movl $0x16d, %edx            # imm = 0x16D
callq 0x936f9
leaq 0xd95aa(%rip), %rbx     # 0x380d80
movq %r14, %rdi
movq %rbx, %rsi
movl $0x16d, %edx            # imm = 0x16D
callq 0x936f9
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movl $0x16d, %edx            # imm = 0x16D
callq 0x936f9
jmp 0x2a8838
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2a8bac
movq 0x18(%rsp), %r14
jmp 0x2a790d
testw %bx, %bx
movq 0x40(%rsp), %r14
je 0x2a788c
movq 0x8(%rsp), %rbx
movq 0xd8(%rbx), %rax
andl $0x0, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x28a939
movq 0xd0(%rbx), %rcx
movl %eax, (%rcx)
movq 0x38(%rsp), %r15
movq 0xd8(%rbx), %rdx
cmpq %r12, %r15
je 0x2a787b
addl -0x4(%rdx,%r12,4), %eax
movl %eax, (%rdx,%r12,4)
movq 0x10(%rsp), %rax
movq (%rax,%r12,8), %rdi
callq 0x28a939
movq 0xd0(%rbx), %rcx
movl %eax, (%rcx,%r12,4)
incq %r12
jmp 0x2a7848
movl %r15d, %eax
movl -0x4(%rcx,%rax,4), %ecx
addl -0x4(%rdx,%rax,4), %ecx
movl %ecx, 0xe0(%rbx)
movq %r14, %rdi
callq 0x14906a
movl %eax, %r14d
xorl %r15d, %r15d
pushq $0x2
popq %r13
xorl %r12d, %r12d
cmpq $0x100, %r15            # imm = 0x100
je 0x2a78f5
movzbl %r15b, %esi
movq %rbp, %rdi
callq 0x2a8b86
movzbl %al, %ebx
movq %rbp, %rdi
movl %ebx, %esi
movl %r13d, %edx
movq 0x28(%rsp), %rcx
callq 0x1493cf
testl %eax, %eax
je 0x2a78f0
movq 0x40(%rsp), %rdi
movl %ebx, %esi
callq 0x2a8b86
movzbl %al, %eax
cmpw %ax, %r14w
jbe 0x2a78f0
movq 0x30(%rsp), %rax
movq (%rax), %rax
addq (%rax,%r15,8), %r12
incq %r15
jmp 0x2a78a1
pushq $0x14
popq %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r14
movq 0x8(%rsp), %rbx
movq 0x40(%rsp), %r13
leaq 0xd946c(%rip), %rsi     # 0x380d80
movq 0x10(%rsp), %rdi
movl $0x1cf, %edx            # imm = 0x1CF
callq 0x936f9
movq 0x20(%rsp), %r15
movq 0x170(%rsp), %rax
movl 0x4(%rax), %edx
andl $0x1, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2ad59c
movq %rax, 0x70(%rbx)
leaq 0x190234(%rip), %rax    # 0x437b80
movq %rax, (%rbx)
leaq 0x48(%rbx), %r14
movq %r14, %rdi
movl %r15d, %esi
movq 0x38(%rsp), %r12
movl %r12d, %edx
callq 0x2aca90
testl %eax, %eax
je 0x2a79ee
movl 0x60(%rbx), %eax
imull %r12d, %eax
movq %rax, 0x18(%rsp)
movl 0x64(%rbx), %eax
imull %r15d, %eax
movq %rax, 0x10(%rsp)
movq 0x90(%rsp), %rcx
movq 0x1a8(%rsp), %rdx
imulq %rcx, %rdx
movl 0x68(%rbx), %eax
movq %rax, 0xa8(%rsp)
movl %r15d, 0xb4(%rbx)
movq %rdx, 0x90(%rbx)
cmpq $0x0, 0x1a0(%rsp)
movq %r14, 0xa0(%rsp)
je 0x2a7ad9
movl 0x6c(%rbx), %edi
movq 0x98(%rsp), %r14
imull %r14d, %edi
callq 0x28a939
movq 0x90(%rsp), %rcx
movl %eax, %r13d
jmp 0x2a7ae4
leaq 0xd94bb(%rip), %rsi     # 0x380eb0
movq 0x1c0(%rsp), %rdi
movl %r15d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x89dbb
cmpq $0x0, 0x18(%rbx)
je 0x2a7a1d
movq %rbx, %rdi
addq $0x18, %rdi
callq 0x2a8b56
cmpl $0x0, 0x60(%rbx)
je 0x2a7a2b
movq %r14, %rdi
callq 0x2ad242
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x2a7a39
callq 0x2ad6ff
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x2a7a53
leaq 0xd9337(%rip), %rsi     # 0x380d80
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x936f9
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x2a7a70
leaq 0xd931a(%rip), %rsi     # 0x380d80
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x936f9
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x2a7a8a
leaq 0xd9300(%rip), %rsi     # 0x380d80
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x936f9
leaq 0xd92ef(%rip), %rsi     # 0x380d80
movq %rbx, %rdi
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x936f9
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2a7ab9
leaq 0xd92d1(%rip), %rsi     # 0x380d80
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x936f9
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x2a7ac8
callq 0x149458
testq %r13, %r13
je 0x2a8838
movq %r13, %rdi
jmp 0x2a8833
xorl %r13d, %r13d
movq 0x98(%rsp), %r14
movq 0x80(%rsp), %r12
movl %r13d, 0xb8(%rbx)
movq 0x88(%rsp), %rdi
leaq 0x1(%rdi), %rax
xorl %edx, %edx
divq %rcx
movq %rcx, %r8
xorl %ecx, %ecx
testq %rdx, %rdx
setne %cl
leaq (%rax,%rcx), %r15
imull 0x6c(%rbx), %r14d
imulq %r15, %r14
movq 0x1b0(%rsp), %r9
testq %r9, %r9
je 0x2a7b6c
leaq 0xc0(%rsp), %rsi
movq %rax, (%rsi)
movq %r8, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movq %rdx, 0x18(%rsi)
pushq $0x2
popq %rdx
leaq 0x110(%rsp), %rcx
movq 0x1b8(%rsp), %rdi
callq *%r9
testb %al, %al
je 0x2a7b82
movq 0x120(%rsp), %r15
jmp 0x2a7b8b
xorps %xmm0, %xmm0
movaps %xmm0, 0x110(%rsp)
andq $0x0, 0x120(%rsp)
jmp 0x2a7b8e
imulq 0x118(%rsp), %r15
addq %r15, %r14
movq %r14, %rdi
callq 0x28a939
movq 0x8(%rsp), %rbx
movl %eax, 0xc0(%rbx)
movq 0x118(%rsp), %rax
movq %rax, 0x88(%rbx)
movq %rbx, %rdi
movq 0x178(%rsp), %rsi
movq 0x188(%rsp), %rdx
callq 0x2a8c48
movq %rax, %r14
leaq 0x18(%rbx), %r15
leaq 0xd9338(%rip), %rdx     # 0x380f0e
movq %r12, %rdi
movq %r15, %rsi
movq 0x1c0(%rsp), %rcx
callq 0x2a8c91
testl %eax, %eax
je 0x2a8275
movl %r13d, 0x6c(%rsp)
movq %r15, 0x50(%rsp)
movq %rbx, %rdi
callq 0x2aa3b0
movq %rax, %rcx
movq 0x10(%rbx), %rax
movl 0xb4(%rbx), %esi
imull 0xb0(%rbx), %esi
incq %rax
xorl %edx, %edx
divq %rsi
xorl %r12d, %r12d
cmpq $0x1, %rdx
sbbq $-0x1, %rax
imulq %rcx, %rax
movq %rax, %rcx
shrq $0x3, %rcx
andl $0x7, %eax
xorl %edx, %edx
testw $0x1fff, %r14w          # imm = 0x1FFF
setne %dl
andq $-0x2000, %r14          # imm = 0xE000
shll $0xd, %edx
addq %r14, %rdx
movq %rdx, 0x30(%rbx)
addq %rcx, %rdx
cmpq $0x1, %rax
sbbq $-0x1, %rdx
movq %rdx, 0x38(%rbx)
andq $0x0, 0x40(%rbx)
leaq 0xd9111(%rip), %r15     # 0x380d80
movq 0x20(%rsp), %rdi
movq %rdi, %r14
movq %r15, %rsi
movl $0x209, %edx            # imm = 0x209
callq 0x93160
movq %rax, %r13
movq 0x58(%rsp), %rdi
movq %r15, %rsi
movl $0x20b, %edx            # imm = 0x20B
callq 0x93160
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, %rdi
shrq $0x3, %rdi
andl $0x7, %eax
cmpq $0x1, %rax
sbbq $-0x1, %rdi
movq %r15, %rsi
movl $0x20e, %edx            # imm = 0x20E
callq 0x93160
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %r15
movl %r15d, %edi
callq 0x2a8d07
movq %rax, 0x10(%rsp)
movl %r15d, %edi
callq 0x2a8d07
movq %rax, 0x70(%rsp)
movq 0x88(%rsp), %rax
xorl %edx, %edx
divq %r14
movq %rdx, 0x130(%rsp)
movq %rax, 0x80(%rsp)
movq %rbx, %rdi
callq 0x2aa3b0
movl 0xb0(%rbx), %ecx
imull 0x6c(%rbx), %ecx
addq $0x7, %rax
movq 0x88(%rbx), %rdx
leaq (%rdx,%rcx), %r15
addq $0x7, %r15
leaq 0xc0(%rsp), %r14
movq %rax, 0x10(%r14)
movq %r15, 0x18(%r14)
movq %rax, %rsi
shrq $0x3, %rsi
andl $0x7, %eax
cmpq $0x1, %rax
sbbq $-0x1, %rsi
pushq $0x1
popq %rdi
leaq 0xd9027(%rip), %rdx     # 0x380d80
movl $0x6d0, %ecx            # imm = 0x6D0
callq 0x9334a
movq %rax, (%r14)
movq %r15, %rsi
shrq $0x3, %rsi
andl $0x7, %r15d
cmpq $0x1, %r15
sbbq $-0x1, %rsi
pushq $0x1
popq %rdi
leaq 0xd8ffd(%rip), %rdx     # 0x380d80
movl $0x6d2, %ecx            # imm = 0x6D2
callq 0x9334a
movq 0x20(%rsp), %r15
movq %rax, 0x8(%r14)
movl 0xe0(%rbx), %eax
movl 0xb8(%rbx), %ecx
movl 0xc0(%rbx), %edx
addq %rax, %rdx
addq %rdx, %rcx
movq %rcx, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
movq 0x78(%rsp), %rax
shll $0x3, %eax
movq %rax, 0x78(%rsp)
leaq 0xd913f(%rip), %rax     # 0x380f12
movq %rax, 0x48(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x60(%rsp), %rbx
imulq %r12, %r15
cmpq 0x80(%rsp), %r12
jae 0x2a7ef4
movq 0xb0(%rsp), %rdi
movq %r13, %rsi
movq %r13, %r14
movq 0x20(%rsp), %r13
movq %r13, %rdx
callq *0xb8(%rsp)
cmpq %r13, %rax
jne 0x2a857a
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x149352
subq $0x8, %rsp
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r12, %rdx
movq %r14, %rcx
movl %r13d, %r8d
movq %rbp, %r9
leaq 0xc8(%rsp), %rax
pushq %rax
pushq 0xb8(%rsp)
pushq 0x48(%rsp)
pushq 0x38(%rsp)
pushq 0x60(%rsp)
pushq %rbx
pushq 0x60(%rsp)
callq 0x2a8d1d
addq $0x40, %rsp
incq %r12
movq %r12, %rax
xorl %edx, %edx
divq 0x98(%rsp)
addq %r13, %r15
testq %rdx, %rdx
movq %r14, %r13
jne 0x2a7dea
movq 0x8(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movq 0x1a0(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x90(%rsp), %r8
movl 0x6c(%rsp), %r9d
movq 0x70(%rsp), %r14
pushq %r14
pushq 0x1c0(%rsp)
callq 0x2a8f11
popq %rcx
popq %rdx
testl %eax, %eax
js 0x2a8850
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x17630
movq %r15, 0x58(%rsp)
movq 0x20(%rsp), %r15
jmp 0x2a7de6
movq 0x130(%rsp), %r15
testq %r15, %r15
movq 0x8(%rsp), %r14
je 0x2a7f93
movq 0xb0(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq *0xb8(%rsp)
cmpq %r15, %rax
jb 0x2a85c4
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x149352
movq %r13, %rdi
addq %r15, %rdi
movq %r15, %rax
movq 0x20(%rsp), %r15
movq %r15, %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0x17380
subq $0x8, %rsp
movq %r14, %rdi
movq 0x18(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %r15d, %r8d
movq %rbp, %r9
leaq 0xc8(%rsp), %rax
pushq %rax
pushq 0xb8(%rsp)
pushq 0x48(%rsp)
pushq 0x38(%rsp)
pushq 0x60(%rsp)
pushq %rbx
pushq 0x60(%rsp)
callq 0x2a8d1d
addq $0x40, %rsp
movq 0x88(%rsp), %r8
movq 0x58(%rsp), %rcx
subq %rcx, %r8
movq 0x50(%rsp), %r12
movq 0x70(%rsp), %rax
jb 0x2a7fde
leaq 0xc0(%rsp), %rsi
movq %r14, %rdi
movq 0x1a0(%rsp), %rdx
movl 0x6c(%rsp), %r9d
pushq %rax
pushq 0x1c0(%rsp)
callq 0x2a8f11
popq %rcx
popq %rdx
testl %eax, %eax
js 0x2a8766
testq %r14, %r14
je 0x2a89ec
movl 0x104(%rsp), %eax
cmpq $0x7, %rax
movq 0x1c0(%rsp), %r15
ja 0x2a89bb
movl 0xe0(%r14), %ecx
movl 0xb8(%r14), %edx
movl 0xc0(%r14), %esi
addq %rsi, %rdx
addq %rax, %rcx
addq %rdx, %rcx
cmpq 0xe0(%rsp), %rcx
jne 0x2a89bb
movl 0x100(%rsp), %ecx
cmpq $0x7, %rcx
ja 0x2a8a1d
cmpq %rcx, 0xe8(%rsp)
jne 0x2a8a1d
testq %rax, %rax
je 0x2a8095
movq 0x18(%r14), %rdi
movq 0xf8(%rsp), %rsi
addq 0x30(%r14), %rsi
xorl %edx, %edx
callq 0x17c70
testl %eax, %eax
jne 0x2a85a6
movq 0xc0(%rsp), %rdi
movq (%r12), %rcx
pushq $0x1
popq %rdx
movq %rdx, %rsi
callq 0xb302c
incq 0xf8(%rsp)
movl 0x100(%rsp), %ecx
testl %ecx, %ecx
je 0x2a80d3
movq 0x18(%r14), %rdi
movq 0xf0(%rsp), %rsi
shrq $0x3, %rsi
addq 0x38(%r14), %rsi
xorl %edx, %edx
callq 0x17c70
testl %eax, %eax
jne 0x2a85a6
movq 0xc8(%rsp), %rdi
movq (%r12), %rcx
pushq $0x1
popq %rdx
movq %rdx, %rsi
callq 0xb302c
movq 0xf0(%rsp), %rax
movq %r14, %rbx
movq %rax, %r14
shrq $0x3, %r14
addq 0x38(%rbx), %r14
andl $0x7, %eax
cmpq $0x1, %rax
sbbq $-0x1, %r14
movq %r14, 0x40(%rbx)
movq 0x70(%rbx), %rdi
movl 0xb4(%rbx), %esi
addq 0x10(%rbx), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
callq 0x2ad781
movq 0x70(%rbx), %rdi
callq 0x2ad65b
movq 0x18(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x17c70
movl $0x267, %ebp            # imm = 0x267
leaq 0xd8e08(%rip), %rcx     # 0x380f3b
movq %rcx, 0x48(%rsp)
testl %eax, %eax
jne 0x2a85bc
movq 0x18(%rbx), %rsi
movq 0x70(%rbx), %rdi
callq 0x2ae297
testl %eax, %eax
movq %rbx, %r14
je 0x2a8709
testq %r15, %r15
je 0x2a8a4b
movq 0x18(%r14), %rbx
movq %r14, %r12
xorl %r14d, %r14d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a8c48
movq %rax, %rbp
leaq 0xd8bff(%rip), %rsi     # 0x380d80
movq %rax, %rdi
movl $0x7cf, %edx            # imm = 0x7CF
callq 0x93160
movq %rax, %r15
xorl %ecx, %ecx
testw $0x1fff, %bp            # imm = 0x1FFF
setne %cl
movq %rbp, %rax
andq $-0x2000, %rax          # imm = 0xE000
shll $0xd, %ecx
addq %rax, %rcx
movl $0x584442, (%r15)       # imm = 0x584442
movq %rcx, 0x38(%rsp)
movl %ecx, 0x4(%r15)
movl $0x424b535a, 0x8(%r15)  # imm = 0x424B535A
movl 0xb4(%r12), %eax
movl %eax, 0xc(%r15)
movl $0x42424c4b, 0x10(%r15) # imm = 0x42424C4B
movl 0xb0(%r12), %eax
movl %eax, 0x14(%r15)
movl $0x564f4646, 0x18(%r15) # imm = 0x564F4646
movq 0x38(%r12), %rax
movq %rax, 0x1c(%r15)
movl $0x524f4646, 0x24(%r15) # imm = 0x524F4646
movq 0x40(%r12), %rax
movq %rax, 0x28(%r15)
movl $0x53454c45, 0x30(%r15) # imm = 0x53454C45
movq 0x10(%r12), %rax
movq %rax, 0x34(%r15)
movl $0x53504254, 0x3c(%r15) # imm = 0x53504254
movl 0xbc(%r12), %eax
movl %eax, 0x40(%r15)
movl $0x56444f42, 0x44(%r15) # imm = 0x56444F42
movl 0xc0(%r12), %eax
movl %eax, 0x48(%r15)
movl $0x53534254, 0x4c(%r15) # imm = 0x53534254
movzwl 0xc4(%r12), %eax
movl %eax, 0x50(%r15)
cmpq %r14, %rax
je 0x2a834e
movq 0x8(%rsp), %rcx
movq 0xd0(%rcx), %rcx
movl (%rcx,%r14,4), %ecx
movl %ecx, 0x54(%r15,%r14,4)
incq %r14
jmp 0x2a8252
cmpq $0x0, (%r15)
je 0x2a8283
movq %r15, %rdi
callq 0x2a8b56
movq 0x8(%rsp), %rbx
cmpl $0x0, 0x60(%rbx)
movq 0xa0(%rsp), %rdi
movq 0x40(%rsp), %r14
je 0x2a82a0
callq 0x2ad242
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x2a82ae
callq 0x2ad6ff
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x2a82c8
leaq 0xd8ac2(%rip), %rsi     # 0x380d80
movl $0x1fa, %edx            # imm = 0x1FA
callq 0x936f9
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x2a82e5
leaq 0xd8aa5(%rip), %rsi     # 0x380d80
movl $0x1fa, %edx            # imm = 0x1FA
callq 0x936f9
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x2a82ff
leaq 0xd8a8b(%rip), %rsi     # 0x380d80
movl $0x1fa, %edx            # imm = 0x1FA
callq 0x936f9
leaq 0xd8a7a(%rip), %rsi     # 0x380d80
movq %rbx, %rdi
movl $0x1fa, %edx            # imm = 0x1FA
callq 0x936f9
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2a832e
leaq 0xd8a5c(%rip), %rsi     # 0x380d80
movl $0x1fa, %edx            # imm = 0x1FA
callq 0x936f9
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x2a833d
callq 0x149458
testq %r14, %r14
je 0x2a8838
movq %r14, %rdi
jmp 0x2a8833
shll $0x2, %eax
movl $0x42454642, 0x54(%r15,%rax) # imm = 0x42454642
movq 0x8(%rsp), %r14
movzbl 0xc6(%r14), %ecx
movl %ecx, 0x58(%r15,%rax)
movl $0x52454642, 0x5c(%r15,%rax) # imm = 0x52454642
movzbl 0xc7(%r14), %ecx
movl %ecx, 0x60(%r15,%rax)
movl $0x4e4d524e, 0x64(%r15,%rax) # imm = 0x4E4D524E
movl 0xc8(%r14), %edx
movl %edx, 0x68(%r15,%rax)
addq $0x6c, %rax
xorl %ecx, %ecx
movslq %edx, %rdx
cmpq %rdx, %rcx
jae 0x2a83c3
movq 0xa8(%r14), %rdx
movl (%rdx,%rcx,4), %edx
movl %edx, (%r15,%rax)
addq $0x4, %rax
incq %rcx
movl 0xc8(%r14), %edx
jmp 0x2a839d
cmpl $0x0, 0xb8(%r14)
je 0x2a840f
movl $0x43424d42, (%r15,%rax) # imm = 0x43424D42
movl 0xb8(%r14), %ecx
movl %ecx, 0x4(%r15,%rax)
movl $0x43455842, 0x8(%r15,%rax) # imm = 0x43455842
movq 0x90(%r14), %rcx
movq %rcx, 0xc(%r15,%rax)
movl $0x4d455842, 0x14(%r15,%rax) # imm = 0x4D455842
movq 0x88(%r14), %rcx
movq %rcx, 0x18(%r15,%rax)
addq $0x20, %rax
cmpq %rbp, %rax
jne 0x2a8a79
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x17c70
movl $0x80e, %edx            # imm = 0x80E
testl %eax, %eax
jne 0x2a8658
pushq $0x1
popq %r14
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xb302c
cmpq $0x0, 0x178(%rsp)
je 0x2a85fb
movq 0x180(%rsp), %r12
movzwl (%r12), %esi
movq 0x188(%rsp), %rax
movl (%rax), %edx
movq 0x190(%rsp), %rax
movq (%rax), %rcx
movq 0x198(%rsp), %rax
movq (%rax), %r8
movq %rbx, %rdi
callq 0x2aa3d6
testl %eax, %eax
je 0x2a8594
movq 0x8(%rsp), %rcx
movq %rcx, %rdi
addq $0x78, %rdi
movq 0x80(%rcx), %rsi
leaq 0x1(%rsi), %rax
movq %rax, 0x80(%rcx)
movq %rbp, %rdx
addq $0x8, %rdx
movzwl (%r12), %ecx
orl $0x45480000, %ecx       # imm = 0x45480000
movq %rdi, 0x20(%rsp)
callq 0x2aa2f6
cmpq %r14, 0x178(%rsp)
je 0x2a85ce
movq 0x188(%rsp), %r12
movl -0x4(%r12,%r14,4), %eax
addl $0x8, %eax
addq %rax, %rbp
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x17c70
testl %eax, %eax
jne 0x2a8644
movq %rbx, %rdi
movq 0x180(%rsp), %rbx
movzwl (%rbx,%r14,2), %esi
movl (%r12,%r14,4), %edx
movq 0x190(%rsp), %rax
movq (%rax,%r14,8), %rcx
movq 0x198(%rsp), %rax
movq (%rax,%r14,8), %r8
movq %rdi, %r12
callq 0x2aa3d6
testl %eax, %eax
je 0x2a864b
movq 0x8(%rsp), %rcx
movq 0x80(%rcx), %rsi
leaq 0x1(%rsi), %rax
movq %rax, 0x80(%rcx)
leaq 0x8(%rbp), %rdx
movzwl (%rbx), %ecx
orl $0x45480000, %ecx       # imm = 0x45480000
movq 0x20(%rsp), %rdi
callq 0x2aa2f6
incq %r14
movq %r12, %rbx
jmp 0x2a84cf
movl $0x27d, %ebp            # imm = 0x27D
movq 0x8(%rsp), %rax
movq 0x50(%rsp), %r12
movq %r14, %r13
movq %rax, %r14
jmp 0x2a8709
movl $0x815, %edx            # imm = 0x815
xorl %r12d, %r12d
movq 0x8(%rsp), %r14
jmp 0x2a8658
movl $0x267, %ebp            # imm = 0x267
leaq 0xd8989(%rip), %rax     # 0x380f3b
movq %rax, 0x48(%rsp)
jmp 0x2a8709
movq %rbx, %r14
jmp 0x2a8709
movl $0x247, %ebp            # imm = 0x247
jmp 0x2a86f8
movq 0x188(%rsp), %rax
movq 0x178(%rsp), %rcx
movl -0x4(%rax,%rcx,4), %eax
leaq (%rax,%rbp), %r14
addq $0x8, %r14
movq %rbx, %rdi
callq 0x17b50
cmpq %rax, %r14
jl 0x2a8ab1
movl $0x82c, %edx            # imm = 0x82C
movq 0x38(%rsp), %rax
movq %rax, %r12
movq 0x8(%rsp), %r14
cmpq %rax, 0x30(%r14)
je 0x2a8658
movq 0x18f94e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c9ef(%rip), %rsi     # 0x2e5013
leaq 0xd8e00(%rip), %rdx     # 0x38142b
leaq 0xd8dc4(%rip), %rcx     # 0x3813f6
leaq 0xd8747(%rip), %r8      # 0x380d80
movl $0x82b, %r9d            # imm = 0x82B
jmp 0x2a8aa5
movl $0x81e, %edx            # imm = 0x81E
jmp 0x2a8650
movl $0x821, %edx            # imm = 0x821
movq 0x8(%rsp), %r14
xorl %r12d, %r12d
leaq 0xd8721(%rip), %rsi     # 0x380d80
movq %r15, %rdi
callq 0x936f9
leaq 0xd8907(%rip), %rbx     # 0x380f75
testq %r12, %r12
je 0x2a86ee
movq 0x50(%rsp), %r12
movq (%r12), %rdi
callq 0x178a0
testl %eax, %eax
jne 0x2a86ff
movq %r12, %rdi
callq 0x2a9334
leaq 0xc0(%rsp), %rdi
callq 0x2a92ed
movq 0x10(%rsp), %rdi
callq 0x2a9323
movq 0x70(%rsp), %rdi
callq 0x2a9323
leaq 0xd86cb(%rip), %rbx     # 0x380d80
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
movl $0x285, %edx            # imm = 0x285
callq 0x936f9
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
movl $0x286, %edx            # imm = 0x286
callq 0x936f9
movq %r13, %rdi
movq %rbx, %rsi
movl $0x287, %edx            # imm = 0x287
callq 0x936f9
jmp 0x2a883b
movq %rbx, 0x48(%rsp)
movl $0x270, %ebp            # imm = 0x270
movq 0x50(%rsp), %r12
jmp 0x2a8709
movq %rbx, 0x48(%rsp)
movl $0x277, %ebp            # imm = 0x277
movq 0x48(%rsp), %rdi
callq 0x17660
leaq 0xc0(%rsp), %rdi
callq 0x2a92ed
movq 0x10(%rsp), %rdi
callq 0x2a9323
movq 0x70(%rsp), %rdi
callq 0x2a9323
leaq 0xd8645(%rip), %rbx     # 0x380d80
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x936f9
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x936f9
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x936f9
cmpq $0x0, (%r12)
je 0x2a8775
movq %r12, %rdi
callq 0x2a8b56
cmpl $0x0, 0x60(%r14)
movq 0x40(%rsp), %rbx
je 0x2a878e
movq 0xa0(%rsp), %rdi
callq 0x2ad242
movq 0x70(%r14), %rdi
testq %rdi, %rdi
je 0x2a879c
callq 0x2ad6ff
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0x2a87b6
leaq 0xd85d4(%rip), %rsi     # 0x380d80
movl $0x28c, %edx            # imm = 0x28C
callq 0x936f9
movq 0xd0(%r14), %rdi
testq %rdi, %rdi
je 0x2a87d3
leaq 0xd85b7(%rip), %rsi     # 0x380d80
movl $0x28c, %edx            # imm = 0x28C
callq 0x936f9
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0x2a87ed
leaq 0xd859d(%rip), %rsi     # 0x380d80
movl $0x28c, %edx            # imm = 0x28C
callq 0x936f9
leaq 0xd858c(%rip), %rsi     # 0x380d80
movq %r14, %rdi
movl $0x28c, %edx            # imm = 0x28C
callq 0x936f9
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2a881c
leaq 0xd856e(%rip), %rsi     # 0x380d80
movl $0x28c, %edx            # imm = 0x28C
callq 0x936f9
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x2a882b
callq 0x149458
testq %rbx, %rbx
je 0x2a8838
movq %rbx, %rdi
callq 0x149458
xorl %r14d, %r14d
movq %r14, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x27d, %ebp            # imm = 0x27D
movq 0x8(%rsp), %r14
movq 0x50(%rsp), %r12
jmp 0x2a8713
movq 0x18f6fd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c79e(%rip), %rsi     # 0x2e5013
leaq 0x99b5b(%rip), %rdx     # 0x3423d7
leaq 0xd84e5(%rip), %rcx     # 0x380d68
leaq 0xd84f6(%rip), %r8      # 0x380d80
movl $0x14a, %r9d            # imm = 0x14A
jmp 0x2a8aa5
movq 0x18f6cc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c76d(%rip), %rsi     # 0x2e5013
leaq 0xd84ed(%rip), %rdx     # 0x380d9a
leaq 0xd84b4(%rip), %rcx     # 0x380d68
leaq 0xd84c5(%rip), %r8      # 0x380d80
movl $0x14b, %r9d            # imm = 0x14B
jmp 0x2a8aa5
movq 0x18f69b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c73c(%rip), %rsi     # 0x2e5013
leaq 0xd84e0(%rip), %rdx     # 0x380dbe
leaq 0xd8483(%rip), %rcx     # 0x380d68
leaq 0xd8494(%rip), %r8      # 0x380d80
movl $0x14c, %r9d            # imm = 0x14C
jmp 0x2a8aa5
movq 0x18f66a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c70b(%rip), %rsi     # 0x2e5013
leaq 0xd8517(%rip), %rdx     # 0x380e26
leaq 0xd8452(%rip), %rcx     # 0x380d68
leaq 0xd8463(%rip), %r8      # 0x380d80
movl $0x178, %r9d            # imm = 0x178
jmp 0x2a8aa5
movq 0x18f639(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c6da(%rip), %rsi     # 0x2e5013
leaq 0xd8521(%rip), %rdx     # 0x380e61
leaq 0xd8421(%rip), %rcx     # 0x380d68
leaq 0xd8432(%rip), %r8      # 0x380d80
movl $0x17a, %r9d            # imm = 0x17A
jmp 0x2a8aa5
movq 0x18f608(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c6a9(%rip), %rsi     # 0x2e5013
leaq 0x3c84e(%rip), %rdx     # 0x2e51bf
leaq 0xd83f0(%rip), %rcx     # 0x380d68
leaq 0xd8401(%rip), %r8      # 0x380d80
movl $0x14e, %r9d            # imm = 0x14E
jmp 0x2a8aa5
movq 0x18f5d7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c678(%rip), %rsi     # 0x2e5013
leaq 0xd842a(%rip), %rdx     # 0x380dcc
leaq 0xd83bf(%rip), %rcx     # 0x380d68
leaq 0xd83d0(%rip), %r8      # 0x380d80
movl $0x14d, %r9d            # imm = 0x14D
jmp 0x2a8aa5
movq 0x18f5a6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c647(%rip), %rsi     # 0x2e5013
leaq 0xd8ae6(%rip), %rdx     # 0x3814b9
leaq 0xd8acd(%rip), %rcx     # 0x3814a7
leaq 0xd839f(%rip), %r8      # 0x380d80
movl $0x97d, %r9d            # imm = 0x97D
jmp 0x2a8aa5
movq 0x18f575(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c616(%rip), %rsi     # 0x2e5013
leaq 0xd8a92(%rip), %rdx     # 0x381496
leaq 0xd8a9c(%rip), %rcx     # 0x3814a7
leaq 0xd836e(%rip), %r8      # 0x380d80
movl $0x97a, %r9d            # imm = 0x97A
jmp 0x2a8aa5
movq 0x18f544(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c5e5(%rip), %rsi     # 0x2e5013
leaq 0xd8aee(%rip), %rdx     # 0x381523
leaq 0xd8a6b(%rip), %rcx     # 0x3814a7
leaq 0xd833d(%rip), %r8      # 0x380d80
movl $0x97f, %r9d            # imm = 0x97F
jmp 0x2a8aa5
movq 0x18f516(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c5b7(%rip), %rsi     # 0x2e5013
leaq 0xd8985(%rip), %rdx     # 0x3813e8
leaq 0xd898c(%rip), %rcx     # 0x3813f6
leaq 0xd830f(%rip), %r8      # 0x380d80
movl $0x7cc, %r9d            # imm = 0x7CC
jmp 0x2a8aa5
movq 0x18f4e8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c589(%rip), %rsi     # 0x2e5013
leaq 0xd8974(%rip), %rdx     # 0x381405
leaq 0xd895e(%rip), %rcx     # 0x3813f6
leaq 0xd82e1(%rip), %r8      # 0x380d80
movl $0x80c, %r9d            # imm = 0x80C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x18f4b0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3c551(%rip), %rsi     # 0x2e5013
leaq 0xd894d(%rip), %rdx     # 0x381416
leaq 0xd8926(%rip), %rcx     # 0x3813f6
leaq 0xd82a9(%rip), %r8      # 0x380d80
movl $0x829, %r9d            # imm = 0x829
jmp 0x2a8aa5