#include <bits/stdc++.h>
using namespace std;
const int INF = 1791791791;
const long long INFLL = 1791791791791791791ll;
template <int input_buf_size, int output_buf_size>
class FastIO {
  char cbuf[input_buf_size + 1];
  int icur = 0;
  inline bool go_to_next_token() {
    while (cbuf[icur] == ' ' || cbuf[icur] == '\n') icur++;
    while (cbuf[icur] == 0) {
      icur = 0;
      if (fgets(cbuf, sizeof(cbuf), stdin) != cbuf) return false;
      while (cbuf[icur] == ' ' || cbuf[icur] == '\n') icur++;
    }
    return true;
  }

 public:
  string readString() {
    assert(go_to_next_token());
    string ans;
    while (cbuf[icur] != ' ' && cbuf[icur] != '\n' && cbuf[icur] != 0)
      ans.push_back(cbuf[icur++]);
    ans.shrink_to_fit();
    return ans;
  }
  template <class int_type>
  int_type readInt() {
    assert(go_to_next_token());
    int_type x = 0;
    bool m = cbuf[icur] == '-';
    if (m) icur++;
    while ('0' <= cbuf[icur] && cbuf[icur] <= '9') {
      x *= 10;
      x += (cbuf[icur] - '0');
      icur++;
    }
    if (m) x = -x;
    return x;
  }
  bool seekEof() { return !go_to_next_token(); }

 private:
  char obuf[output_buf_size + 1];
  int ocur = 0;
  inline void write_string(const char* str, size_t sz = 0) {
    if (sz == 0) sz = strlen(str);
    if (ocur + sz > output_buf_size) {
      fputs(obuf, stdout);
      fputs(str, stdout);
      ocur = 0;
      obuf[0] = 0;
      return;
    }
    strcpy(obuf + ocur, str);
    ocur += sz;
    obuf[ocur] = 0;
  }

 public:
  template <class int_type>
  void writeInt(int_type x, bool sp = true) {
    char buf[20];
    int c = 0;
    if (x < 0) {
      buf[c++] = '-';
      x = -x;
    }
    int s = c;
    if (x == 0) {
      buf[c++] = '0';
    }
    while (x > 0) {
      buf[c++] = (x % 10) + '0';
      x /= 10;
    }
    for (int i = 0; 2 * i < c - s; i++) {
      swap(buf[s + i], buf[c - 1 - i]);
    }
    buf[c] = 0;
    write_string(buf, c);
    if (sp) write_string(" ", 1);
  }
  void writeString(string s, bool space = true) {
    write_string(s.c_str(), s.size());
    if (space) write_string(" ", 1);
  }
  void writeEndl() { write_string("\n", 1); }
  void flush() {
    fputs(obuf, stdout);
    ocur = 0;
    obuf[0] = 0;
  }

 private:
  bool lflush;

 public:
  FastIO(bool local_flush) {
    obuf[0] = 0;
    lflush = local_flush;
  }
  ~FastIO() { fputs(obuf, stdout); }
};
FastIO<10000000, 10000000> IO(true);
const int maxn = 100179;
const long long MOD = 1000000007;
long long fpow(long long x, int n, long long m) {
  if (n == 0)
    return 1;
  else if (n % 2 == 1)
    return (x * fpow(x, n - 1, m)) % m;
  else {
    long long t = fpow(x, n / 2, m);
    return (t * t) % m;
  }
}
long long div(long long x, long long y, long long m) {
  return (x * fpow(y, m - 2, m)) % m;
}
long long fct[maxn];
long long revfct[maxn];
long long cnk(int n, int k) {
  return (fct[n] * ((revfct[k] * revfct[n - k]) % MOD)) % MOD;
}
struct query {
  int n;
  long long& whans;
  query(int _n, long long& _whans) : n(_n), whans(_whans) {}
};
long long pow25[maxn];
long long pow26[maxn];
void solve_for_m(int m, vector<query> qs) {
  vector<long long> forl(maxn);
  for (int n = (int)(m); n < ((int)(maxn)); ++n) {
    forl[n] =
        (pow25[n - m] * ((cnk(n - 1, m - 1) * pow26[maxn - n]) % MOD) % MOD);
  }
  vector<long long> ps(maxn + 1);
  ps[0] = 0;
  for (int i = (int)(1); i < ((int)(maxn + 1)); ++i) {
    ps[i] = (ps[i - 1] + forl[i - 1]) % MOD;
  }
  for (query& q : qs) {
    q.whans = div(((((ps[q.n + 1] - ps[m]) % (MOD)) + (MOD)) % (MOD)),
                  pow26[maxn - q.n], MOD);
  }
}
int main() {
  fct[0] = 1;
  for (int i = (int)(1); i < ((int)(maxn)); ++i)
    fct[i] = (i * fct[i - 1]) % MOD;
  for (int i = 0; i < ((int)(maxn)); ++i) revfct[i] = div(1, fct[i], MOD);
  pow25[0] = 1;
  for (int i = (int)(1); i < ((int)(maxn)); ++i)
    pow25[i] = (pow25[i - 1] * 25) % MOD;
  pow26[0] = 1;
  for (int i = (int)(1); i < ((int)(maxn)); ++i)
    pow26[i] = (pow26[i - 1] * 26) % MOD;
  int t = IO.readInt<int>();
  map<int, vector<query> > qs;
  string trash = IO.readString();
  vector<long long> ans(t, -1);
  for (int i = 0; i < ((int)(t)); ++i) {
    int type = IO.readInt<int>();
    if (type == 1)
      trash = IO.readString();
    else {
      int n = IO.readInt<int>();
      qs[trash.size()].push_back(query(n, ans[i]));
    }
  }
  for (auto p : qs) {
    solve_for_m(p.first, p.second);
  }
  for (int i = 0; i < ((int)(t)); ++i)
    if (ans[i] != -1) {
      IO.writeInt(ans[i]);
      IO.writeEndl();
    }
  return 0;
}
