@ladybugmem/icebug 0.1.0 → 0.1.1

package/vendor/include/tlx/algorithm/multiway_merge.hpp

@@ -1,1385 +0,0 @@
-/*******************************************************************************
- * tlx/algorithm/multiway_merge.hpp
- *
- * Many variants of multiway merge.
- *
- * Copied and modified from STXXL, see http://stxxl.org, which itself extracted
- * it from MCSTL http://algo2.iti.uni-karlsruhe.de/singler/mcstl/. Both are
- * distributed under the Boost Software License, Version 1.0.
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2007 Johannes Singler <singler@ira.uka.de>
- * Copyright (C) 2014-2018 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_ALGORITHM_MULTIWAY_MERGE_HEADER
-#define TLX_ALGORITHM_MULTIWAY_MERGE_HEADER
-
-#include <tlx/algorithm/merge_advance.hpp>
-#include <tlx/container/loser_tree.hpp>
-#include <tlx/container/simple_vector.hpp>
-#include <tlx/define/likely.hpp>
-#include <tlx/unused.hpp>
-#include <algorithm>
-#include <cassert>
-#include <functional>
-#include <iterator>
-#include <numeric>
-#include <utility>
-#include <vector>
-
-namespace tlx {
-
-//! \addtogroup tlx_algorithm
-//! \{
-
-namespace multiway_merge_detail {
-
-//! Size of a sequence described by a pair of iterators.
-template <typename RandomAccessIteratorPair>
-typename std::iterator_traits<
-    typename RandomAccessIteratorPair::first_type>::difference_type
-iterpair_size(const RandomAccessIteratorPair& p)
-{
-    return p.second - p.first;
-}
-
-/*!
- * Iterator wrapper supporting an implicit supremum at the end of the sequence,
- * dominating all comparisons.  Deriving from RandomAccessIterator is not
- * possible since RandomAccessIterator need not be a class.
- */
-template <typename RandomAccessIterator, typename Comparator>
-class guarded_iterator
-{
-public:
-    //! Our own type
-    using self_type = guarded_iterator<RandomAccessIterator, Comparator>;
-
-    //! Value type of the iterator
-    using value_type =
-        typename std::iterator_traits<RandomAccessIterator>::value_type;
-
-private:
-    //! Current iterator position.
-    RandomAccessIterator current;
-    //! End iterator of the sequence.
-    RandomAccessIterator end_;
-    //! Comparator.
-    Comparator& comp_;
-
-public:
-    /*!
-     * Constructor. Sets iterator to beginning of sequence.
-     * \param begin Begin iterator of sequence.
-     * \param end End iterator of sequence.
-     * \param comp Comparator provided for associated overloaded compare
-     * operators.
-     */
-    guarded_iterator(RandomAccessIterator begin, RandomAccessIterator end,
-                     Comparator& comp)
-        : current(begin), end_(end), comp_(comp)
-    {
-    }
-
-    /*!
-     * Pre-increment operator.
-     * \return This.
-     */
-    self_type& operator++()
-    {
-        ++current;
-        return *this;
-    }
-
-    /*!
-     * Dereference operator.
-     * \return Referenced element.
-     */
-    value_type& operator*()
-    {
-        return *current;
-    }
-
-    /*!
-     * Convert to wrapped iterator.
-     * \return Wrapped iterator.
-     */
-    RandomAccessIterator& iterator()
-    {
-        return current;
-    }
-
-    /*!
-     * Compare two elements referenced by guarded iterators.
-     * \param bi1 First iterator.
-     * \param bi2 Second iterator.
-     * \return \c True if less.
-     */
-    friend bool operator<(self_type& bi1, self_type& bi2)
-    {
-        if (bi1.current == bi1.end_)        // bi1 is sup
-            return bi2.current == bi2.end_; // bi2 is not sup
-        if (bi2.current == bi2.end_)        // bi2 is sup
-            return true;
-        return bi1.comp_(*bi1, *bi2); // normal compare
-    }
-
-    /*!
-     * Compare two elements referenced by guarded iterators.
-     * \param bi1 First iterator.
-     * \param bi2 Second iterator.
-     * \return \c True if less equal.
-     */
-    friend bool operator<=(self_type& bi1, self_type& bi2)
-    {
-        if (bi2.current == bi2.end_)        // bi1 is sup
-            return bi1.current != bi1.end_; // bi2 is not sup
-        if (bi1.current == bi1.end_)        // bi2 is sup
-            return false;
-        return !bi1.comp_(*bi2, *bi1); // normal compare
-    }
-};
-
-template <typename RandomAccessIterator, typename Comparator>
-class unguarded_iterator
-{
-public:
-    //! Our own type
-    using self_type = unguarded_iterator<RandomAccessIterator, Comparator>;
-
-    //! Value type of the iterator
-    using value_type =
-        typename std::iterator_traits<RandomAccessIterator>::value_type;
-
-private:
-    //! Current iterator position.
-    RandomAccessIterator current;
-    //! Comparator.
-    Comparator& comp_;
-
-public:
-    /*!
-     * Constructor. Sets iterator to beginning of sequence.
-     * \param begin Begin iterator of sequence.
-     * param end Unused, only for compatibility.
-     * \param comp Unused, only for compatibility.
-     */
-    unguarded_iterator(RandomAccessIterator begin,
-                       RandomAccessIterator /* end */, Comparator& comp)
-        : current(begin), comp_(comp)
-    {
-    }
-
-    /*!
-     * Pre-increment operator.
-     * \return This.
-     */
-    self_type& operator++()
-    {
-        ++current;
-        return *this;
-    }
-
-    /*!
-     * Dereference operator.
-     * \return Referenced element.
-     */
-    value_type& operator*()
-    {
-        return *current;
-    }
-
-    /*!
-     * Convert to wrapped iterator.
-     * \return Wrapped iterator.
-     */
-    RandomAccessIterator& iterator()
-    {
-        return current;
-    }
-
-    /*!
-     * Compare two elements referenced by unguarded iterators.
-     * \param bi1 First iterator.
-     * \param bi2 Second iterator.
-     * \return \c True if less.
-     */
-    friend bool operator<(self_type& bi1, self_type& bi2)
-    {
-        return bi1.comp_(*bi1, *bi2); // normal compare, unguarded
-    }
-
-    /*!
-     * Compare two elements referenced by unguarded iterators.
-     * \param bi1 First iterator.
-     * \param bi2 Second iterator.
-     * \return \c True if less equal.
-     */
-    friend bool operator<=(self_type& bi1, self_type& bi2)
-    {
-        return !bi1.comp_(*bi2, *bi1); // normal compare, unguarded
-    }
-};
-
-/*!
- * Prepare a set of sequences to be merged without a (end) guard
- *
- * \param seqs_begin
- * \param seqs_end
- * \param comp
- * \param min_sequence
- * \tparam Stable
- * \pre (seqs_end - seqs_begin > 0)
- */
-template <bool Stable, typename RandomAccessIteratorIterator,
-          typename Comparator>
-typename std::iterator_traits<typename std::iterator_traits<
-    RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-prepare_unguarded(RandomAccessIteratorIterator seqs_begin,
-                  RandomAccessIteratorIterator seqs_end, Comparator comp,
-                  int& min_sequence)
-{
-    using RandomAccessIterator = typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type;
-    using value_type =
-        typename std::iterator_traits<RandomAccessIterator>::value_type;
-    using diff_type =
-        typename std::iterator_traits<RandomAccessIterator>::difference_type;
-
-    if ((*seqs_begin).first == (*seqs_begin).second)
-    {
-        // empty sequence found, it's the first one
-        min_sequence = 0;
-        return -1;
-    }
-
-    // last element in sequence
-    value_type min = *((*seqs_begin).second - 1);
-    min_sequence = 0;
-    for (RandomAccessIteratorIterator s = seqs_begin + 1; s != seqs_end; ++s)
-    {
-        if ((*s).first == (*s).second)
-        {
-            // empty sequence found
-            min_sequence = static_cast<int>(s - seqs_begin);
-            return -1;
-        }
-        const value_type& v = *((*s).second - 1);
-        if (comp(v, min))
-        {
-            // last element in sequence is strictly smaller
-            min = v;
-            min_sequence = static_cast<int>(s - seqs_begin);
-        }
-    }
-
-    diff_type overhang_size = 0;
-
-    int s = 0;
-    for (s = 0; s <= min_sequence; ++s)
-    {
-        RandomAccessIterator split;
-        if (Stable)
-            split = std::upper_bound(seqs_begin[s].first, seqs_begin[s].second,
-                                     min, comp);
-        else
-            split = std::lower_bound(seqs_begin[s].first, seqs_begin[s].second,
-                                     min, comp);
-
-        overhang_size += seqs_begin[s].second - split;
-    }
-
-    for (; s < (seqs_end - seqs_begin); ++s)
-    {
-        RandomAccessIterator split = std::lower_bound(
-            seqs_begin[s].first, seqs_begin[s].second, min, comp);
-        overhang_size += seqs_begin[s].second - split;
-    }
-
-    // so many elements will be left over afterwards
-    return overhang_size;
-}
-
-/*!
- * Prepare a set of sequences to be merged with a (end) guard (sentinel)
- * \param seqs_begin
- * \param seqs_end
- * \param comp
- */
-template <typename RandomAccessIteratorIterator, typename Comparator>
-typename std::iterator_traits<typename std::iterator_traits<
-    RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-prepare_unguarded_sentinel(RandomAccessIteratorIterator seqs_begin,
-                           RandomAccessIteratorIterator seqs_end,
-                           Comparator comp)
-{
-    using RandomAccessIterator = typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type;
-    using value_type =
-        typename std::iterator_traits<RandomAccessIterator>::value_type;
-    using diff_type =
-        typename std::iterator_traits<RandomAccessIterator>::difference_type;
-
-    value_type* max_value = nullptr; // last element in sequence
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
-    {
-        if ((*s).first == (*s).second)
-            continue;
-        value_type& v = *((*s).second - 1);    // last element in sequence
-        if (!max_value || comp(*max_value, v)) // strictly greater
-            max_value = &v;
-    }
-
-    diff_type overhang_size = 0;
-
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
-    {
-        RandomAccessIterator split =
-            std::lower_bound((*s).first, (*s).second, *max_value, comp);
-        overhang_size += (*s).second - split;
-        *((*s).second) = *max_value; // set sentinel
-    }
-
-    // so many elements will be left over afterwards
-    return overhang_size;
-}
-
-/*!
- * Highly efficient 3-way merging procedure.
- *
- * Merging is done with the algorithm implementation described by Peter
- * Sanders.  Basically, the idea is to minimize the number of necessary
- * comparison after merging an element.  The implementation trick that makes
- * this fast is that the order of the sequences is stored in the instruction
- * pointer (translated into labels in C++).
- *
- * This works well for merging up to 3 sequences.
- *
- * Note that making the merging stable does \a not come at a performance hit.
- *
- * Whether the merging is done guarded or unguarded is selected by the used
- * iterator class.
- *
- * \param seqs_begin Begin iterator of iterator pair input sequence.
- * \param seqs_end End iterator of iterator pair input sequence.
- * \param target Begin iterator out output sequence.
- * \param size Maximum size to merge.
- * \param comp Comparator.
- * \return End iterator of output sequence.
- */
-template <template <typename RAI, typename C> class Iterator,
-          typename RandomAccessIteratorIterator, typename RandomAccessIterator3,
-          typename Comparator>
-RandomAccessIterator3 multiway_merge_3_variant(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp)
-{
-    assert(seqs_end - seqs_begin == 3);
-    unused(seqs_end);
-
-    using RandomAccessIterator = typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type;
-
-    if (size == 0)
-        return target;
-
-    Iterator<RandomAccessIterator, Comparator> seq0(seqs_begin[0].first,
-                                                    seqs_begin[0].second, comp),
-        seq1(seqs_begin[1].first, seqs_begin[1].second, comp),
-        seq2(seqs_begin[2].first, seqs_begin[2].second, comp);
-
-    if (seq0 <= seq1)
-    {
-        if (seq1 <= seq2)
-            goto s012;
-        else if (seq2 < seq0)
-            goto s201;
-        else
-            goto s021;
-    }
-    else
-    {
-        if (seq1 <= seq2)
-        {
-            if (seq0 <= seq2)
-                goto s102;
-            else
-                goto s120;
-        }
-        else
-            goto s210;
-    }
-
-#define TLX_MERGE3CASE(a, b, c, c0, c1)                                        \
-    s##a##b##c : * target = *seq##a;                                           \
-    ++target;                                                                  \
-    --size;                                                                    \
-    ++seq##a;                                                                  \
-    if (size == 0)                                                             \
-        goto finish;                                                           \
-    if (seq##a c0 seq##b)                                                      \
-        goto s##a##b##c;                                                       \
-    if (seq##a c1 seq##c)                                                      \
-        goto s##b##a##c;                                                       \
-    goto s##b##c##a;
-
-    TLX_MERGE3CASE(0, 1, 2, <=, <=);
-    TLX_MERGE3CASE(1, 2, 0, <=, <);
-    TLX_MERGE3CASE(2, 0, 1, <, <);
-    TLX_MERGE3CASE(1, 0, 2, <, <=);
-    TLX_MERGE3CASE(0, 2, 1, <=, <=);
-    TLX_MERGE3CASE(2, 1, 0, <, <);
-
-#undef TLX_MERGE3CASE
-
-finish:
-    seqs_begin[0].first = seq0.iterator();
-    seqs_begin[1].first = seq1.iterator();
-    seqs_begin[2].first = seq2.iterator();
-
-    return target;
-}
-
-template <typename RandomAccessIteratorIterator, typename RandomAccessIterator3,
-          typename Comparator>
-RandomAccessIterator3 multiway_merge_3_combined(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp)
-{
-    using RandomAccessIterator = typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type;
-    using DiffType =
-        typename std::iterator_traits<RandomAccessIterator>::difference_type;
-
-    assert(seqs_end - seqs_begin == 3);
-
-    int min_seq;
-    RandomAccessIterator3 target_end;
-    DiffType overhang =
-        prepare_unguarded<true>(seqs_begin, seqs_end, comp, min_seq);
-
-    DiffType total_size = 0;
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
-        total_size += iterpair_size(*s);
-
-    if (overhang != static_cast<DiffType>(-1))
-    {
-        DiffType unguarded_size = std::min(size, total_size - overhang);
-        target_end = multiway_merge_3_variant<unguarded_iterator>(
-            seqs_begin, seqs_end, target, unguarded_size, comp);
-        overhang = size - unguarded_size;
-    }
-    else
-    {
-        // empty sequence found
-        overhang = size;
-        target_end = target;
-    }
-
-    switch (min_seq)
-    {
-    case 0:
-        // iterators will be advanced accordingly
-        target_end = merge_advance(seqs_begin[1].first, seqs_begin[1].second,
-                                   seqs_begin[2].first, seqs_begin[2].second,
-                                   target_end, overhang, comp);
-        break;
-    case 1:
-        target_end = merge_advance(seqs_begin[0].first, seqs_begin[0].second,
-                                   seqs_begin[2].first, seqs_begin[2].second,
-                                   target_end, overhang, comp);
-        break;
-    case 2:
-        target_end = merge_advance(seqs_begin[0].first, seqs_begin[0].second,
-                                   seqs_begin[1].first, seqs_begin[1].second,
-                                   target_end, overhang, comp);
-        break;
-    default:
-        assert(false);
-    }
-
-    return target_end;
-}
-
-/*!
- * Highly efficient 4-way merging procedure.
- *
- * Merging is done with the algorithm implementation described by Peter
- * Sanders. Basically, the idea is to minimize the number of necessary
- * comparison after merging an element.  The implementation trick that makes
- * this fast is that the order of the sequences is stored in the instruction
- * pointer (translated into goto labels in C++).
- *
- * This works well for merging up to 4 sequences.
- *
- * Note that making the merging stable does \a not come at a performance hit.
- *
- * Whether the merging is done guarded or unguarded is selected by the used
- * iterator class.
- *
- * \param seqs_begin Begin iterator of iterator pair input sequence.
- * \param seqs_end End iterator of iterator pair input sequence.
- * \param target Begin iterator out output sequence.
- * \param size Maximum size to merge.
- * \param comp Comparator.
- * \return End iterator of output sequence.
- */
-template <template <typename RAI, typename C> class iterator,
-          typename RandomAccessIteratorIterator, typename RandomAccessIterator3,
-          typename Comparator>
-RandomAccessIterator3 multiway_merge_4_variant(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp)
-{
-    assert(seqs_end - seqs_begin == 4);
-    unused(seqs_end);
-    using RandomAccessIterator = typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type;
-
-    if (size == 0)
-        return target;
-
-    iterator<RandomAccessIterator, Comparator> seq0(seqs_begin[0].first,
-                                                    seqs_begin[0].second, comp),
-        seq1(seqs_begin[1].first, seqs_begin[1].second, comp),
-        seq2(seqs_begin[2].first, seqs_begin[2].second, comp),
-        seq3(seqs_begin[3].first, seqs_begin[3].second, comp);
-
-#define TLX_DECISION(a, b, c, d)                                               \
-    do                                                                         \
-    {                                                                          \
-        if (seq##d < seq##a)                                                   \
-            goto s##d##a##b##c;                                                \
-        if (seq##d < seq##b)                                                   \
-            goto s##a##d##b##c;                                                \
-        if (seq##d < seq##c)                                                   \
-            goto s##a##b##d##c;                                                \
-        goto s##a##b##c##d;                                                    \
-    } while (0)
-
-    if (seq0 <= seq1)
-    {
-        if (seq1 <= seq2)
-            TLX_DECISION(0, 1, 2, 3);
-        else if (seq2 < seq0)
-            TLX_DECISION(2, 0, 1, 3);
-        else
-            TLX_DECISION(0, 2, 1, 3);
-    }
-    else
-    {
-        if (seq1 <= seq2)
-        {
-            if (seq0 <= seq2)
-                TLX_DECISION(1, 0, 2, 3);
-            else
-                TLX_DECISION(1, 2, 0, 3);
-        }
-        else
-            TLX_DECISION(2, 1, 0, 3);
-    }
-
-#define TLX_MERGE4CASE(a, b, c, d, c0, c1, c2)                                 \
-    s##a##b##c##d : * target = *seq##a;                                        \
-    ++target;                                                                  \
-    --size;                                                                    \
-    ++seq##a;                                                                  \
-    if (size == 0)                                                             \
-        goto finish;                                                           \
-    if (seq##a c0 seq##b)                                                      \
-        goto s##a##b##c##d;                                                    \
-    if (seq##a c1 seq##c)                                                      \
-        goto s##b##a##c##d;                                                    \
-    if (seq##a c2 seq##d)                                                      \
-        goto s##b##c##a##d;                                                    \
-    goto s##b##c##d##a;
-
-    TLX_MERGE4CASE(0, 1, 2, 3, <=, <=, <=);
-    TLX_MERGE4CASE(0, 1, 3, 2, <=, <=, <=);
-    TLX_MERGE4CASE(0, 2, 1, 3, <=, <=, <=);
-    TLX_MERGE4CASE(0, 2, 3, 1, <=, <=, <=);
-    TLX_MERGE4CASE(0, 3, 1, 2, <=, <=, <=);
-    TLX_MERGE4CASE(0, 3, 2, 1, <=, <=, <=);
-    TLX_MERGE4CASE(1, 0, 2, 3, <, <=, <=);
-    TLX_MERGE4CASE(1, 0, 3, 2, <, <=, <=);
-    TLX_MERGE4CASE(1, 2, 0, 3, <=, <, <=);
-    TLX_MERGE4CASE(1, 2, 3, 0, <=, <=, <);
-    TLX_MERGE4CASE(1, 3, 0, 2, <=, <, <=);
-    TLX_MERGE4CASE(1, 3, 2, 0, <=, <=, <);
-    TLX_MERGE4CASE(2, 0, 1, 3, <, <, <=);
-    TLX_MERGE4CASE(2, 0, 3, 1, <, <=, <);
-    TLX_MERGE4CASE(2, 1, 0, 3, <, <, <=);
-    TLX_MERGE4CASE(2, 1, 3, 0, <, <=, <);
-    TLX_MERGE4CASE(2, 3, 0, 1, <=, <, <);
-    TLX_MERGE4CASE(2, 3, 1, 0, <=, <, <);
-    TLX_MERGE4CASE(3, 0, 1, 2, <, <, <);
-    TLX_MERGE4CASE(3, 0, 2, 1, <, <, <);
-    TLX_MERGE4CASE(3, 1, 0, 2, <, <, <);
-    TLX_MERGE4CASE(3, 1, 2, 0, <, <, <);
-    TLX_MERGE4CASE(3, 2, 0, 1, <, <, <);
-    TLX_MERGE4CASE(3, 2, 1, 0, <, <, <);
-
-#undef TLX_MERGE4CASE
-#undef TLX_DECISION
-
-finish:
-    seqs_begin[0].first = seq0.iterator();
-    seqs_begin[1].first = seq1.iterator();
-    seqs_begin[2].first = seq2.iterator();
-    seqs_begin[3].first = seq3.iterator();
-
-    return target;
-}
-
-template <typename RandomAccessIteratorIterator, typename RandomAccessIterator3,
-          typename Comparator>
-RandomAccessIterator3 multiway_merge_4_combined(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp)
-{
-    assert(seqs_end - seqs_begin == 4);
-    using RandomAccessIteratorPair =
-        typename std::iterator_traits<RandomAccessIteratorIterator>::value_type;
-    using DiffType = typename std::iterator_traits<
-        RandomAccessIteratorIterator>::difference_type;
-
-    int min_seq;
-    RandomAccessIterator3 target_end;
-    DiffType overhang =
-        prepare_unguarded<true>(seqs_begin, seqs_end, comp, min_seq);
-
-    DiffType total_size = 0;
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
-        total_size += iterpair_size(*s);
-
-    if (overhang != static_cast<DiffType>(-1))
-    {
-        DiffType unguarded_size = std::min(size, total_size - overhang);
-        target_end = multiway_merge_4_variant<unguarded_iterator>(
-            seqs_begin, seqs_end, target, unguarded_size, comp);
-        overhang = size - unguarded_size;
-    }
-    else
-    {
-        // empty sequence found
-        overhang = size;
-        target_end = target;
-    }
-
-    std::vector<RandomAccessIteratorPair> one_missing(seqs_begin, seqs_end);
-    // remove
-    one_missing.erase(one_missing.begin() + min_seq);
-
-    target_end = multiway_merge_3_variant<guarded_iterator>(
-        one_missing.begin(), one_missing.end(), target_end, overhang, comp);
-
-    // insert back again
-    one_missing.insert(one_missing.begin() + min_seq, seqs_begin[min_seq]);
-    // write back modified iterators
-    std::copy(one_missing.begin(), one_missing.end(), seqs_begin);
-
-    return target_end;
-}
-
-/*!
- * Basic multi-way merging procedure.
- *
- * The head elements are kept in a sorted array, new heads are inserted
- * linearly.
- *
- * \param seqs_begin Begin iterator of iterator pair input sequence.
- * \param seqs_end End iterator of iterator pair input sequence.
- * \param target Begin iterator out output sequence.
- * \param size Maximum size to merge.
- * \param comp Comparator.
- * \tparam Stable Stable merging incurs a performance penalty.
- * \return End iterator of output sequence.
- */
-template <bool Stable, typename RandomAccessIteratorIterator,
-          typename RandomAccessIterator3, typename Comparator>
-RandomAccessIterator3 multiway_merge_bubble(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp)
-{
-    using RandomAccessIterator = typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type;
-    using value_type =
-        typename std::iterator_traits<RandomAccessIterator>::value_type;
-    using DiffType =
-        typename std::iterator_traits<RandomAccessIterator>::difference_type;
-
-    // num remaining pieces
-    int num_seqs = static_cast<int>(seqs_end - seqs_begin), nrp;
-
-    simple_vector<value_type> pl(num_seqs);
-    simple_vector<int> source(num_seqs);
-    DiffType total_size = 0;
-
-#define TLX_POS(i) seqs_begin[(i)].first
-#define TLX_STOPS(i) seqs_begin[(i)].second
-
-    // write entries into queue
-    nrp = 0;
-    for (int pi = 0; pi < num_seqs; ++pi)
-    {
-        if (TLX_STOPS(pi) != TLX_POS(pi))
-        {
-            pl[nrp] = *(TLX_POS(pi));
-            source[nrp] = pi;
-            ++nrp;
-            total_size += iterpair_size(seqs_begin[pi]);
-        }
-    }
-
-    if (Stable)
-    {
-        for (int k = 0; k < nrp - 1; ++k)
-            for (int pi = nrp - 1; pi > k; --pi)
-                if (comp(pl[pi], pl[pi - 1]) ||
-                    (!comp(pl[pi - 1], pl[pi]) && source[pi] < source[pi - 1]))
-                {
-                    std::swap(pl[pi - 1], pl[pi]);
-                    std::swap(source[pi - 1], source[pi]);
-                }
-    }
-    else
-    {
-        for (int k = 0; k < nrp - 1; ++k)
-            for (int pi = nrp - 1; pi > k; --pi)
-                if (comp(pl[pi], pl[pi - 1]))
-                {
-                    std::swap(pl[pi - 1], pl[pi]);
-                    std::swap(source[pi - 1], source[pi]);
-                }
-    }
-
-    // iterate
-    if (Stable)
-    {
-        int j;
-        while (nrp > 0 && size > 0)
-        {
-            if (source[0] < source[1])
-            {
-                // pl[0] <= pl[1] ?
-                while ((nrp == 1 || !(comp(pl[1], pl[0]))) && size > 0)
-                {
-                    *target = pl[0];
-                    ++target;
-                    ++TLX_POS(source[0]);
-                    --size;
-                    if (TLX_POS(source[0]) == TLX_STOPS(source[0]))
-                    {
-                        // move everything to the left
-                        for (int s = 0; s < nrp - 1; ++s)
-                        {
-                            pl[s] = pl[s + 1];
-                            source[s] = source[s + 1];
-                        }
-                        --nrp;
-                        break;
-                    }
-                    pl[0] = *(TLX_POS(source[0]));
-                }
-            }
-            else
-            {
-                // pl[0] < pl[1] ?
-                while ((nrp == 1 || comp(pl[0], pl[1])) && size > 0)
-                {
-                    *target = pl[0];
-                    ++target;
-                    ++TLX_POS(source[0]);
-                    --size;
-                    if (TLX_POS(source[0]) == TLX_STOPS(source[0]))
-                    {
-                        for (int s = 0; s < nrp - 1; ++s)
-                        {
-                            pl[s] = pl[s + 1];
-                            source[s] = source[s + 1];
-                        }
-                        --nrp;
-                        break;
-                    }
-                    pl[0] = *(TLX_POS(source[0]));
-                }
-            }
-
-            // sink down
-            j = 1;
-            while ((j < nrp) &&
-                   (comp(pl[j], pl[j - 1]) ||
-                    (!comp(pl[j - 1], pl[j]) && (source[j] < source[j - 1]))))
-            {
-                std::swap(pl[j - 1], pl[j]);
-                std::swap(source[j - 1], source[j]);
-                ++j;
-            }
-        }
-    }
-    else
-    {
-        int j;
-        while (nrp > 0 && size > 0)
-        {
-            // pl[0] <= pl[1] ?
-            while ((nrp == 1 || !comp(pl[1], pl[0])) && size > 0)
-            {
-                *target = pl[0];
-                ++target;
-                ++TLX_POS(source[0]);
-                --size;
-                if (TLX_POS(source[0]) == TLX_STOPS(source[0]))
-                {
-                    for (int s = 0; s < (nrp - 1); ++s)
-                    {
-                        pl[s] = pl[s + 1];
-                        source[s] = source[s + 1];
-                    }
-                    --nrp;
-                    break;
-                }
-                pl[0] = *(TLX_POS(source[0]));
-            }
-
-            // sink down
-            j = 1;
-            while ((j < nrp) && comp(pl[j], pl[j - 1]))
-            {
-                std::swap(pl[j - 1], pl[j]);
-                std::swap(source[j - 1], source[j]);
-                ++j;
-            }
-        }
-    }
-
-#undef TLX_POS
-#undef TLX_STOPS
-
-    return target;
-}
-
-/*!
- * Multi-way merging procedure for a high branching factor, guarded case.
- *
- * The head elements are kept in a loser tree.
- * \param seqs_begin Begin iterator of iterator pair input sequence.
- * \param seqs_end End iterator of iterator pair input sequence.
- * \param target Begin iterator out output sequence.
- * \param size Maximum size to merge.
- * \param comp Comparator.
- * \tparam Stable Stable merging incurs a performance penalty.
- * \return End iterator of output sequence.
- */
-template <typename LoserTreeType, typename RandomAccessIteratorIterator,
-          typename RandomAccessIterator3, typename Comparator>
-RandomAccessIterator3 multiway_merge_loser_tree(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp)
-{
-    using Source = typename LoserTreeType::Source;
-    using size_type = typename LoserTreeType::Source;
-    using RandomAccessIteratorPair =
-        typename std::iterator_traits<RandomAccessIteratorIterator>::value_type;
-    using RandomAccessIterator = typename RandomAccessIteratorPair::first_type;
-    using DiffType =
-        typename std::iterator_traits<RandomAccessIterator>::difference_type;
-
-    const Source k = static_cast<Source>(seqs_end - seqs_begin);
-
-    LoserTreeType lt(static_cast<size_type>(k), comp);
-
-    const DiffType total_size = std::min<DiffType>(
-        size,
-        std::accumulate(seqs_begin, seqs_end, DiffType(0),
-                        [](DiffType sum, const RandomAccessIteratorPair& x) {
-                            return sum + iterpair_size(x);
-                        }));
-
-    for (Source t = 0; t < k; ++t)
-    {
-        if (TLX_UNLIKELY(seqs_begin[t].first == seqs_begin[t].second))
-            lt.insert_start(nullptr, t, true);
-        else
-            lt.insert_start(&*seqs_begin[t].first, t, false);
-    }
-
-    lt.init();
-
-    if (total_size == 0)
-        return target;
-
-    // take out first
-    Source source = lt.min_source();
-
-    *target = *seqs_begin[source].first;
-    ++target;
-    ++seqs_begin[source].first;
-
-    for (DiffType i = 1; i < total_size; ++i)
-    {
-        // feed
-        if (seqs_begin[source].first == seqs_begin[source].second)
-            lt.delete_min_insert(nullptr, true);
-        else
-            // replace from same source
-            lt.delete_min_insert(&*seqs_begin[source].first, false);
-
-        // take out following
-        source = lt.min_source();
-
-        *target = *seqs_begin[source].first;
-        ++target;
-        ++seqs_begin[source].first;
-    }
-
-    return target;
-}
-
-/*!
- * Multi-way merging procedure for a high branching factor, unguarded case.
- * The head elements are kept in a loser tree.
- *
- * \param seqs_begin Begin iterator of iterator pair input sequence.
- * \param seqs_end End iterator of iterator pair input sequence.
- * \param target Begin iterator out output sequence.
- * \param size Maximum size to merge.
- * \param comp Comparator.
- * \tparam Stable Stable merging incurs a performance penalty.
- * \return End iterator of output sequence.
- * \pre No input will run out of elements during the merge.
- */
-template <typename LoserTreeType, typename RandomAccessIteratorIterator,
-          typename RandomAccessIterator3, typename Comparator>
-RandomAccessIterator3 multiway_merge_loser_tree_unguarded(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp)
-{
-    using Source = typename LoserTreeType::Source;
-    using size_type = typename LoserTreeType::Source;
-    using RandomAccessIteratorPair =
-        typename std::iterator_traits<RandomAccessIteratorIterator>::value_type;
-    using RandomAccessIterator = typename RandomAccessIteratorPair ::first_type;
-    using DiffType =
-        typename std::iterator_traits<RandomAccessIterator>::difference_type;
-
-    Source k = static_cast<Source>(seqs_end - seqs_begin);
-
-    // sentinel is item at end of first sequence.
-    LoserTreeType lt(static_cast<size_type>(k), *(seqs_begin->second - 1),
-                     comp);
-
-    DiffType total_size = 0;
-
-    for (Source t = 0; t < k; ++t)
-    {
-        assert(seqs_begin[t].first != seqs_begin[t].second);
-
-        lt.insert_start(&*seqs_begin[t].first, t, false);
-
-        total_size += iterpair_size(seqs_begin[t]);
-    }
-
-    lt.init();
-
-    // do not go past end
-    size = std::min(total_size, size);
-
-    RandomAccessIterator3 target_end = target + size;
-    if (target == target_end)
-        return target;
-
-    // take out first
-    int source = lt.min_source();
-
-    *target = *seqs_begin[source].first;
-    ++seqs_begin[source].first;
-    ++target;
-
-    while (target < target_end)
-    {
-        // feed. replace from same source
-        lt.delete_min_insert(&*seqs_begin[source].first, false);
-
-        // take out following
-        source = lt.min_source();
-
-        *target = *seqs_begin[source].first;
-        ++seqs_begin[source].first;
-        ++target;
-    }
-
-    return target;
-}
-
-template <bool Stable, typename RandomAccessIteratorIterator,
-          typename RandomAccessIterator3, typename Comparator>
-RandomAccessIterator3 multiway_merge_loser_tree_combined(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp)
-{
-    using RandomAccessIterator = typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type;
-    using value_type =
-        typename std::iterator_traits<RandomAccessIterator>::value_type;
-    using DiffType =
-        typename std::iterator_traits<RandomAccessIterator>::difference_type;
-
-    int min_seq;
-    RandomAccessIterator3 target_end;
-    DiffType overhang =
-        prepare_unguarded<Stable>(seqs_begin, seqs_end, comp, min_seq);
-
-    DiffType total_size = 0;
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
-        total_size += iterpair_size(*s);
-
-    if (overhang != static_cast<DiffType>(-1))
-    {
-        DiffType unguarded_size = std::min(size, total_size - overhang);
-        target_end = multiway_merge_loser_tree_unguarded<
-            LoserTreeUnguarded<Stable, value_type, Comparator> >(
-            seqs_begin, seqs_end, target, unguarded_size, comp);
-        overhang = size - unguarded_size;
-    }
-    else
-    {
-        // empty sequence found
-        overhang = size;
-        target_end = target;
-    }
-
-    target_end =
-        multiway_merge_loser_tree<LoserTree<Stable, value_type, Comparator> >(
-            seqs_begin, seqs_end, target_end, overhang, comp);
-
-    return target_end;
-}
-
-template <bool Stable, typename RandomAccessIteratorIterator,
-          typename RandomAccessIterator3, typename Comparator>
-RandomAccessIterator3 multiway_merge_loser_tree_sentinel(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp)
-{
-    using RandomAccessIterator = typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type;
-    using value_type =
-        typename std::iterator_traits<RandomAccessIterator>::value_type;
-
-    // move end of sequences to include the sentinel for merging
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
-        ++(*s).second;
-
-    RandomAccessIterator3 target_end = multiway_merge_loser_tree_unguarded<
-        LoserTreeUnguarded<Stable, value_type, Comparator> >(
-        seqs_begin, seqs_end, target, size, comp);
-
-    // restore end of sequences
-    for (RandomAccessIteratorIterator s = seqs_begin; s != seqs_end; ++s)
-        --(*s).second;
-
-    return target_end;
-}
-
-} // namespace multiway_merge_detail
-
-/******************************************************************************/
-// Multiway Merge Algorithm Switch
-
-/*!
- * Different merging algorithms: bubblesort-alike, loser-tree variants, enum
- * sentinel
- */
-enum MultiwayMergeAlgorithm
-{
-    MWMA_LOSER_TREE,
-    MWMA_LOSER_TREE_COMBINED,
-    MWMA_LOSER_TREE_SENTINEL,
-    MWMA_BUBBLE,
-    MWMA_ALGORITHM_LAST,
-    MWMA_ALGORITHM_DEFAULT = MWMA_LOSER_TREE_COMBINED
-};
-
-/*!
- * Sequential multi-way merging switch.
- *
- * The decision if based on the branching factor and runtime settings.
- *
- * \param seqs_begin Begin iterator of iterator pair input sequence.
- * \param seqs_end End iterator of iterator pair input sequence.
- * \param target Begin iterator out output sequence.
- * \param size Maximum size to merge.
- * \param comp Comparator.
- * \param mwma MultiwayMergeAlgorithm set to use.
- * \tparam Stable Stable merging incurs a performance penalty.
- * \tparam Sentinels The sequences have a sentinel element.
- * \return End iterator of output sequence.
- */
-template <bool Stable, bool Sentinels, typename RandomAccessIteratorIterator,
-          typename RandomAccessIterator3,
-          typename Comparator = std::less<typename std::iterator_traits<
-              typename std::iterator_traits<RandomAccessIteratorIterator>::
-                  value_type::first_type>::value_type> >
-RandomAccessIterator3 multiway_merge_base(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp = Comparator(),
-    MultiwayMergeAlgorithm mwma = MWMA_ALGORITHM_DEFAULT)
-{
-    using RandomAccessIterator = typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type;
-    using value_type =
-        typename std::iterator_traits<RandomAccessIterator>::value_type;
-
-    RandomAccessIterator3 return_target = target;
-    int k = static_cast<int>(seqs_end - seqs_begin);
-
-    if (!Sentinels && mwma == MWMA_LOSER_TREE_SENTINEL)
-        mwma = MWMA_LOSER_TREE_COMBINED;
-
-    using namespace multiway_merge_detail;
-
-    switch (k)
-    {
-    case 0:
-        break;
-    case 1:
-        return_target =
-            std::copy(seqs_begin[0].first, seqs_begin[0].first + size, target);
-        seqs_begin[0].first += size;
-        break;
-    case 2:
-        return_target = merge_advance(seqs_begin[0].first, seqs_begin[0].second,
-                                      seqs_begin[1].first, seqs_begin[1].second,
-                                      target, size, comp);
-        break;
-    case 3:
-        switch (mwma)
-        {
-        case MWMA_LOSER_TREE_COMBINED:
-            return_target = multiway_merge_3_combined(seqs_begin, seqs_end,
-                                                      target, size, comp);
-            break;
-        case MWMA_LOSER_TREE_SENTINEL:
-            return_target = multiway_merge_3_variant<unguarded_iterator>(
-                seqs_begin, seqs_end, target, size, comp);
-            break;
-        default:
-            return_target = multiway_merge_3_variant<guarded_iterator>(
-                seqs_begin, seqs_end, target, size, comp);
-            break;
-        }
-        break;
-    case 4:
-        switch (mwma)
-        {
-        case MWMA_LOSER_TREE_COMBINED:
-            return_target = multiway_merge_4_combined(seqs_begin, seqs_end,
-                                                      target, size, comp);
-            break;
-        case MWMA_LOSER_TREE_SENTINEL:
-            return_target = multiway_merge_4_variant<unguarded_iterator>(
-                seqs_begin, seqs_end, target, size, comp);
-            break;
-        default:
-            return_target = multiway_merge_4_variant<guarded_iterator>(
-                seqs_begin, seqs_end, target, size, comp);
-            break;
-        }
-        break;
-    default: {
-        switch (mwma)
-        {
-        case MWMA_BUBBLE:
-            return_target = multiway_merge_bubble<Stable>(seqs_begin, seqs_end,
-                                                          target, size, comp);
-            break;
-        case MWMA_LOSER_TREE:
-            return_target = multiway_merge_loser_tree<
-                LoserTree<Stable, value_type, Comparator> >(
-                seqs_begin, seqs_end, target, size, comp);
-            break;
-        case MWMA_LOSER_TREE_COMBINED:
-            return_target = multiway_merge_loser_tree_combined<Stable>(
-                seqs_begin, seqs_end, target, size, comp);
-            break;
-        case MWMA_LOSER_TREE_SENTINEL:
-            return_target = multiway_merge_loser_tree_sentinel<Stable>(
-                seqs_begin, seqs_end, target, size, comp);
-            break;
-        default:
-            assert(0 && "multiway_merge algorithm not implemented");
-            break;
-        }
-    }
-    }
-
-    return return_target;
-}
-
-/******************************************************************************/
-// multiway_merge() Frontends
-
-/*!
- * Sequential multi-way merge.
- *
- * \param seqs_begin Begin iterator of iterator pair input sequence.
- * \param seqs_end End iterator of iterator pair input sequence.
- * \param target Begin iterator out output sequence.
- * \param size Maximum size to merge.
- * \param comp Comparator.
- * \param mwma MultiwayMergeAlgorithm set to use.
- * \return End iterator of output sequence.
- */
-template <typename RandomAccessIteratorIterator, typename RandomAccessIterator3,
-          typename Comparator = std::less<typename std::iterator_traits<
-              typename std::iterator_traits<RandomAccessIteratorIterator>::
-                  value_type::first_type>::value_type> >
-RandomAccessIterator3 multiway_merge(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp = Comparator(),
-    MultiwayMergeAlgorithm mwma = MWMA_ALGORITHM_DEFAULT)
-{
-    return multiway_merge_base</* Stable */ false, /* Sentinels */ false>(
-        seqs_begin, seqs_end, target, size, comp, mwma);
-}
-
-/*!
- * Stable sequential multi-way merge.
- *
- * \param seqs_begin Begin iterator of iterator pair input sequence.
- * \param seqs_end End iterator of iterator pair input sequence.
- * \param target Begin iterator out output sequence.
- * \param size Maximum size to merge.
- * \param comp Comparator.
- * \param mwma MultiwayMergeAlgorithm set to use.
- * \return End iterator of output sequence.
- */
-template <typename RandomAccessIteratorIterator, typename RandomAccessIterator3,
-          typename Comparator = std::less<typename std::iterator_traits<
-              typename std::iterator_traits<RandomAccessIteratorIterator>::
-                  value_type::first_type>::value_type> >
-RandomAccessIterator3 stable_multiway_merge(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp = Comparator(),
-    MultiwayMergeAlgorithm mwma = MWMA_ALGORITHM_DEFAULT)
-{
-    return multiway_merge_base</* Stable */ true, /* Sentinels */ false>(
-        seqs_begin, seqs_end, target, size, comp, mwma);
-}
-
-/*!
- * Sequential multi-way merge with sentinels in sequences.
- *
- * \param seqs_begin Begin iterator of iterator pair input sequence.
- * \param seqs_end End iterator of iterator pair input sequence.
- * \param target Begin iterator out output sequence.
- * \param size Maximum size to merge.
- * \param comp Comparator.
- * \param mwma MultiwayMergeAlgorithm set to use.
- * \return End iterator of output sequence.
- */
-template <typename RandomAccessIteratorIterator, typename RandomAccessIterator3,
-          typename Comparator = std::less<typename std::iterator_traits<
-              typename std::iterator_traits<RandomAccessIteratorIterator>::
-                  value_type::first_type>::value_type> >
-RandomAccessIterator3 multiway_merge_sentinels(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp = Comparator(),
-    MultiwayMergeAlgorithm mwma = MWMA_ALGORITHM_DEFAULT)
-{
-    return multiway_merge_base</* Stable */ false, /* Sentinels */ true>(
-        seqs_begin, seqs_end, target, size, comp, mwma);
-}
-
-/*!
- * Stable sequential multi-way merge with sentinels in sequences.
- *
- * \param seqs_begin Begin iterator of iterator pair input sequence.
- * \param seqs_end End iterator of iterator pair input sequence.
- * \param target Begin iterator out output sequence.
- * \param size Maximum size to merge.
- * \param comp Comparator.
- * \param mwma MultiwayMergeAlgorithm set to use.
- * \return End iterator of output sequence.
- */
-template <typename RandomAccessIteratorIterator, typename RandomAccessIterator3,
-          typename Comparator = std::less<typename std::iterator_traits<
-              typename std::iterator_traits<RandomAccessIteratorIterator>::
-                  value_type::first_type>::value_type> >
-RandomAccessIterator3 stable_multiway_merge_sentinels(
-    RandomAccessIteratorIterator seqs_begin,
-    RandomAccessIteratorIterator seqs_end, RandomAccessIterator3 target,
-    typename std::iterator_traits<typename std::iterator_traits<
-        RandomAccessIteratorIterator>::value_type::first_type>::difference_type
-        size,
-    Comparator comp = Comparator(),
-    MultiwayMergeAlgorithm mwma = MWMA_ALGORITHM_DEFAULT)
-{
-    return multiway_merge_base</* Stable */ true, /* Sentinels */ true>(
-        seqs_begin, seqs_end, target, size, comp, mwma);
-}
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_ALGORITHM_MULTIWAY_MERGE_HEADER
-
-/******************************************************************************/