import java.math.BigInteger;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.OutputStream;

public class Alien {

    static final int MOD=1<<20;

    static long powmod(long x, long y) {
     long res = 1;      // Initialize result

     x = x % MOD;  // Update x if it is more than or
     // equal to p

     while (y > 0)
         {
          // If y is odd, multiply x with result
          if ((y & 1) != 0)
              res = (res*x) % MOD;

          // y must be even now
          y = y>>1; // y = y/2
          x = (x*x) % MOD;
         }
     return res;

    }

    static long col_sum(int i, int X, long [] fi_tbl) {
     long fi = fi_tbl[i];
     long res=fi;
     long prev = fi;
     long add_this = fi_tbl[X-1];

     for(int ii = 0; ii <X-1; ++ii) {
         prev = (prev * powmod(33, X) + add_this) % MOD;
         res += prev; res %= MOD;
     }
     return res;
    }

    // 107005050|00005252- construct right, construct left, multiply
    static BigInteger FastBigInt(String x) {
     int size = x.length();
     if (size <= 5) {
         return new BigInteger(x);
     }
     int last_half = size/2;
     int last_half_size = size - last_half;
     BigInteger lo = FastBigInt(x.substring(last_half,
                                last_half + last_half_size)); // last half
     BigInteger hi = FastBigInt(x.substring(0, last_half)); // first half
     return lo.add(BigInteger.TEN.pow(last_half_size).multiply(hi));
    }

    public static void main(String [] args) throws IOException{
     Kattio io = new Kattio(System.in, System.out);
     int K, X;
     K = io.getInt(); X = io.getInt();
     String msg = io.r.readLine();
     //System.out.println(msg);



     // should be a bit more?
     long[] fi_tbl = new long[X];
     fi_tbl[0] = 1;
     for (int i=1; i<X; i++) {
         fi_tbl[i] = (33*fi_tbl[i-1] + 1) % MOD;
     }

     long l0 = col_sum(0, X, fi_tbl);
     long l1 = col_sum(1, X, fi_tbl);

     long abez = 1016801;
     long B = ((l1 - l0) * abez) % MOD;
     long A = l0 - B;

     long[] all_col_sums = new long[X];
     for (int i=0; i<X; i++) {
         //System.out.println(A + "  " +  B + " " + fi_tbl[i]);
         all_col_sums[i] = (((A + B*fi_tbl[i]) % MOD) + MOD) % MOD;
         //System.out.println(all_col_sums[i]);
     }

     //System.out.println("did compute col sums");

     StringBuilder s=new StringBuilder();
     for (long x: all_col_sums)
         s.append(""+x);
     // System.out.println("did build string");
     //BigInteger b= new BigInteger(s.toString());
     BigInteger b = FastBigInt(s.toString());

     //System.out.println("did build integer");


     String base27Java = b.toString(27);

     //System.out.println("did convert to base");

     StringBuilder buildRes = new StringBuilder();
     for (int i=0; i<msg.length(); i++) {
         int x = msg.charAt(i);
         x -= 'A';
         if (x < 0) x = 26; // space
         char y = base27Java.charAt(i);
         int yy = y >= 'a' ? y-'a' + 10 : y-'0';
         int res = (x+yy) % 27;
         char c = (char)(res + 'A');
         if (c > 'Z') c = ' ';
         buildRes.append(c);
     }
     io.println(buildRes.toString());
     io.close();

     //for (long x: all_col_sums)

    }

}

/** Simple yet moderately fast I/O routines.
 *
 * Example usage:
 *
 * Kattio io = new Kattio(System.in, System.out);
 *
 * while (io.hasMoreTokens()) {
 *    int n = io.getInt();
 *    double d = io.getDouble();
 *    double ans = d*n;
 *
 *    io.println("Answer: " + ans);
 * }
 *
 * io.close();
 *
 *
 * Some notes:
 *
 * - When done, you should always do io.close() or io.flush() on the
 *   Kattio-instance, otherwise, you may lose output.
 *
 * - The getInt(), getDouble(), and getLong() methods will throw an
 *   exception if there is no more data in the input, so it is generally
 *   a good idea to use hasMoreTokens() to check for end-of-file.
 *
 * @author: Kattis
 */


class Kattio extends PrintWriter {
    public Kattio(InputStream i) {
        super(new BufferedOutputStream(System.out));
        r = new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(InputStream i, OutputStream o) {
        super(new BufferedOutputStream(o));
        r = new BufferedReader(new InputStreamReader(i));
    }

    public boolean hasMoreTokens() {
        return peekToken() != null;
    }

    public int getInt() {
        return Integer.parseInt(nextToken());
    }

    public double getDouble() {
        return Double.parseDouble(nextToken());
    }

    public long getLong() {
        return Long.parseLong(nextToken());
    }

    public String getWord() {
        return nextToken();
    }



    public BufferedReader r;
    private String line;
    private StringTokenizer st;
    private String token;

    private String peekToken() {
        if (token == null)
            try {
                while (st == null || !st.hasMoreTokens()) {
                    line = r.readLine();
                    if (line == null) return null;
                    st = new StringTokenizer(line);
                }
                token = st.nextToken();
            } catch (IOException e) { }
        return token;
    }

    private String nextToken() {
        String ans = peekToken();
        token = null;
        return ans;
    }
}