#include <string>
#include <vector>
#include <cstdint>
#include <exception>
#include <unordered_map>
#include <iostream>
#include <cctype>

class sequence
{
    size_t _size;
    std::vector<uint8_t> _data;

public:
    enum step { up, down, left, right };

    struct _step_wrapper
    {
        uint8_t& _data;
        int _position;

        _step_wrapper(uint8_t& data, int position): _data(data), _position(position) { /* Nothing to do */ }

        operator step() const {return step((_data >> _position) & 3); }
        const step& operator=(const step& s) const { _data = (_data & ~(0x3 << _position)) | (s << _position); return s; }
    };


    sequence(size_t n): _size(n), _data( (n + 3) / 4, 0){ /*Nothing to do */ }
    sequence(): sequence(0) { /*Nothing to do */ };

    size_t size() const { return _size; }

    _step_wrapper operator[](size_t i) {
        return _step_wrapper(_data[i / 4], (i % 4) * 2);
    }

    //TODO: make enumerator interface
};

std::istream& operator>>(std::istream& is, const sequence::_step_wrapper& rhs)
{
    using namespace std::string_literals;

    char c = ' ';

    while (std::isspace(c))
        is >> c;

    switch (c)
    {
        case '^': rhs = sequence::up; break;
        case 'v': rhs = sequence::down; break;
        case '<': rhs = sequence::left; break;
        case '>': rhs = sequence::right; break;
        default:
            throw std::invalid_argument("Invalid sequence char "s + c);
    }

    return is;
}

std::ostream& operator<<(std::ostream& os, const sequence::_step_wrapper& rhs)
{
    switch (rhs)
    {
        case sequence::up: os << "^"; break;
        case sequence::down: os << "v"; break;
        case sequence::left: os << "<"; break;
        case sequence::right: os << ">"; break;
    }

    return os;
}


bool inizializza_sequenza(size_t n, sequence& old_sequence)
{
    //allocation of [n/4] bytes
    sequence new_seq(n);

    try
    {
        for (size_t i = 0; i != n; i++)
            std::cin >> new_seq[i];

        //no allocation or copy here, old_seq is deallocated
        old_sequence = std::move(new_seq);
        return true;
    }
    catch (const std::invalid_argument&)
    {
        return false;
    }
}

bool inizializza_sequenza(size_t n, std::vector<char>& old_sequence)
{
    using namespace std::string_literals;

    //allocation of n bytes
    std::vector<char> new_seq;
    new_seq.resize(n);

    for (size_t i = 0; i != n; i++)
    {
        char c;
        std::cin >> c;

        switch (c)
        {
            case '^':
            case 'v':
            case '<':
            case '>': new_seq[i] = c; break;
            default:
                std::cerr << "Invalid sequence char '"s + c + "'\n"s;
                return false;
        }
    }

    old_sequence = std::move(new_seq);
    return true;
}

bool inizializza_sequenza(size_t n, char*& old_sequence)
{
    using namespace std::string_literals;

    //allocation of n bytes
    char* new_seq = new char[n];

    for (size_t i = 0; i != n; i++)
    {
        char c;
        std::cin >> c;

        switch (c)
        {
            case '^':
            case 'v':
            case '<':
            case '>': new_seq[i] = c; break;
            default:
                std::cerr << "Invalid sequence char '"s + c + "'\n"s;
                return false;
        }
    }

    delete [] old_sequence;
    old_sequence = new_seq;
    return true;
}


#ifdef T1
typedef sequence sequence_t;
#elif T2
typedef std::vector<char> sequence_t;
#else
#define T3
typedef char* sequence_t;
#endif


int main()
{
    using namespace std::string_literals;

    size_t new_size = 7;

    #ifdef T3
    sequence_t cur_seq = nullptr;
    #else
    sequence_t cur_seq;
    #endif

    bool is_new = inizializza_sequenza(7, cur_seq);

    #ifdef T3
    new_size = is_new ? new_size : 0;
    #else
    (void)is_new;
    new_size = cur_seq.size();
    #endif

    std::cout << "There are "s << new_size << " element(s) in the sequence:\n"s;
    for (unsigned int i = 0; i != new_size; i++)
        std::cout << cur_seq[i] << " ";
    std::cout << "\n";

    return 0;
}