/*
lib:        https://github.com/old-yan/CP-template
author:     oldyan
*/
#include <algorithm>
#include <bit>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <iostream>
#include <limits>
#include <numeric>
#include <string>
#include <vector>
#ifndef __OY_FASTIO__
#define __OY_FASTIO__
#define cin OY::IO::InputHelper::get_instance()
#define cout OY::IO::OutputHelper::get_instance()
#define endl '\n'
#ifndef INPUT_FILE
#define INPUT_FILE "in.txt"
#endif
#ifndef OUTPUT_FILE
#define OUTPUT_FILE "out.txt"
#endif
namespace OY {
    namespace IO {
        using size_type = size_t;
        static constexpr size_type INPUT_BUFFER_SIZE = 1 << 16, OUTPUT_BUFFER_SIZE = 1 << 16, MAX_INTEGER_SIZE = 20, MAX_FLOAT_SIZE = 50;
#ifdef OY_LOCAL
        static constexpr char input_file[] = INPUT_FILE, output_file[] = OUTPUT_FILE;
#else
        static constexpr char input_file[] = "", output_file[] = "";
#endif
        struct InputHelper {
            FILE *m_file_ptr;
            char m_buf[INPUT_BUFFER_SIZE], *m_end, *m_cursor;
            bool m_ok;
            InputHelper &set_bad() { return m_ok = false, *this; }
            template <size_type BlockSize>
            void _reserve() {
                size_type a = m_end - m_cursor;
                if (a >= BlockSize) return;
                memmove(m_buf, m_cursor, a), m_cursor = m_buf;
                size_type b = a + fread(m_buf + a, 1, INPUT_BUFFER_SIZE - a, m_file_ptr);
                if (b < INPUT_BUFFER_SIZE) m_end = m_buf + b, *m_end = EOF;
            }
            template <typename Tp, typename BinaryOperation>
            InputHelper &fill_integer(Tp &ret, BinaryOperation op) {
                if (!isdigit(*m_cursor)) return set_bad();
                ret = op(Tp(0), *m_cursor - '0');
                size_type len = 1;
                while (isdigit(*(m_cursor + len))) ret = op(ret * 10, *(m_cursor + len++) - '0');
                m_cursor += len;
                return *this;
            }
            explicit InputHelper(const char *inputFileName) : m_ok(true), m_cursor(m_buf + INPUT_BUFFER_SIZE), m_end(m_buf + INPUT_BUFFER_SIZE) { m_file_ptr = *inputFileName ? fopen(inputFileName, "rt") : stdin; }
            ~InputHelper() { fclose(m_file_ptr); }
            static InputHelper &get_instance() {
                static InputHelper s_obj(input_file);
                return s_obj;
            }
            static bool is_blank(char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; }
            static bool is_endline(char c) { return c == '\n' || c == EOF; }
            const char &getchar_checked() {
                _reserve<1>();
                return *m_cursor;
            }
            const char &getchar_unchecked() const { return *m_cursor; }
            void next() { ++m_cursor; }
            template <typename Tp, typename std::enable_if<std::is_signed<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
            InputHelper &operator>>(Tp &num) {
                while (is_blank(getchar_checked())) next();
                _reserve<MAX_INTEGER_SIZE>();
                if (getchar_unchecked() != '-') return fill_integer(num, std::plus<Tp>());
                next();
                return fill_integer(num, std::minus<Tp>());
            }
            template <typename Tp, typename std::enable_if<std::is_unsigned<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
            InputHelper &operator>>(Tp &num) {
                while (is_blank(getchar_checked())) next();
                _reserve<MAX_INTEGER_SIZE>();
                return fill_integer(num, std::plus<Tp>());
            }
            template <typename Tp, typename std::enable_if<std::is_floating_point<Tp>::value>::type * = nullptr>
            InputHelper &operator>>(Tp &num) {
                bool neg = false, integer = false, decimal = false;
                while (is_blank(getchar_checked())) next();
                _reserve<MAX_FLOAT_SIZE>();
                if (getchar_unchecked() == '-') {
                    neg = true;
                    next();
                }
                if (!isdigit(getchar_unchecked()) && getchar_unchecked() != '.') return set_bad();
                if (isdigit(getchar_unchecked())) {
                    integer = true;
                    num = getchar_unchecked() - '0';
                    while (next(), isdigit(getchar_unchecked())) num = num * 10 + (getchar_unchecked() - '0');
                }
                if (getchar_unchecked() == '.')
                    if (next(), isdigit(getchar_unchecked())) {
                        if (!integer) num = 0;
                        decimal = true;
                        Tp unit = 0.1;
                        num += unit * (getchar_unchecked() - '0');
                        while (next(), isdigit(getchar_unchecked())) num += (unit *= 0.1) * (getchar_unchecked() - '0');
                    }
                if (!integer && !decimal) return set_bad();
                if (neg) num = -num;
                return *this;
            }
            InputHelper &operator>>(char &c) {
                while (is_blank(getchar_checked())) next();
                if (getchar_checked() == EOF) return set_bad();
                c = getchar_checked(), next();
                return *this;
            }
            InputHelper &operator>>(std::string &s) {
                while (is_blank(getchar_checked())) next();
                if (getchar_checked() == EOF) return set_bad();
                s.clear();
                do {
                    s += getchar_checked();
                    next();
                } while (!is_blank(getchar_checked()) && getchar_unchecked() != EOF);
                return *this;
            }
            explicit operator bool() { return m_ok; }
        };
        struct OutputHelper {
            FILE *m_file_ptr = nullptr;
            char m_buf[OUTPUT_BUFFER_SIZE], *m_end, *m_cursor;
            char m_temp_buf[MAX_FLOAT_SIZE], *m_temp_buf_cursor, *m_temp_buf_dot;
            uint64_t m_float_reserve, m_float_ratio;
            void _write() { fwrite(m_buf, 1, m_cursor - m_buf, m_file_ptr), m_cursor = m_buf; }
            template <size_type BlockSize>
            void _reserve() {
                size_type a = m_end - m_cursor;
                if (a >= BlockSize) return;
                _write();
            }
            OutputHelper(const char *outputFileName, size_type prec = 6) : m_cursor(m_buf), m_end(m_buf + OUTPUT_BUFFER_SIZE), m_temp_buf_cursor(m_temp_buf) { m_file_ptr = *outputFileName ? fopen(outputFileName, "wt") : stdout, precision(prec); }
            static OutputHelper &get_instance() {
                static OutputHelper s_obj(output_file);
                return s_obj;
            }
            ~OutputHelper() { flush(), fclose(m_file_ptr); }
            void precision(size_type prec) { m_float_reserve = prec, m_float_ratio = uint64_t(pow(10, prec)), m_temp_buf_dot = m_temp_buf + prec; }
            OutputHelper &flush() { return _write(), fflush(m_file_ptr), *this; }
            void putchar(const char &c) {
                if (m_cursor == m_end) _write();
                *m_cursor++ = c;
            }
            template <typename Tp, typename std::enable_if<std::is_signed<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
            OutputHelper &operator<<(Tp ret) {
                _reserve<MAX_INTEGER_SIZE>();
                size_type len = 0;
                if (ret >= 0)
                    do *(m_cursor + len++) = '0' + ret % 10, ret /= 10;
                    while (ret);
                else {
                    putchar('-');
                    do *(m_cursor + len++) = '0' - ret % 10, ret /= 10;
                    while (ret);
                }
                for (size_type i = 0, j = len - 1; i < j;) std::swap(*(m_cursor + i++), *(m_cursor + j--));
                m_cursor += len;
                return *this;
            }
            template <typename Tp, typename std::enable_if<std::is_unsigned<Tp>::value & std::is_integral<Tp>::value>::type * = nullptr>
            OutputHelper &operator<<(Tp ret) {
                _reserve<MAX_INTEGER_SIZE>();
                size_type len = 0;
                do *(m_cursor + len++) = '0' + ret % 10, ret /= 10;
                while (ret);
                for (size_type i = 0, j = len - 1; i < j;) std::swap(*(m_cursor + i++), *(m_cursor + j--));
                m_cursor += len;
                return *this;
            }
            template <typename Tp, typename std::enable_if<std::is_floating_point<Tp>::value>::type * = nullptr>
            OutputHelper &operator<<(Tp ret) {
                if (ret < 0) {
                    putchar('-');
                    return *this << -ret;
                }
                ret *= m_float_ratio;
                uint64_t integer = ret;
                if (ret - integer >= 0.4999999999) integer++;
                do {
                    *m_temp_buf_cursor++ = '0' + integer % 10;
                    integer /= 10;
                } while (integer);
                if (m_temp_buf_cursor > m_temp_buf_dot) {
                    do putchar(*--m_temp_buf_cursor);
                    while (m_temp_buf_cursor > m_temp_buf_dot);
                    putchar('.');
                } else {
                    putchar('0'), putchar('.');
                    for (size_type i = m_temp_buf_dot - m_temp_buf_cursor; i--;) putchar('0');
                }
                do putchar(*--m_temp_buf_cursor);
                while (m_temp_buf_cursor > m_temp_buf);
                return *this;
            }
            OutputHelper &operator<<(const char &ret) {
                putchar(ret);
                return *this;
            }
            OutputHelper &operator<<(const char *ret) {
                while (*ret) putchar(*ret++);
                return *this;
            }
            OutputHelper &operator<<(const std::string &ret) { return *this << ret.data(); }
        };
        InputHelper &getline(InputHelper &ih, std::string &line) {
            line.clear();
            if (ih.getchar_checked() == EOF) return ih.set_bad();
            while (!InputHelper::is_endline(ih.getchar_checked())) line += ih.getchar_unchecked(), ih.next();
            if (ih.getchar_unchecked() != EOF) ih.next();
            return ih;
        }
    }
}
using OY::IO::getline;
#endif 
#ifndef __OY_BISUFFIXTREE__
#define __OY_BISUFFIXTREE__
namespace OY {
    namespace BISUFTREE {
        using size_type = uint32_t;
        template <typename Node>
        struct BaseNodeWrap : Node {};
        template <size_type ChildCount>
        struct StaticChildGetter {
            size_type m_child[ChildCount];
            void set_child(size_type index, size_type child) { m_child[index] = child; }
            size_type get_child(size_type index) const { return m_child[index]; }
            void copy_children(const StaticChildGetter<ChildCount> &rhs) { std::copy_n(rhs.m_child, ChildCount, m_child); }
        };
        template <typename Tp, template <typename> typename NodeWrap, typename ChildGetter, size_type MAX_LEN>
        struct Tree {
            static constexpr size_type inf = std::numeric_limits<size_type>::max() / 2;
            struct node : NodeWrap<ChildGetter> {
                size_type m_length, m_parent, m_fail;
                Tp *m_ptr;
                ChildGetter m_trans;
            };
            std::vector<node> m_data;
            Tp m_seq[MAX_LEN * 2], *m_first, *m_last;
            size_type m_now, m_remain, m_lst1, m_lst2, m_leaf;
            uint64_t m_unique_cnt;
            size_type _newnode(size_type length, Tp *ptr) {
                m_data.push_back({});
                m_data.back().m_length = length, m_data.back().m_ptr = ptr;
                return m_data.size() - 1;
            }
            void _link(size_type child, size_type parent) {
                m_data[child].m_parent = parent;
                m_data[parent].set_child(m_data[child].m_ptr[m_data[parent].m_length], child);
            }
            void _init() {
                m_now = m_remain = m_lst1 = m_lst2 = m_leaf = m_unique_cnt = 0;
                m_first = m_last = m_seq + MAX_LEN;
                m_data.clear(), m_data.resize(1), m_data[0].m_fail = m_data[0].m_parent = -1;
            }
            Tree() { _init(); }
            void reserve(size_type length) { m_data.clear(), m_data.reserve(length * 2 + 1), _init(); }
            void clear() { m_data.clear(), _init(); }
            size_type size() const { return m_last - m_first; }
            size_type leaf_count() const { return m_leaf; }
            uint64_t unique_count() const { return m_unique_cnt; }
            bool empty() const { return m_first == m_last; }
            void push_back(const Tp &elem) {
                *m_last = elem, m_remain++;
                size_type lst = 0;
                while (m_remain) {
                    if (m_remain <= m_data[m_now].m_length ? m_data[m_now].m_ptr[m_remain - 1] == elem : m_data[m_now].get_child(elem)) break;
                    if (m_remain <= m_data[m_now].m_length) {
                        size_type u = _newnode(m_remain - 1, m_data[m_now].m_ptr);
                        m_data[u].m_trans.copy_children(m_data[m_now].m_trans);
                        _link(u, m_data[m_now].m_parent), _link(m_now, u);
                        m_now = u;
                    }
                    size_type x = _newnode(inf, m_last - m_remain + 1);
                    _link(x, m_now);
                    m_remain--, m_leaf++;
                    if (lst)
                        m_data[lst].m_fail = m_now, m_data[m_now].m_trans.set_child(*m_data[lst].m_ptr, lst);
                    else if (m_lst2)
                        m_data[m_now].m_trans.set_child(*m_data[m_lst2].m_ptr, m_lst2);
                    if (m_lst2) m_data[x].m_trans.set_child(*m_data[m_lst2].m_ptr, m_lst2);
                    lst = m_now, m_lst2 = x;
                    if (!m_now)
                        m_data[0].m_trans.set_child(*m_data[x].m_ptr, x);
                    else {
                        if (!m_data[m_now].m_parent)
                            m_data[0].m_trans.set_child(*m_data[lst].m_ptr, lst), m_now = 0;
                        else
                            m_now = m_data[m_data[m_now].m_parent].m_fail;
                        if (m_data[m_now].m_length < m_remain - 1)
                            while (m_now = m_data[m_now].get_child((m_last - m_remain)[m_data[m_now].m_length + 1]), m_data[m_now].m_length < m_remain - 1) m_data[m_now].m_trans.set_child(*m_data[lst].m_ptr, lst);
                    }
                }
                if (lst) m_data[lst].m_fail = m_now, m_data[m_now].m_trans.set_child(*m_data[lst].m_ptr, lst);
                if (!m_lst1) m_lst1 = m_data[0].get_child(elem);
                if (m_remain > m_data[m_now].m_length) m_now = m_data[m_now].get_child(elem);
                if (m_remain == m_data[m_now].m_length) m_data[m_now].m_trans.set_child(*m_data[m_lst2].m_ptr, m_lst2);
                m_last++, m_unique_cnt += m_leaf;
            }
            void push_front(const Tp &elem) {
                auto old_Ans = m_unique_cnt;
                *--m_first = elem;
                size_type p = m_lst1, x;
                while (~p && !m_data[p].m_trans.get_child(elem)) p = m_data[p].m_parent;
                if (!~p)
                    x = _newnode(inf, m_first), m_unique_cnt += m_remain + ++m_leaf;
                else if ((m_data[p].m_length == m_remain ? p : m_data[p].get_child(m_data[m_lst1].m_ptr[m_data[p].m_length])) == m_now && m_data[m_lst1].m_ptr[m_leaf - 1] == elem) {
                    x = m_lst2, m_data[x].m_length = inf, m_data[x].m_ptr = m_first;
                    if (x != m_lst1) {
                        m_lst2 = m_data[x].m_trans.get_child(m_data[m_lst1].m_ptr[m_leaf - 2]);
                        m_data[x].m_trans.set_child(m_data[m_lst1].m_ptr[m_leaf - 2], 0);
                    }
                    m_remain++, m_now = x, m_unique_cnt += m_leaf;
                } else
                    x = _newnode(inf, m_first), m_unique_cnt += m_leaf++ + m_remain - m_data[p].m_length;
                if (x != m_lst1) {
                    for (p = m_lst1; ~p && !m_data[p].m_trans.get_child(elem); p = m_data[p].m_parent) m_data[p].m_trans.set_child(elem, x);
                    if (!~p)
                        _link(x, 0);
                    else if (m_data[p].m_trans.get_child(elem) != x) {
                        size_type t = m_data[p].m_trans.get_child(elem);
                        if (m_data[t].m_length == m_data[p].m_length + 1)
                            _link(x, t);
                        else {
                            size_type u = _newnode(m_data[p].m_length + 1, m_data[t].m_ptr);
                            m_data[u].m_fail = p;
                            m_data[u].m_trans.copy_children(m_data[t].m_trans);
                            _link(u, m_data[t].m_parent), _link(t, u), _link(x, u);
                            for (; ~p && m_data[p].m_trans.get_child(elem) == t; p = m_data[p].m_parent) m_data[p].m_trans.set_child(elem, u);
                            if (m_now == t) {
                                if (m_remain <= m_data[u].m_length) m_now = u;
                                if (m_data[u].m_length <= m_remain) m_data[u].m_trans.set_child(*m_data[m_lst2].m_ptr, m_lst2);
                            }
                        }
                    }
                }
                m_lst1 = x;
                if (!m_lst2) m_lst2 = m_lst1;
            }
            const node *get_node(size_type node_index) const { return &m_data[node_index]; }
            node *get_node(size_type node_index) { return &m_data[node_index]; }
        };
    }
    template <typename Tp, template <typename> typename NodeWrap = BISUFTREE::BaseNodeWrap, BISUFTREE::size_type ChildCount = 26, BISUFTREE::size_type MAX_LEN = 1 << 20>
    using StaticBiSufTree_string = BISUFTREE::Tree<Tp, NodeWrap, BISUFTREE::StaticChildGetter<ChildCount>, MAX_LEN>;
}
#endif
/*
lib code is above
temp code is below
*/
void solve_BiSTree() {
    using BiSTree = OY::StaticBiSufTree_string<uint8_t, OY::BISUFTREE::BaseNodeWrap, 26, 200000>;
    BiSTree st;
    uint32_t n, type;
    cin >> n >> type;
    st.reserve(n);
    if (type) {
        uint32_t lst = 0;
        for (uint32_t i = 0; i < n; i++) {
            std::string s;
            char c;
            cin >> s >> c;
            if (s.size() == 9)
                st.push_back((c - 'a' + lst) % 26);
            else
                st.push_front((c - 'a' + lst) % 26);
            lst = st.unique_count();
            cout << lst << endl;
        }
    } else
        for (uint32_t i = 0; i < n; i++) {
            std::string s;
            char c;
            cin >> s >> c;
            if (s.size() == 9)
                st.push_back(c - 'a');
            else
                st.push_front(c - 'a');
            cout << st.unique_count() << endl;
        }
}
int main() {
    solve_BiSTree();
}