Still use 64bit candidate sort. Further do not cache near the beginning.

      if (mm_positive_hits[mi].size() == 0) continue;

      // only the positive part may have the underflow issue

      if (heap_resort)

        std::sort(mm_positive_hits[mi].begin(), mm_positive_hits[mi].end(), CompSortHits);

        std::sort(mm_positive_hits[mi].begin(), mm_positive_hits[mi].end());

      struct mmHit nh;

      nh.mi = mi;

      nh.position = mm_positive_hits[mi][0];

    delete[] mm_negative_hits;

    delete[] mm_pos;

  } else {

    std::sort(positive_hits.begin(), positive_hits.end(), CompSortHits);

    std::sort(positive_hits.begin(), positive_hits.end());

    std::sort(negative_hits.begin(), negative_hits.end());

  }

  /*for (uint32_t mi = 0 ; mi < positive_hits->size() ; ++mi)

    return key;

  }

  inline static bool CompSortHits(const uint64_t &a, const uint64_t &b) {

    if (int(a>>32) != int(b>>32))

      return a < b;

    else

      return (int)a < int(b);

  }

 protected:

  int kmer_size_;

  int window_size_;

      int shift = (int)minimizers[0].second >> 1;

      // Do not cache if it is too near the start.

      for (i = 0; i < size; ++i) 

        if ((int)pos_candidates[i].position < 0) {

        if ((int)pos_candidates[i].position < kmer_length + shift) {

          cache[hidx].offsets.resize(0);

          cache[hidx].strands.resize(0);

          cache[hidx].minimizers.resize(0);

  bool operator<(const mmHit &h) const {

    // the inversed direction is to make a min-heap

    //return position > h.position;

    if (int(position>>32) != int(h.position>>32))

    return position > h.position;

    else

      return (int)position > (int)h.position;

  }

};