#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

// using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


#ifndef LIBRA_OTHER_INT128_H_
#define LIBRA_OTHER_INT128_H_

#include <stdio.h>
#include <iostream>

constexpr unsigned __int128 toUInt128(const char *s) {
  unsigned __int128 x = 0;
  for (; *s; ++s) x = x * 10 + (*s - '0');
  return x;
}
constexpr __int128 toInt128(const char *s) {
  if (*s == '-') return -toInt128(s + 1);
  __int128 x = 0;
  for (; *s; ++s) x = x * 10 + (*s - '0');
  return x;
}
unsigned __int128 inUInt128() {
  static char buf[41];
  scanf("%s", buf);
  return toUInt128(buf);
}
__int128 inInt128() {
  static char buf[41];
  scanf("%s", buf);
  return toInt128(buf);
}

void out(unsigned __int128 x) {
  static char buf[41];
  int len = 0;
  do { buf[len++] = '0' + static_cast<int>(x % 10); } while (x /= 10);
  for (int i = len; --i >= 0; ) putchar(buf[i]);
}
void out(__int128 x) {
  if (x < 0) {
    putchar('-');
    out(-static_cast<unsigned __int128>(x));
  } else {
    out(static_cast<unsigned __int128>(x));
  }
}
std::ostream &operator<<(std::ostream &os, unsigned __int128 x) {
  static char buf[41];
  int len = 0;
  do { buf[len++] = '0' + static_cast<int>(x % 10); } while (x /= 10);
  for (int i = len; --i >= 0; ) os << buf[i];
  return os;
}
std::ostream &operator<<(std::ostream &os, __int128 x) {
  if (x < 0) {
    os << '-' << -static_cast<unsigned __int128>(x);
  } else {
    os << static_cast<unsigned __int128>(x);
  }
  return os;
}

#endif  // LIBRA_OTHER_INT128_H_

using INT = __int128;

unsigned xrand() {
  static unsigned x = 314159265, y = 358979323, z = 846264338, w = 327950288;
  unsigned t = x ^ x << 11; x = y; y = z; z = w; return w = w ^ w >> 19 ^ t ^ t >> 8;
}


constexpr int E = 71;

vector<int> encode(const string &S, int N, const vector<int> &A) {
  INT key = 0;
  for (const char s : S) {
    key *= 26;
    key += 1;
    key += (s - 'a');
  }
  assert(key < (INT)1 << E);
  const int K = N / E;
  vector<int> B;
  for (int e = 0; e < E; ++e) {
    const int want = key >> e & 1;
    const int l = K * e;
    const int r = K * (e + 1);
    vector<int> pre(K + 1, 0), suf(K + 1, 0);
    for (int k = 0; k < K; ++k) pre[k + 1] = pre[k] + ((A[l + k] % 3 == want) ? 1 : 0);
    for (int k = K; --k >= 0; ) suf[k] = ((A[l + k] % 3 == 2) ? 1 : 0) + suf[k + 1];
    int mx = -1;
    int km = -1;
    for (int k = 0; k <= K; ++k) {
      if (chmax(mx, min(pre[k], suf[k]))) {
        km = k;
      }
    }
    for (int k = 0; k < km; ++k) if (A[l + k] % 3 == want) B.push_back(A[l + k]);
    for (int k = km; k < K; ++k) if (A[l + k] % 3 == 2) B.push_back(A[l + k]);
  }
  return B;
}

string decode(int M, const vector<int> &B) {
  vector<int> xs;
  for (int i = 0; i < M; ++i) {
    xs.push_back(B[i] % 3);
  }
  xs.erase(unique(xs.begin(), xs.end()), xs.end());
// cerr<<xs<<endl;
  assert((int)xs.size() == 2 * E);
  INT key = 0;
  for (int e = 0; e < E; ++e) {
    key |= (INT)xs[2 * e] << e;
  }
  string S;
  for (; key; ) {
    --key;
    S += (char)('a' + key % 26);
    key /= 26;
  }
  reverse(S.begin(), S.end());
  return S;
}

int main() {
  char name[110];
  for (; ~scanf("%s", name); ) {
    if (!strcmp(name, "Alisa")) {
      char S[110];
      scanf("%s", S);
      int N;
      scanf("%d", &N);
      vector<int> A(N);
      for (int i = 0; i < N; ++i) {
        scanf("%d", &A[i]);
      }
      const auto B = encode(S, N, A);
      const int BLen = B.size();
      printf("%d\n", BLen);
      for (int i = 0; i < BLen; ++i) {
        if (i) printf(" ");
        printf("%d", B[i]);
      }
      puts("");
    } else if (!strcmp(name, "Eva")) {
      int M;
      scanf("%d", &M);
      vector<int> B(M);
      for (int i = 0; i < M; ++i) {
        scanf("%d", &B[i]);
      }
      const string S = decode(M, B);
      puts(S.c_str());
    } else {
      assert(false);
    }
#ifndef LOCAL
break;
#endif
  }
  return 0;
}