#include <vector>
#define PROBLEM "https://yukicoder.me/problems/no/1469"
#include <iostream>

#include <ranges>
#include <vector>
namespace mtd {  template <std::ranges::range _R>  class RunLengthEncoding {    using T = std::iter_value_t<std::ranges::iterator_t<_R>>;    const std::vector<std::tuple<T, int>> r;    static constexpr auto construct_rle(const _R& r) {      std::vector<std::tuple<T, int>> rle;      if (r.empty()) { return rle; }      T now = *r.begin();      int cnt = 1;      for (const auto& x : r | std::views::drop(1)) {        if (x == now) {          ++cnt;        } else {          rle.emplace_back(now, cnt);          cnt = 1;          now = x;        }      }      rle.emplace_back(now, cnt);      return rle;    }  public:    constexpr RunLengthEncoding(const _R& r) : r(construct_rle(r)) {}    constexpr auto begin() const { return r.begin(); }    constexpr auto end() const { return r.end(); }  };}  
#include <iostream>
#include <ranges>
#include <type_traits>
#include <vector>
namespace mtd {  namespace io {    namespace type {      template <class T, int Pre = 1, int Size = 0>      struct vec {        using value_type = T;        static constexpr int pre = Pre;        static constexpr int size = Size;      };      template <class T>      concept is_vec = requires {        std::is_same_v<T, vec<typename T::value_type, T::pre, T::size>>;      };    }      template <type::is_vec T>    auto _input(int n) {      std::vector<typename T::value_type> v(n);      for (auto i : std::views::iota(0, n)) { std::cin >> v[i]; }      return v;    }    template <class T>    auto _input() {      T x;      std::cin >> x;      return x;    }    template <int N, class Tuple, class T, class... Args>    auto _tuple_input(Tuple& t) {      if constexpr (type::is_vec<T>) {        if constexpr (T::size == 0) {          std::get<N>(t) = _input<T>(std::get<N - T::pre>(t));        } else {          std::get<N>(t) = _input<T>(T::size);        }      } else {        std::get<N>(t) = _input<T>();      }      if constexpr (sizeof...(Args) > 0) {        _tuple_input<N + 1, Tuple, Args...>(t);      }    }    template <class T>    struct _Converter {      using type = T;    };    template <class T, int Pre, int Size>    struct _Converter<type::vec<T, Pre, Size>> {      using type = std::vector<T>;    };    template <class... Args>    auto in() {      auto base = std::tuple<typename _Converter<Args>::type...>();      _tuple_input<0, decltype(base), Args...>(base);      return base;    }  }  }  
#include <ranges>
namespace mtd {  namespace ranges {    constexpr int _inf = 1e9;    template <class... Args>    struct istream_view        : public std::ranges::view_interface<istream_view<Args...>> {      class iterator {        int count;        std::tuple<typename io::_Converter<Args>::type...> val;      public:        using difference_type = int;        using value_type = decltype(val);        using iterator_concept = std::input_iterator_tag;        constexpr iterator() = default;        constexpr explicit iterator(int count) : count(count) { operator++(); }        constexpr auto operator*() const { return val; }        constexpr auto& operator++() {          --count;          if (count >= 0) { val = io::in<Args...>(); }          return *this;        }        constexpr auto operator++(int) { return ++*this; }        constexpr auto operator==(const iterator& s) const {          return count == s.count;        }        constexpr auto operator==(std::default_sentinel_t s) const {          return count < 0 || std::cin.eof() || std::cin.fail() ||                 std::cin.bad();        }        constexpr friend auto operator==(std::default_sentinel_t s,                                         const iterator& li) {          return li == s;        }      };      int count;    public:      constexpr explicit istream_view(int count) : count(count) {}      constexpr explicit istream_view() : istream_view(_inf) {}      constexpr auto begin() const { return iterator(count); }      constexpr auto end() const { return std::default_sentinel; }    };  }    namespace views {    namespace __detail {      template <typename... _Args>      concept __can_istream_view = requires {        ranges::istream_view(std::declval<_Args>()...);      };    }      template <class... Args>    struct _Istream {      template <class... _Tp>      requires __detail::__can_istream_view<_Tp...>      constexpr auto operator() [[nodiscard]] (_Tp&&... __e) const {        return ranges::istream_view<Args...>(std::forward<_Tp>(__e)...);      }    };    template <class... Args>    inline constexpr _Istream<Args...> istream{};  }  }  

int main() {
  std::cin.tie(0);
  std::ios::sync_with_stdio(0);

  auto [s] = mtd::io::in<std::string>();
  auto rle = mtd::RunLengthEncoding(s);
  for (auto [c, _] : rle) { std::cout << c; }
  std::cout << std::endl;
}