#include <iostream>
using namespace std;

class uniq_range_combinator
{
public:
        using range_value_t = int;
        using range_t = range<range_value_t>;

        template <typename X>
        using list_t = std::list<X>;

        uniq_range_combinator() = default;

        template<typename FwdIt>
        list_t<std::vector<range_t>>&& operator()(FwdIt first, FwdIt last, size_t len)
        {
                len_ = len;

                size_t ksz = std::distance(first, last);
                std::vector<range_t> res;
                res.reserve(ksz);

                while(first != last)
                {
                        const range_t& el = *first++;
                        backtrack(first, last, el, 0, res);
                        res.pop_back();
                }

                return std::move(output_);
        }

private:
        template<typename FwdIt>
        void backtrack(FwdIt first, FwdIt last, const range_t& el,
                       size_t len, std::vector<range_t>& res)
        {
                res.push_back(el);
                len += el.length();

                if(len == len_)
                {
                        output_.push_back(res);
                        return;
                }

                while(first != last /* && len < len_ */)
                {
                        const range_t& next = *first++;
                        size_t nl = len + next.length();

                        if(el.overlap(next) or nl > len_)
                                continue;

                        backtrack(first, last, next, len, res);
                        res.pop_back();
                }
        }

private:
        list_t<std::vector<range_t>> output_;
        size_t len_;
};

int main() {
	// your code goes here
	return 0;
}