// File: /workspace/github_c_makefile_star2_O0/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 %rbx
subq $0x218, %rsp            # imm = 0x218
movq 0x290(%rsp), %rax
movq 0x288(%rsp), %rax
movq 0x280(%rsp), %rax
movq 0x278(%rsp), %rax
movq 0x270(%rsp), %rax
movq 0x268(%rsp), %rax
movq 0x260(%rsp), %rax
movq 0x258(%rsp), %rax
movq 0x250(%rsp), %rax
movq 0x248(%rsp), %rax
movq 0x240(%rsp), %rax
movq %r8, 0x200(%rsp)
movq %r9, 0x208(%rsp)
movq %rdi, 0x1f8(%rsp)
movq %rsi, 0x1f0(%rsp)
movq %rdx, 0x1e8(%rsp)
movq %rcx, 0x1e0(%rsp)
movq $0x0, 0x1d8(%rsp)
movq 0x1f8(%rsp), %rax
movl $0x64, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x1c8(%rsp)
movq $0x0, 0x1c0(%rsp)
movq $0x0, 0x1b8(%rsp)
movq 0x240(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x19c(%rsp)
movq 0x240(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x198(%rsp)
movl 0x198(%rsp), %eax
movl 0x19c(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x190(%rsp)
movq $0x0, 0x188(%rsp)
movq 0x111444(%rip), %rax    # 0x5b5ee8
movq %rax, 0x168(%rsp)
cmpq $0x0, 0x1f0(%rsp)
jne 0x4a4aef
movq 0x1974e2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x7154b(%rip), %rsi     # 0x516013
leaq 0xcfbd8(%rip), %rdx     # 0x5746a7
leaq 0x11141a(%rip), %rcx    # 0x5b5ef0
leaq 0x11142b(%rip), %r8     # 0x5b5f08
movl $0x14a, %r9d            # imm = 0x14A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a4af1
jmp 0x4a4af3
movq 0x240(%rsp), %rax
cmpl $0x2, (%rax)
je 0x4a4b38
movq 0x197499(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x71502(%rip), %rsi     # 0x516013
leaq 0x11140a(%rip), %rdx    # 0x5b5f22
leaq 0x1113d1(%rip), %rcx    # 0x5b5ef0
leaq 0x1113e2(%rip), %r8     # 0x5b5f08
movl $0x14b, %r9d            # imm = 0x14B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a4b3a
jmp 0x4a4b3c
cmpl $0x0, 0x19c(%rsp)
ja 0x4a4b7e
movq 0x197453(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x714bc(%rip), %rsi     # 0x516013
leaq 0x1113e8(%rip), %rdx    # 0x5b5f46
leaq 0x11138b(%rip), %rcx    # 0x5b5ef0
leaq 0x11139c(%rip), %r8     # 0x5b5f08
movl $0x14c, %r9d            # imm = 0x14C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a4b80
jmp 0x4a4b82
cmpq $0x0, 0x270(%rsp)
je 0x4a4b98
cmpq $0x0, 0x280(%rsp)
jne 0x4a4be6
cmpq $0x0, 0x270(%rsp)
jne 0x4a4bae
cmpq $0x0, 0x280(%rsp)
je 0x4a4be6
movq 0x1973eb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x71454(%rip), %rsi     # 0x516013
leaq 0x11138e(%rip), %rdx    # 0x5b5f54
leaq 0x111323(%rip), %rcx    # 0x5b5ef0
leaq 0x111334(%rip), %r8     # 0x5b5f08
movl $0x14d, %r9d            # imm = 0x14D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a4be8
jmp 0x4a4bea
cmpq $0x0, 0x290(%rsp)
je 0x4a4c40
movq 0x290(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4a4c08
jmp 0x4a4c40
movq 0x197391(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x713fa(%rip), %rsi     # 0x516013
leaq 0x7159f(%rip), %rdx     # 0x5161bf
leaq 0x1112c9(%rip), %rcx    # 0x5b5ef0
leaq 0x1112da(%rip), %r8     # 0x5b5f08
movl $0x14e, %r9d            # imm = 0x14E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a4c42
movl $0xe8, %edi
movl $0x1, %esi
leaq 0x1112b5(%rip), %rdx    # 0x5b5f08
movl $0x150, %ecx            # imm = 0x150
callq 0xe83c0
movq %rax, 0x1d8(%rsp)
movl 0x198(%rsp), %ecx
movq 0x1d8(%rsp), %rax
movl %ecx, 0xb0(%rax)
movq 0x1f8(%rsp), %rdi
movq 0x1d8(%rsp), %rax
movq %rdi, 0x10(%rax)
subq $0x1, %rdi
callq 0x46ec80
movl %eax, %ecx
movq 0x1d8(%rsp), %rax
movl %ecx, 0xbc(%rax)
movq 0x1e8(%rsp), %rcx
movq 0x1d8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x1e8(%rsp), %rdi
callq 0x4a64a0
movq 0x1d8(%rsp), %rcx
movl %eax, 0xc8(%rcx)
cltq
movq %rax, 0x158(%rsp)
movq 0x1e8(%rsp), %rdi
callq 0x22aeb0
movw %ax, 0x1d4(%rsp)
movw $0x0, 0x1d6(%rsp)
movq 0x158(%rsp), %rdi
shlq $0x2, %rdi
leaq 0x1111f6(%rip), %rsi    # 0x5b5f08
movl $0x15a, %edx            # imm = 0x15A
callq 0xe80f0
movq %rax, %rcx
movq %rcx, 0x188(%rsp)
movq 0x1d8(%rsp), %rax
movq %rcx, 0xa8(%rax)
movq $0x0, 0x160(%rsp)
movq 0x160(%rsp), %rax
cmpq 0x158(%rsp), %rax
jae 0x4a4f77
movq 0x160(%rsp), %rcx
movl 0x168(%rsp,%rcx,4), %edx
movq 0x188(%rsp), %rax
movl %edx, (%rax,%rcx,4)
movq 0x160(%rsp), %rax
movl 0x168(%rsp,%rax,4), %eax
movl %eax, 0x64(%rsp)
testl %eax, %eax
je 0x4a4dd2
jmp 0x4a4d8b
movl 0x64(%rsp), %eax
subl $0x1, %eax
je 0x4a4da1
jmp 0x4a4d96
movl 0x64(%rsp), %eax
subl $0x2, %eax
je 0x4a4dd7
jmp 0x4a4ddc
movq 0x1e8(%rsp), %rdi
movq 0x160(%rsp), %rax
movl %eax, %esi
callq 0x4a64b0
movzwl %ax, %ecx
movzwl 0x1d6(%rsp), %eax
addl %ecx, %eax
movw %ax, 0x1d6(%rsp)
jmp 0x4a4f5c
jmp 0x4a4f5c
jmp 0x4a4f5c
leaq 0x1111b0(%rip), %rdi    # 0x5b5f93
movb $0x0, %al
callq 0xe7740
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4a4e0a
movq 0x1d8(%rsp), %rdi
addq $0x18, %rdi
callq 0x4a6560
movq 0x1d8(%rsp), %rax
cmpl $0x0, 0x60(%rax)
je 0x4a4e29
movq 0x1d8(%rsp), %rdi
addq $0x48, %rdi
callq 0x4af220
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x4a4e49
movq 0x1d8(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x4afea0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4a4e75
movq 0x1d8(%rsp), %rax
movq 0x78(%rax), %rdi
leaq 0x11109d(%rip), %rsi    # 0x5b5f08
movl $0x16d, %edx            # imm = 0x16D
callq 0xe88c0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x4a4ea7
movq 0x1d8(%rsp), %rax
movq 0xd0(%rax), %rdi
leaq 0x11106b(%rip), %rsi    # 0x5b5f08
movl $0x16d, %edx            # imm = 0x16D
callq 0xe88c0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4a4ed3
movq 0x1d8(%rsp), %rax
movq 0x78(%rax), %rdi
leaq 0x11103f(%rip), %rsi    # 0x5b5f08
movl $0x16d, %edx            # imm = 0x16D
callq 0xe88c0
cmpq $0x0, 0x1d8(%rsp)
je 0x4a4ef7
movq 0x1d8(%rsp), %rdi
leaq 0x11101b(%rip), %rsi    # 0x5b5f08
movl $0x16d, %edx            # imm = 0x16D
callq 0xe88c0
cmpq $0x0, 0x188(%rsp)
je 0x4a4f1b
movq 0x188(%rsp), %rdi
leaq 0x110ff7(%rip), %rsi    # 0x5b5f08
movl $0x16d, %edx            # imm = 0x16D
callq 0xe88c0
cmpq $0x0, 0x1c0(%rsp)
je 0x4a4f33
movq 0x1c0(%rsp), %rdi
callq 0x22b660
cmpq $0x0, 0x1b8(%rsp)
je 0x4a4f4b
movq 0x1b8(%rsp), %rdi
callq 0x22b660
movq $0x0, 0x210(%rsp)
jmp 0x4a6489
jmp 0x4a4f5e
movq 0x160(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x160(%rsp)
jmp 0x4a4d42
movw 0x1d6(%rsp), %cx
movq 0x1d8(%rsp), %rax
movw %cx, 0xc4(%rax)
movq 0x1e8(%rsp), %rdi
movq 0x188(%rsp), %rdx
movq 0x1d8(%rsp), %rax
movb $0x0, 0xc6(%rax)
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x22af10
movq %rax, %rcx
movq %rcx, 0x1c0(%rsp)
movq 0x1d8(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x1e8(%rsp), %rdi
movq 0x188(%rsp), %rdx
movq 0x1d8(%rsp), %rax
movb $0x0, 0xc7(%rax)
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x22af10
movq %rax, %rcx
movq %rcx, 0x1b8(%rsp)
movq 0x1d8(%rsp), %rax
movq %rcx, 0xa0(%rax)
movq 0x1c0(%rsp), %rdi
callq 0x22aeb0
movzwl %ax, %eax
movzwl 0x1d6(%rsp), %ecx
cmpl %ecx, %eax
je 0x4a506c
movq 0x196f65(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x70fce(%rip), %rsi     # 0x516013
leaq 0x110f62(%rip), %rdx    # 0x5b5fae
leaq 0x110e9d(%rip), %rcx    # 0x5b5ef0
leaq 0x110eae(%rip), %r8     # 0x5b5f08
movl $0x178, %r9d            # imm = 0x178
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a506e
jmp 0x4a5070
movq 0x1b8(%rsp), %rdi
callq 0x22aeb0
movzwl %ax, %eax
movzwl 0x1d4(%rsp), %ecx
movzwl 0x1d6(%rsp), %edx
subl %edx, %ecx
cmpl %ecx, %eax
je 0x4a50ce
movq 0x196f03(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x70f6c(%rip), %rsi     # 0x516013
leaq 0x110f3b(%rip), %rdx    # 0x5b5fe9
leaq 0x110e3b(%rip), %rcx    # 0x5b5ef0
leaq 0x110e4c(%rip), %r8     # 0x5b5f08
movl $0x17a, %r9d            # imm = 0x17A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4a50d0
movzwl 0x1d6(%rsp), %eax
movl %eax, %edi
shlq $0x2, %rdi
shlq %rdi
leaq 0x110e20(%rip), %rsi    # 0x5b5f08
movl $0x17e, %edx            # imm = 0x17E
callq 0xe80f0
movq %rax, %rcx
movq 0x1d8(%rsp), %rax
movq %rcx, 0xd0(%rax)
movq 0x1d8(%rsp), %rax
movq 0xd0(%rax), %rcx
movzwl 0x1d6(%rsp), %eax
cltq
shlq $0x2, %rax
addq %rax, %rcx
movq 0x1d8(%rsp), %rax
movq %rcx, 0xd8(%rax)
cmpq $0x0, 0x1e0(%rsp)
je 0x4a54fb
movzwl 0x1d6(%rsp), %eax
shll $0x3, %eax
movl %eax, %edi
leaq 0x110db2(%rip), %rsi    # 0x5b5f08
movl $0x184, %edx            # imm = 0x184
callq 0xe80f0
movq %rax, 0x150(%rsp)
movq 0x1e0(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
jne 0x4a54d3
jmp 0x4a517e
movq 0x150(%rsp), %rdi
movzwl 0x1d6(%rsp), %eax
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x19360
movl $0x0, 0x148(%rsp)
cmpl $0xff, 0x148(%rsp)
ja 0x4a5272
movq 0x1e8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x1e8(%rsp), %rdi
movl 0x148(%rsp), %eax
movzbl %al, %esi
callq 0x4a65b0
movq 0x58(%rsp), %rdi
movb %al, 0x14f(%rsp)
movq 0x188(%rsp), %rcx
movl $0x1, %edx
movzbl %al, %esi
callq 0x22b530
cmpl $0x0, %eax
je 0x4a525a
movq 0x1c0(%rsp), %rdi
movzbl 0x14f(%rsp), %esi
callq 0x4a65b0
movb %al, 0x14e(%rsp)
movzbl %al, %eax
movzwl 0x1d6(%rsp), %ecx
cmpl %ecx, %eax
jge 0x4a525a
movq 0x1e0(%rsp), %rax
movq (%rax), %rax
movl 0x148(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
movq 0x150(%rsp), %rax
movzbl 0x14e(%rsp), %ecx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x4a525c
movl 0x148(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x148(%rsp)
jmp 0x4a51a6
cmpw $0x0, 0x1d6(%rsp)
je 0x4a53c7
movq 0x1d8(%rsp), %rax
movq 0xd8(%rax), %rax
movl $0x0, (%rax)
movq 0x150(%rsp), %rax
movq (%rax), %rdi
callq 0x46ec80
movl %eax, %ecx
movq 0x1d8(%rsp), %rax
movq 0xd0(%rax), %rax
movl %ecx, (%rax)
movl $0x1, 0x148(%rsp)
movl 0x148(%rsp), %eax
movzwl 0x1d6(%rsp), %ecx
cmpl %ecx, %eax
jae 0x4a5379
movq 0x1d8(%rsp), %rax
movq 0xd8(%rax), %rax
movl 0x148(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movq 0x1d8(%rsp), %rax
movq 0xd0(%rax), %rax
movl 0x148(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
addl (%rax,%rcx,4), %edx
movq 0x1d8(%rsp), %rax
movq 0xd8(%rax), %rax
movl 0x148(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movq 0x150(%rsp), %rax
movl 0x148(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x46ec80
movl %eax, %edx
movq 0x1d8(%rsp), %rax
movq 0xd0(%rax), %rax
movl 0x148(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0x148(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x148(%rsp)
jmp 0x4a52c4
movq 0x1d8(%rsp), %rax
movq 0xd8(%rax), %rax
movzwl 0x1d6(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
movq 0x1d8(%rsp), %rax
movq 0xd0(%rax), %rax
movzwl 0x1d6(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
addl (%rax,%rdx,4), %ecx
movq 0x1d8(%rsp), %rax
movl %ecx, 0xe0(%rax)
movq $0x0, 0x138(%rsp)
movq 0x1b8(%rsp), %rdi
callq 0x22aeb0
movw %ax, 0x136(%rsp)
movl $0x0, 0x130(%rsp)
cmpl $0xff, 0x130(%rsp)
ja 0x4a54b7
movq 0x1e8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x1e8(%rsp), %rdi
movl 0x130(%rsp), %eax
movzbl %al, %esi
callq 0x4a65b0
movq 0x50(%rsp), %rdi
movb %al, 0x147(%rsp)
movq 0x188(%rsp), %rcx
movl $0x2, %edx
movzbl %al, %esi
callq 0x22b530
cmpl $0x0, %eax
je 0x4a549f
movq 0x1b8(%rsp), %rdi
movzbl 0x147(%rsp), %esi
callq 0x4a65b0
movb %al, 0x146(%rsp)
movzbl %al, %eax
movzwl 0x136(%rsp), %ecx
cmpl %ecx, %eax
jge 0x4a549f
movq 0x1e0(%rsp), %rax
movq (%rax), %rax
movl 0x130(%rsp), %ecx
movq (%rax,%rcx,8), %rax
addq 0x138(%rsp), %rax
movq %rax, 0x138(%rsp)
jmp 0x4a54a1
movl 0x130(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x130(%rsp)
jmp 0x4a53f3
movq 0x138(%rsp), %rax
movl $0x14, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x1c8(%rsp)
jmp 0x4a54e0
movq 0x1d8(%rsp), %rdi
callq 0x4a65f0
movq 0x150(%rsp), %rdi
leaq 0x110a19(%rip), %rsi    # 0x5b5f08
movl $0x1cf, %edx            # imm = 0x1CF
callq 0xe88c0
jmp 0x4a5508
movq 0x1d8(%rsp), %rdi
callq 0x4a65f0
movl $0x0, 0x12c(%rsp)
movq 0x240(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4a5537
movl 0x12c(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x12c(%rsp)
movq 0x1c8(%rsp), %rdi
movq 0x1b8(%rsp), %rsi
movl 0x12c(%rsp), %edx
callq 0x4afc40
movq %rax, %rcx
movq 0x1d8(%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0x1d8(%rsp), %rax
leaq 0x19669f(%rip), %rcx    # 0x63bc10
movq %rcx, (%rax)
movq 0x1d8(%rsp), %rdi
addq $0x48, %rdi
movl 0x19c(%rsp), %esi
movzwl 0x1d6(%rsp), %edx
callq 0x4ae620
cmpl $0x0, %eax
jne 0x4a5734
movq 0x290(%rsp), %rdi
movl 0x19c(%rsp), %edx
movzwl 0x1d6(%rsp), %ecx
leaq 0x110a7d(%rip), %rsi    # 0x5b6038
movb $0x0, %al
callq 0xd88c0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4a55e2
movq 0x1d8(%rsp), %rdi
addq $0x18, %rdi
callq 0x4a6560
movq 0x1d8(%rsp), %rax
cmpl $0x0, 0x60(%rax)
je 0x4a5601
movq 0x1d8(%rsp), %rdi
addq $0x48, %rdi
callq 0x4af220
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x4a5621
movq 0x1d8(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x4afea0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4a564d
movq 0x1d8(%rsp), %rax
movq 0x78(%rax), %rdi
leaq 0x1108c5(%rip), %rsi    # 0x5b5f08
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xe88c0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x4a567f
movq 0x1d8(%rsp), %rax
movq 0xd0(%rax), %rdi
leaq 0x110893(%rip), %rsi    # 0x5b5f08
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xe88c0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4a56ab
movq 0x1d8(%rsp), %rax
movq 0x78(%rax), %rdi
leaq 0x110867(%rip), %rsi    # 0x5b5f08
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xe88c0
cmpq $0x0, 0x1d8(%rsp)
je 0x4a56cf
movq 0x1d8(%rsp), %rdi
leaq 0x110843(%rip), %rsi    # 0x5b5f08
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xe88c0
cmpq $0x0, 0x188(%rsp)
je 0x4a56f3
movq 0x188(%rsp), %rdi
leaq 0x11081f(%rip), %rsi    # 0x5b5f08
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xe88c0
cmpq $0x0, 0x1c0(%rsp)
je 0x4a570b
movq 0x1c0(%rsp), %rdi
callq 0x22b660
cmpq $0x0, 0x1b8(%rsp)
je 0x4a5723
movq 0x1b8(%rsp), %rdi
callq 0x22b660
movq $0x0, 0x210(%rsp)
jmp 0x4a6489
movq 0x1d8(%rsp), %rax
movl 0x60(%rax), %eax
movzwl 0x1d6(%rsp), %ecx
imull %ecx, %eax
movl %eax, %eax
movq %rax, 0x1b0(%rsp)
movq 0x1d8(%rsp), %rax
movl 0x68(%rax), %eax
movl %eax, 0x1a4(%rsp)
movq 0x1d8(%rsp), %rax
movl 0x64(%rax), %eax
imull 0x19c(%rsp), %eax
movl %eax, %eax
movq %rax, 0x1a8(%rsp)
movl 0x19c(%rsp), %ecx
movq 0x1d8(%rsp), %rax
movl %ecx, 0xb4(%rax)
movq 0x278(%rsp), %rcx
imulq 0x190(%rsp), %rcx
movq 0x1d8(%rsp), %rax
movq %rcx, 0x90(%rax)
cmpq $0x0, 0x270(%rsp)
je 0x4a57e5
movq 0x1d8(%rsp), %rax
movl 0x6c(%rax), %eax
imull 0x198(%rsp), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x46ec80
movl %eax, 0x4c(%rsp)
jmp 0x4a57ed
xorl %eax, %eax
movl %eax, 0x4c(%rsp)
jmp 0x4a57ed
movl 0x4c(%rsp), %ecx
movl %ecx, 0x1a0(%rsp)
movq 0x1d8(%rsp), %rax
movl %ecx, 0xb8(%rax)
movq 0x1f8(%rsp), %rdi
movl 0x19c(%rsp), %esi
movl 0x198(%rsp), %edx
movq 0x1d8(%rsp), %rax
movl 0x6c(%rax), %ecx
movq 0x280(%rsp), %r8
movq 0x288(%rsp), %r9
leaq 0x170(%rsp), %rax
movq %rax, (%rsp)
callq 0x4a6730
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rdi
callq 0x46ec80
movl %eax, %ecx
movq 0x1d8(%rsp), %rax
movl %ecx, 0xc0(%rax)
movq 0x178(%rsp), %rcx
movq 0x1d8(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x1d8(%rsp), %rdi
movq 0x248(%rsp), %rsi
movq 0x258(%rsp), %rdx
callq 0x4a68e0
movq %rax, 0x118(%rsp)
movq 0x1f0(%rsp), %rdi
movq 0x1d8(%rsp), %rsi
addq $0x18, %rsi
movq 0x290(%rsp), %rcx
leaq 0x1107ca(%rip), %rdx    # 0x5b6096
callq 0x4a6980
cmpl $0x0, %eax
jne 0x4a5a4e
jmp 0x4a58dc
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4a58fc
movq 0x1d8(%rsp), %rdi
addq $0x18, %rdi
callq 0x4a6560
movq 0x1d8(%rsp), %rax
cmpl $0x0, 0x60(%rax)
je 0x4a591b
movq 0x1d8(%rsp), %rdi
addq $0x48, %rdi
callq 0x4af220
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x4a593b
movq 0x1d8(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x4afea0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4a5967
movq 0x1d8(%rsp), %rax
movq 0x78(%rax), %rdi
leaq 0x1105ab(%rip), %rsi    # 0x5b5f08
movl $0x1fa, %edx            # imm = 0x1FA
callq 0xe88c0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x4a5999
movq 0x1d8(%rsp), %rax
movq 0xd0(%rax), %rdi
leaq 0x110579(%rip), %rsi    # 0x5b5f08
movl $0x1fa, %edx            # imm = 0x1FA
callq 0xe88c0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4a59c5
movq 0x1d8(%rsp), %rax
movq 0x78(%rax), %rdi
leaq 0x11054d(%rip), %rsi    # 0x5b5f08
movl $0x1fa, %edx            # imm = 0x1FA
callq 0xe88c0
cmpq $0x0, 0x1d8(%rsp)
je 0x4a59e9
movq 0x1d8(%rsp), %rdi
leaq 0x110529(%rip), %rsi    # 0x5b5f08
movl $0x1fa, %edx            # imm = 0x1FA
callq 0xe88c0
cmpq $0x0, 0x188(%rsp)
je 0x4a5a0d
movq 0x188(%rsp), %rdi
leaq 0x110505(%rip), %rsi    # 0x5b5f08
movl $0x1fa, %edx            # imm = 0x1FA
callq 0xe88c0
cmpq $0x0, 0x1c0(%rsp)
je 0x4a5a25
movq 0x1c0(%rsp), %rdi
callq 0x22b660
cmpq $0x0, 0x1b8(%rsp)
je 0x4a5a3d
movq 0x1b8(%rsp), %rdi
callq 0x22b660
movq $0x0, 0x210(%rsp)
jmp 0x4a6489
movq 0x1d8(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x38(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0x4a6aa0
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq %rax, %rdx
callq 0x4a6a40
movl $0x0, 0x114(%rsp)
movl 0x19c(%rsp), %eax
movl %eax, %edi
shlq $0x0, %rdi
leaq 0x11045e(%rip), %rsi    # 0x5b5f08
movl $0x209, %edx            # imm = 0x209
callq 0xe80f0
movq %rax, 0x108(%rsp)
movzwl 0x1d6(%rsp), %eax
movl %eax, %edi
shlq $0x2, %rdi
leaq 0x110437(%rip), %rsi    # 0x5b5f08
movl $0x20b, %edx            # imm = 0x20B
callq 0xe80f0
movq %rax, 0x100(%rsp)
movq 0x1b0(%rsp), %rdi
addq 0x1a8(%rsp), %rdi
callq 0x4a6b00
movq %rax, %rdi
shlq $0x0, %rdi
leaq 0x110402(%rip), %rsi    # 0x5b5f08
movl $0x20e, %edx            # imm = 0x20E
callq 0xe80f0
movq %rax, 0xf8(%rsp)
movzwl 0x1d4(%rsp), %edi
callq 0x4a6b60
movq %rax, 0xf0(%rsp)
movzwl 0x1d4(%rsp), %edi
callq 0x4a6b60
movq %rax, 0xe8(%rsp)
movq 0x1f8(%rsp), %rax
movl 0x19c(%rsp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0xe0(%rsp)
movq $0x0, 0xd0(%rsp)
movq 0x1d8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x4a6b90
movq $0x0, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
cmpq 0xe0(%rsp), %rax
jae 0x4a5d82
movq 0x108(%rsp), %rdx
movl 0x19c(%rsp), %eax
movl %eax, %ecx
movq 0x200(%rsp), %rdi
movq 0x208(%rsp), %rsi
callq 0x4a6ca0
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movl 0x19c(%rsp), %ecx
cmpq %rcx, %rax
je 0x4a5bff
movl $0x1, 0x114(%rsp)
leaq 0x1104a5(%rip), %rdi    # 0x5b609a
callq 0x19640
jmp 0x4a5d82
movq 0x1e8(%rsp), %rdi
movq 0x108(%rsp), %rsi
movl 0x19c(%rsp), %eax
movl %eax, %edx
callq 0x22b420
movq 0x1d8(%rsp), %rdi
movq 0xf0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
movq 0x108(%rsp), %rcx
movl 0x19c(%rsp), %r8d
movq 0x1e8(%rsp), %r9
movq 0x188(%rsp), %r15
movq 0x1c0(%rsp), %r14
movw 0x1d6(%rsp), %bp
movq 0xf8(%rsp), %rbx
movq 0x100(%rsp), %r11
movl 0x1a4(%rsp), %r10d
leaq 0x88(%rsp), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movzwl %bp, %ebp
movl %ebp, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movl %r10d, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x4a6ce0
movq 0xd8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd8(%rsp)
movl 0x198(%rsp), %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x4a5d7d
movq 0xd8(%rsp), %rax
movl 0x19c(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x78(%rsp)
movq 0x1d8(%rsp), %rdi
movq 0x270(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq 0x190(%rsp), %r8
movl 0x1a0(%rsp), %r9d
movq 0x288(%rsp), %r10
movq 0xe8(%rsp), %rax
leaq 0x88(%rsp), %rsi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x4a6df0
cmpl $0x0, %eax
jge 0x4a5d50
movl $0x1, 0x114(%rsp)
jmp 0x4a5d82
movw 0x1d4(%rsp), %ax
movq 0xe8(%rsp), %rsi
movq 0xf0(%rsp), %rdx
movzwl %ax, %edi
callq 0x4a6eb0
movq 0x78(%rsp), %rax
movq %rax, 0xd0(%rsp)
jmp 0x4a5b8b
cmpl $0x0, 0x114(%rsp)
jne 0x4a620a
movq 0x1f8(%rsp), %rax
movl 0x19c(%rsp), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0x4a5f4d
movq 0x108(%rsp), %rdx
movq 0x70(%rsp), %rcx
movq 0x200(%rsp), %rdi
movq 0x208(%rsp), %rsi
callq 0x4a6ca0
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
cmpq 0x70(%rsp), %rax
jae 0x4a5e7a
movl $0x1, 0x114(%rsp)
leaq 0x11029c(%rip), %rdi    # 0x5b609a
callq 0x19640
leaq 0x88(%rsp), %rdi
callq 0x4a6ef0
movq 0xf0(%rsp), %rdi
callq 0x4a6f30
movq 0xe8(%rsp), %rdi
callq 0x4a6f30
movq 0x100(%rsp), %rdi
leaq 0x1100cf(%rip), %rsi    # 0x5b5f08
movl $0x247, %edx            # imm = 0x247
callq 0xe88c0
movq 0xf8(%rsp), %rdi
leaq 0x1100b6(%rip), %rsi    # 0x5b5f08
movl $0x247, %edx            # imm = 0x247
callq 0xe88c0
movq 0x108(%rsp), %rdi
leaq 0x11009d(%rip), %rsi    # 0x5b5f08
movl $0x247, %edx            # imm = 0x247
callq 0xe88c0
jmp 0x4a62fa
movq 0x1e8(%rsp), %rdi
movq 0x108(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x22b420
movq 0x108(%rsp), %rdi
addq 0x70(%rsp), %rdi
movl 0x19c(%rsp), %eax
movl %eax, %edx
subq 0x70(%rsp), %rdx
shlq $0x0, %rdx
xorl %esi, %esi
callq 0x19360
movq 0x1d8(%rsp), %rdi
movq 0xf0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
movq 0x108(%rsp), %rcx
movl 0x19c(%rsp), %r8d
movq 0x1e8(%rsp), %r9
movq 0x188(%rsp), %r15
movq 0x1c0(%rsp), %r14
movw 0x1d6(%rsp), %bp
movq 0xf8(%rsp), %rbx
movq 0x100(%rsp), %r11
movl 0x1a4(%rsp), %r10d
leaq 0x88(%rsp), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movzwl %bp, %ebp
movl %ebp, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movl %r10d, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x4a6ce0
jmp 0x4a5f4d
movq 0xd0(%rsp), %rax
cmpq 0x1f8(%rsp), %rax
ja 0x4a5fcc
movq 0x1d8(%rsp), %rdi
movq 0x270(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq 0x1f8(%rsp), %r8
subq 0xd0(%rsp), %r8
movl 0x1a0(%rsp), %r9d
movq 0x288(%rsp), %r10
movq 0xe8(%rsp), %rax
leaq 0x88(%rsp), %rsi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x4a6df0
cmpl $0x0, %eax
jge 0x4a5fca
movl $0x1, 0x114(%rsp)
jmp 0x4a62fa
jmp 0x4a5fcc
movq 0x1d8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x4a6f50
cmpl $0x0, %eax
jne 0x4a6078
movl $0x1, 0x114(%rsp)
leaq 0x1100c7(%rip), %rdi    # 0x5b60c3
callq 0x19640
leaq 0x88(%rsp), %rdi
callq 0x4a6ef0
movq 0xf0(%rsp), %rdi
callq 0x4a6f30
movq 0xe8(%rsp), %rdi
callq 0x4a6f30
movq 0x100(%rsp), %rdi
leaq 0x10fed1(%rip), %rsi    # 0x5b5f08
movl $0x267, %edx            # imm = 0x267
callq 0xe88c0
movq 0xf8(%rsp), %rdi
leaq 0x10feb8(%rip), %rsi    # 0x5b5f08
movl $0x267, %edx            # imm = 0x267
callq 0xe88c0
movq 0x108(%rsp), %rdi
leaq 0x10fe9f(%rip), %rsi    # 0x5b5f08
movl $0x267, %edx            # imm = 0x267
callq 0xe88c0
jmp 0x4a62fa
movq 0x1d8(%rsp), %rdi
movq 0x248(%rsp), %rsi
movq 0x250(%rsp), %rdx
movq 0x258(%rsp), %rcx
movq 0x260(%rsp), %r8
movq 0x268(%rsp), %r9
movq 0x290(%rsp), %rax
movq %rax, (%rsp)
callq 0x4a7250
cmpq $0x0, %rax
jne 0x4a6151
movl $0x1, 0x114(%rsp)
leaq 0x110028(%rip), %rdi    # 0x5b60fd
callq 0x19640
leaq 0x88(%rsp), %rdi
callq 0x4a6ef0
movq 0xf0(%rsp), %rdi
callq 0x4a6f30
movq 0xe8(%rsp), %rdi
callq 0x4a6f30
movq 0x100(%rsp), %rdi
leaq 0x10fdf8(%rip), %rsi    # 0x5b5f08
movl $0x270, %edx            # imm = 0x270
callq 0xe88c0
movq 0xf8(%rsp), %rdi
leaq 0x10fddf(%rip), %rsi    # 0x5b5f08
movl $0x270, %edx            # imm = 0x270
callq 0xe88c0
movq 0x108(%rsp), %rdi
leaq 0x10fdc6(%rip), %rsi    # 0x5b5f08
movl $0x270, %edx            # imm = 0x270
callq 0xe88c0
jmp 0x4a62fa
movq 0x1d8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x19840
cmpl $0x0, %eax
je 0x4a61f9
movl $0x1, 0x114(%rsp)
leaq 0x10ff80(%rip), %rdi    # 0x5b60fd
callq 0x19640
leaq 0x88(%rsp), %rdi
callq 0x4a6ef0
movq 0xf0(%rsp), %rdi
callq 0x4a6f30
movq 0xe8(%rsp), %rdi
callq 0x4a6f30
movq 0x100(%rsp), %rdi
leaq 0x10fd50(%rip), %rsi    # 0x5b5f08
movl $0x277, %edx            # imm = 0x277
callq 0xe88c0
movq 0xf8(%rsp), %rdi
leaq 0x10fd37(%rip), %rsi    # 0x5b5f08
movl $0x277, %edx            # imm = 0x277
callq 0xe88c0
movq 0x108(%rsp), %rdi
leaq 0x10fd1e(%rip), %rsi    # 0x5b5f08
movl $0x277, %edx            # imm = 0x277
callq 0xe88c0
jmp 0x4a62fa
movq 0x1d8(%rsp), %rdi
addq $0x18, %rdi
callq 0x4a7ab0
cmpl $0x0, 0x114(%rsp)
je 0x4a6288
leaq 0x88(%rsp), %rdi
callq 0x4a6ef0
movq 0xf0(%rsp), %rdi
callq 0x4a6f30
movq 0xe8(%rsp), %rdi
callq 0x4a6f30
movq 0x100(%rsp), %rdi
leaq 0x10fcbe(%rip), %rsi    # 0x5b5f08
movl $0x27d, %edx            # imm = 0x27D
callq 0xe88c0
movq 0xf8(%rsp), %rdi
leaq 0x10fca5(%rip), %rsi    # 0x5b5f08
movl $0x27d, %edx            # imm = 0x27D
callq 0xe88c0
movq 0x108(%rsp), %rdi
leaq 0x10fc8c(%rip), %rsi    # 0x5b5f08
movl $0x27d, %edx            # imm = 0x27D
callq 0xe88c0
jmp 0x4a62fa
leaq 0x88(%rsp), %rdi
callq 0x4a6ef0
movq 0xf0(%rsp), %rdi
callq 0x4a6f30
movq 0xe8(%rsp), %rdi
callq 0x4a6f30
movq 0x100(%rsp), %rdi
leaq 0x10fc4a(%rip), %rsi    # 0x5b5f08
movl $0x285, %edx            # imm = 0x285
callq 0xe88c0
movq 0xf8(%rsp), %rdi
leaq 0x10fc31(%rip), %rsi    # 0x5b5f08
movl $0x286, %edx            # imm = 0x286
callq 0xe88c0
movq 0x108(%rsp), %rdi
leaq 0x10fc18(%rip), %rsi    # 0x5b5f08
movl $0x287, %edx            # imm = 0x287
callq 0xe88c0
cmpl $0x0, 0x114(%rsp)
je 0x4a6479
jmp 0x4a630a
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4a632a
movq 0x1d8(%rsp), %rdi
addq $0x18, %rdi
callq 0x4a6560
movq 0x1d8(%rsp), %rax
cmpl $0x0, 0x60(%rax)
je 0x4a6349
movq 0x1d8(%rsp), %rdi
addq $0x48, %rdi
callq 0x4af220
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x4a6369
movq 0x1d8(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x4afea0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4a6395
movq 0x1d8(%rsp), %rax
movq 0x78(%rax), %rdi
leaq 0x10fb7d(%rip), %rsi    # 0x5b5f08
movl $0x28c, %edx            # imm = 0x28C
callq 0xe88c0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x4a63c7
movq 0x1d8(%rsp), %rax
movq 0xd0(%rax), %rdi
leaq 0x10fb4b(%rip), %rsi    # 0x5b5f08
movl $0x28c, %edx            # imm = 0x28C
callq 0xe88c0
movq 0x1d8(%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4a63f3
movq 0x1d8(%rsp), %rax
movq 0x78(%rax), %rdi
leaq 0x10fb1f(%rip), %rsi    # 0x5b5f08
movl $0x28c, %edx            # imm = 0x28C
callq 0xe88c0
cmpq $0x0, 0x1d8(%rsp)
je 0x4a6417
movq 0x1d8(%rsp), %rdi
leaq 0x10fafb(%rip), %rsi    # 0x5b5f08
movl $0x28c, %edx            # imm = 0x28C
callq 0xe88c0
cmpq $0x0, 0x188(%rsp)
je 0x4a643b
movq 0x188(%rsp), %rdi
leaq 0x10fad7(%rip), %rsi    # 0x5b5f08
movl $0x28c, %edx            # imm = 0x28C
callq 0xe88c0
cmpq $0x0, 0x1c0(%rsp)
je 0x4a6453
movq 0x1c0(%rsp), %rdi
callq 0x22b660
cmpq $0x0, 0x1b8(%rsp)
je 0x4a646b
movq 0x1b8(%rsp), %rdi
callq 0x22b660
movq $0x0, 0x210(%rsp)
jmp 0x4a6489
movq 0x1d8(%rsp), %rax
movq %rax, 0x210(%rsp)
movq 0x210(%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop