Decrypt

import java.io.*;
import java.util.*;

/**
 * Created by migho on 6.9.2016.
 */
public class Main {

    //nopqrstuvwxyzabcdefghijklm

    //tbbqvqrn

    public static void main(String[] argv) {
        IO io = new IO();

        // characters
        char[] f = io.next().toCharArray();

        //rounds
        int k = io.nextInt();

        //encrypted message
        char[] encryptedString = io.next().toCharArray();

        char[] alphabet = "abcdefghijklmnopqrstuvwxyz".toCharArray();

        validate(f.clone());
        
        Hashtable<Character, Character> data = new Hashtable<>();
        for(int i = 0; i < f.length; i++) {
            data.put(f[i], alphabet[i]);
        }
        for(int i = 0; i < k; i++) {
            for(int j = 0; j < encryptedString.length; j++) {
                encryptedString[j] = data.get(encryptedString[j]);
            }
        }
        System.out.println(new String(encryptedString));
    }

    private static void validate(char[] c) {
        Arrays.sort(c);
        char cur = c[0];
        for(int i = 1; i < c.length; i++) {
            if(cur == c[i]) {
                System.out.println("impossible");
                System.exit(0);
            }
            cur = c[i];
        }
    }

    private static class IO extends PrintWriter {
        private InputStreamReader r;
        private static final int BUFSIZE = 1 << 15;
        private char[] buf;
        private int bufc;
        private int bufi;
        private StringBuilder sb;

        public IO() {
            super(new BufferedOutputStream(System.out));
            r = new InputStreamReader(System.in);

            buf = new char[BUFSIZE];
            bufc = 0;
            bufi = 0;
            sb = new StringBuilder();
        }

        private void fillBuf() throws IOException {
            bufi = 0;
            bufc = 0;
            while(bufc == 0) {
                bufc = r.read(buf, 0, BUFSIZE);
                if(bufc == -1) {
                    bufc = 0;
                    return;
                }
            }
        }

        private boolean pumpBuf() throws IOException {
            if(bufi == bufc) {
                fillBuf();
            }
            return bufc != 0;
        }

        private boolean isDelimiter(char c) {
            return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
        }

        private void eatDelimiters() throws IOException {
            while(true) {
                if(bufi == bufc) {
                    fillBuf();
                    if(bufc == 0) throw new RuntimeException("IO: Out of input.");
                }

                if(!isDelimiter(buf[bufi])) break;
                ++bufi;
            }
        }

        public String next() {
            try {
                sb.setLength(0);

                eatDelimiters();
                int start = bufi;

                while(true) {
                    if(bufi == bufc) {
                        sb.append(buf, start, bufi - start);
                        fillBuf();
                        start = 0;
                        if(bufc == 0) break;
                    }

                    if(isDelimiter(buf[bufi])) break;
                    ++bufi;
                }

                sb.append(buf, start, bufi - start);

                return sb.toString();
            } catch(IOException e) {
                throw new RuntimeException("IO.next: Caught IOException.");
            }
        }

        public int nextInt() {
            try {
                int ret = 0;

                eatDelimiters();

                boolean positive = true;
                if(buf[bufi] == '-') {
                    ++bufi;
                    if(!pumpBuf()) throw new RuntimeException("IO.nextInt: Invalid int.");
                    positive = false;
                }

                boolean first = true;
                while(true) {
                    if(!pumpBuf()) break;
                    if(isDelimiter(buf[bufi])) {
                        if(first) throw new RuntimeException("IO.nextInt: Invalid int.");
                        break;
                    }
                    first = false;

                    if(buf[bufi] >= '0' && buf[bufi] <= '9') {
                        if(ret < -214748364) throw new RuntimeException("IO.nextInt: Invalid int.");
                        ret *= 10;
                        ret -= (int)(buf[bufi] - '0');
                        if(ret > 0) throw new RuntimeException("IO.nextInt: Invalid int.");
                    } else {
                        throw new RuntimeException("IO.nextInt: Invalid int.");
                    }

                    ++bufi;
                }

                if(positive) {
                    if(ret == -2147483648) throw new RuntimeException("IO.nextInt: Invalid int.");
                    ret = -ret;
                }

                return ret;
            } catch(IOException e) {
                throw new RuntimeException("IO.nextInt: Caught IOException.");
            }
        }

        public long nextLong() {
            try {
                long ret = 0;

                eatDelimiters();

                boolean positive = true;
                if(buf[bufi] == '-') {
                    ++bufi;
                    if(!pumpBuf()) throw new RuntimeException("IO.nextLong: Invalid long.");
                    positive = false;
                }

                boolean first = true;
                while(true) {
                    if(!pumpBuf()) break;
                    if(isDelimiter(buf[bufi])) {
                        if(first) throw new RuntimeException("IO.nextLong: Invalid long.");
                        break;
                    }
                    first = false;

                    if(buf[bufi] >= '0' && buf[bufi] <= '9') {
                        if(ret < -922337203685477580L) throw new RuntimeException("IO.nextLong: Invalid long.");
                        ret *= 10;
                        ret -= (long)(buf[bufi] - '0');
                        if(ret > 0) throw new RuntimeException("IO.nextLong: Invalid long.");
                    } else {
                        throw new RuntimeException("IO.nextLong: Invalid long.");
                    }

                    ++bufi;
                }

                if(positive) {
                    if(ret == -9223372036854775808L) throw new RuntimeException("IO.nextLong: Invalid long.");
                    ret = -ret;
                }

                return ret;
            } catch(IOException e) {
                throw new RuntimeException("IO.nextLong: Caught IOException.");
            }
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }

}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: TIME LIMIT EXCEEDED

Test 4

Verdict: WRONG ANSWER

Test 5

Verdict: ACCEPTED

Test 6

Verdict: ACCEPTED

Test 7

Verdict: WRONG ANSWER

Test 8

Verdict: ACCEPTED

Test 9

Verdict: TIME LIMIT EXCEEDED

Test 10

Verdict: WRONG ANSWER

Test 11

Verdict: ACCEPTED

Test 12

Verdict: ACCEPTED

Test 13

Verdict: WRONG ANSWER

Test 14

Verdict: ACCEPTED

Test 15

Verdict: TIME LIMIT EXCEEDED

Test 16

Verdict: WRONG ANSWER

Test 17

Verdict: ACCEPTED

Test 18

Verdict: ACCEPTED

Test 19

Verdict: ACCEPTED

Test 20

Verdict: ACCEPTED

Test 21

Verdict: TIME LIMIT EXCEEDED

Test 22

Verdict: WRONG ANSWER

Test 23

Verdict: ACCEPTED

Test 24

Verdict: ACCEPTED

Test 25

Verdict: ACCEPTED

Test 26

Verdict: ACCEPTED

Test 27

Verdict: TIME LIMIT EXCEEDED

Test 28

Verdict: WRONG ANSWER

Test 29

Verdict: ACCEPTED

Test 30

Verdict: ACCEPTED