#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;


template<typename Iterator>
struct skip_iterator {
  using iterator_category = typename Iterator::iterator_category;
  //using iterator_category = std::input_iterator_tag;
  using value_type = typename Iterator::value_type;
  using difference_type = typename Iterator::difference_type;
  using pointer = typename Iterator::pointer;
  using reference = typename Iterator::reference;
 Iterator _begin, _end;
 std::function<bool(value_type const &)> _predicate;
 using self_t = skip_iterator<Iterator>;

 bool operator==(self_t const & rhs) {
  return (_begin == rhs._begin);
 }
 bool operator!=(self_t const & rhs) {
  return not (*this == rhs);
 }

 reference operator*(void) {
  return *_begin;
 }

 void skip_to_next(void) {
  for(; _begin != _end; ++_begin) {
   if (not _predicate(*_begin)) {
    break;
   }
  }
 }

 skip_iterator (Iterator b, Iterator e,  std::function<bool(value_type const &)> p)
  : _begin (b), _end (e), _predicate (p) {
  skip_to_next ();
 }
 self_t end(void) {
  return {_end, _end, _predicate};
 }
 self_t & operator++(void) {
  skip_to_next();
  return *this;
 }
 difference_type operator-(self_t const & rhs) {
  return _begin - rhs._begin;
 }
 self_t operator+(difference_type inc) {
  return {_begin + inc, _end, _predicate};
 }
 self_t operator-(difference_type inc) {
  return {_begin - inc, _end, _predicate};
 }
 bool operator<(self_t const & rhs) {
  return _begin < rhs._begin;
 }
};

template<typename Iterator, typename Predicate>
auto make_skip_iterator (Iterator f, Iterator t, Predicate p) {
 return skip_iterator<Iterator>{f, t, p};
}

int main() {
 vector<int> input{1, 2, 3, 4, 5, 6, 8, 10, 11, 13};
 auto f = input.begin();
 auto t = input.end();
 auto from = make_skip_iterator (f, t, [](auto e) { return e % 2 == 0; });
 auto to = from.end ();
 sort(from, to, greater<int>{});
 for (auto e : input) {
  cout << e << " ";
 }
 cout << endl;
 return 0;
}