#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define all(a) a.begin(), a.end()
ll ceildiv(ll a, ll b) { return a / b + (a % b && (a ^ b) >= 0); }

using u64 = unsigned long long;

u64 reverse(u64 x) {
  u64 ret = 0;
  rep(i, 0, 8) { ret |= (x >> (i * 8) & 255) << (7 - i) * 8; }
  return ret;
}

u64 enc(u64 x) {
  u64 r = 0;
  bool sep = false;
  rep(p, 0, 4) {
    const u64 w = u64(1) << (3 - p) * 16;
    const u64 c = ((u64(1) << (3 - p) * 16) + (u64(1) << (3 - p) * 8)) / 2;
    if (!sep) {
      rep(i, 0, 256) {
        if (x < w * u64(i)) {
          r |= u64(i) << (7 - p) * 8;
          r |= (x / w) << p * 8;
          x %= w;
          sep = true;
          break;
        }
        x -= w * u64(i);
        if (x < c) {
          r |= u64(i) << (7 - p) * 8;
          r |= u64(i) << p * 8;
          break;
        }
        x -= c;
      }
    } else {
      r |= u64(x / w / 256) << (7 - p) * 8;
      r |= u64(x / w % 256) << p * 8;
      x %= w;
    }
  }
  return r;
}

u64 dec(const u64 x) {
  const auto get = [&](int p) { return x >> p & 255; };
  u64 r = 0;
  bool sep = false;
  rep(p, 0, 4) {
    const u64 w = u64(1) << (3 - p) * 16;
    const u64 c = ((u64(1) << (3 - p) * 16) + (u64(1) << (3 - p) * 8)) / 2;
    if (!sep) {
      const u64 lim = get((7 - p) * 8);
      rep(i, 0, lim) {
        r += w * u64(i);
        r += c;
      }
      const u64 l2 = get(p * 8);
      r += w * l2;
      if (lim > l2)
        sep = true;
    } else {
      r += w * 256 * get((7 - p) * 8);
      r += w * get(p * 8);
    }
  }
  return r;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  string s;
  cin >> s;
  if (s == "encode") {
    int n;
    cin >> n;
    vector<u64> bt(63 * 1024);
    rep(i, 0, n) {
      u64 t;
      cin >> t;
      rep(j, 0, 64) bt[i * 64 + j] = t >> j & 1;
    }
    bt[n * 64] = 1;
    cout << 1024 << "\n";
    rep(i, 0, 1024) {
      u64 x = 0;
      rep(j, 0, 63) x |= bt[i * 63 + j] << j;
      cout << enc(x) << " \n"[i + 1 == 1024];
    }
  } else {
    int n;
    cin >> n;
    assert(n == 1024);
    vector<u64> bt(63 * 1024);
    rep(i, 0, 1024) {
      u64 x;
      cin >> x;
      x = dec(max(x, reverse(x)));
      rep(j, 0, 63) bt[i * 63 + j] = x >> j & 1;
    }
    vector<u64> ans(2000);
    rep(i, 0, bt.size()) { ans[i / 64] |= bt[i] << (i % 64); }
    while (ans.back() == 0)
      ans.pop_back();
    ans.pop_back();
    rep(i, 0, ans.size()) cout << ans[i] << " \n"[i + 1 == ans.size()];
  }
  return 0;
}