#include <iostream>
//#include <set>
#include <unordered_set>
#include <stdio.h>

void WordFind(std::string &s) {
    for (auto &c : s)
        if (c+1 >'z')
            c='a';
        else
            c+=1;
}

int main() {
//    std::set<std::string> Decrypt{};
    std::unordered_set<std::string> Decrypt{};
    int Wordlen=1000000;
    int N = 0;
    char *Word = new char[Wordlen];

    while (scanf("%s", Word) ) {
        if (isdigit(Word[0])) {
            N = atoi(Word);
            break;
        }
        Decrypt.insert(std::string(Word));
    }

    for (int j = 0; j < N; j++) {
        scanf("%s", Word);
        std::string s{Word};
        for (int i = 0; i < 'z'-'a'+1; i++) {
            WordFind(s);
            if (Decrypt.count(s) != 0)
                printf("%s\n", s.c_str());
        }
    }

    delete Word;
    return 0;
}

-----------------------------------2----------------------------
Amount = int(input())
Boxes=[]
Counter=0
for i in range(Amount):
    Box=input().split()
    Boxes.append((lambda x,y: (int(x),int(y)) if int(x)>int(y) else (int(y),int(x)))(*Box))
Boxes=sorted(Boxes,key=lambda x:(x[0],-x[1]),reverse=True)
CurMax=0
for x,y in Boxes:
    if y>=CurMax:
        Counter+=1
        CurMax=y
print(Counter)

--------------------------------3--------------------------
from math import sqrt

class Graph:
    def __init__(self, Cf):
        self.a, self.b, self.c = Cf

    def getRes(self,pt):
        return self.a*pt**2 + self.b*pt + self.c

    def getInt(self, Lft, Rgt):
        return self.a * (Rgt**3 - Lft ** 3) / 3 + self.b * (Rgt**2 - Lft**2) / 2 + self.c * (Rgt - Lft)

    def __sub__(self, other):
        return Graph((self.a - other.a, self.b - other.b, self.c - other.c))

    def __str__(self):
        return str(self.x) + " * x^2 + " + str(self.y) + " * x +" + str(self.z)

    def GetPoints(self):
        Discr = self.b ** 2 - 4 * self.a * self.c
        if self.a==0:
            if self.b==0:
                return []
            else:
                return [-self.c/self.b]
        if Discr > 0:
            x1, x2 = (-self.b - sqrt(Discr)) / (2 * self.a), (-self.b + sqrt(Discr)) / (2 * self.a)
            return [x1, x2] if x1 < x2 else [x2, x1]
        elif Discr == 0:
            return [self.b / 2 * self.a]
        else:
            return []

def TestPoint(Funks,Int):
    return (Funks[0],Funks[1]) if Funks[0].getRes((Int[1]+Int[0])/2)>= Funks[1].getRes((Int[1]+Int[0])/2) else (Funks[1],Funks[0])


def NewInt(Points,Min,Max):
    Res=[Min,Max]
    for elem in Points:
        if elem>Res[0] and elem < Res[-1]:
            Res.insert(-1,elem)
    return Res



# print(NewInt([],1,4))
N, M = map(int, input().split())
ResSum,PosN,PosM=0,0,0
Tmp = []
NPoints = list(map(float, input().split()))
NFuncks = []
Sum=0
for i in range(N):
    NFuncks.append(Graph(tuple(map(int, input().split()))))
# NFuncs.append({i for i in range Graph(tuple(map(int, input().split())))})
MPoints = list(map(float, input().split()))
MFuncks = []
for i in range(M):
    MFuncks.append(Graph(tuple(map(int, input().split()))))

while PosN!=N and PosM!=M:
    Min,Max=max(NPoints[PosN],MPoints[PosM]),min(NPoints[PosN+1],MPoints[PosM+1])
    FunN,FunM=NFuncks[PosN],MFuncks[PosM]
    Int=NewInt((FunM-FunN).GetPoints(),Min,Max)
    for pos in range(len(Int)-1):
        # Funks=TestPoint([FunN,FunM],[Int[pos],Int[pos+1]])
        Sum+=abs((FunN-FunM).getInt(Int[pos],Int[pos+1]))
    if Max==MPoints[PosM+1]:
        PosM+=1
        if Max==NPoints[PosN+1]:
            PosN+=1
    else:
         PosN+=1
print("{:.8}".format(Sum))

--------------------------------------5----------------------------------
#include <random>
#include <set>
#include <map>

class segmtree {
    int n, *t;

    void buikd_tree(const std::vector<int> &from, int v, int tl, int tr) {
        if (tl == tr)
            t[v] = from[tl];
        else {
            int tm = (tl + tr) / 2;
            buikd_tree(from, v * 2, tl, tm);
            buikd_tree(from, v * 2 + 1, tm + 1, tr);
            t[v] = t[v * 2] + t[v * 2 + 1];
        }
    }

    int rec_sum(int v, int topl, int topr, int left, int right {
        if (left > right)
            return 0;
        if (left == topl && right == topr)
            return t[v];
        int tm = (topl + topr) / 2;
        return rec_sum(v * 2, topl, tm, left, std::min(right, tm)) + rec_sum(v * 2 + 1, tm + 1, topr, std::max(left, tm + 1), right);
    }

    void rec_update(int v, int tl, int tr, int pos, int new_val) {
        if (tl == tr)
            t[v] = new_val;
        else {
            int tm = (tl + tr) / 2;
            if (pos <= tm)
                rec_update(v * 2, tl, tm, pos, new_val);
            else
                rec_update(v * 2 + 1, tm + 1, tr, pos, new_val);
            t[v] = t[v * 2] + t[v * 2 + 1];
        }
    }


public:
    segmtree(const std::vector<int> &a) {
        n = a.size();
        t = new int[4 * n];
        buikd_tree(a, 1, 0, n - 1);
    }

    int sum(int l, int r) {
        return rec_sum(1, 0, n - 1, l, r);
    }

    void update(int pos, int val) {
        rec_update(1, 0, n - 1, pos, val);
    }
};

class tree {
public:
    int y, value, tree_size;
    tree *left, *right;

    tree(int y = 0, int value = 0, tree *l = nullptr, tree *r = nullptr, int size = 1) : y(y), value(value),
                                                                                         left(l),
                                                                                         right(r), tree_size(size) {}
};


tree *pre_alocate_trees = nullptr;
int new_tree_ind = 0;

tree *get_new_tree(int y = 0, int value = 0, tree *l = nullptr, tree *r = nullptr, int size = 1) {
    tree *new_node = &pre_alocate_trees[new_tree_ind];
    new_node->y = y;
    new_node->value = value;
    new_node->left = l;
    new_node->right = r;
    new_node->tree_size = size;
    new_tree_ind++;
    return new_node;
}

int size_of_tree(tree *t) {
    if (t)
        return t->tree_size;
    else
        return 0;
}

void update_size(tree *t) {
    t->tree_size = size_of_tree(t->left) + size_of_tree(t->right) + 1;
}

void split_tree(tree *t, int pos, tree *&l, tree *&r) {
    if (t == nullptr) {
        l = r = nullptr;
        return;
    }
    if (size_of_tree(t->left) < pos) {
        split_tree(t->right, pos - size_of_tree(t->left) - 1, t->right, r);
        l = t;
    } else {
        split_tree(t->left, pos, l, t->left);
        r = t;
    }
    update_size(t);
}

tree *merge_trees(tree *l, tree *r) {
    if (l == nullptr) { return r; }
    if (r == nullptr) { return l; }
    if (l->y > r->y) {
        l->right = merge_trees(l->right, r);
        update_size(l);
        return l;
    } else {
        r->left = merge_trees(l, r->left);
        update_size(r);
        return r;
    }
}

tree *erase(tree *t, int pos, int &val) {
    tree *l, *m, *r;
    split_tree(t, pos, l, r);
    split_tree(r, 1, m, r);
    val = m->value;
    return merge_trees(l, r);
}

tree *insert(tree *t, int value, int pos) {
    tree *l, *r;
    split_tree(t, pos, l, r);
    tree *m = get_new_tree(std::rand(), value);
    return merge_trees(merge_trees(l, m), r);
}

void delete_nodes() {
    delete[] pre_alocate_trees;
}




int main() {
    int n, m, type;
    scanf("%d%d%d", &n, &m, &type);
//    std::cin >> n >> m >> type;
    if (type == 1) {
        std::vector<int> x{};
        std::vector<int> k_val{};
        std::map<int, int> pos{};

        for (int i = 0; i < m; i++) {
            x.push_back(m - i);
            k_val.push_back(1);
            pos[m - i] = i;
        }

        int in;
        for (int i = 0; i < n; i++) {
            scanf("%d", &in);
            x.push_back(in);
            k_val.push_back(0);
        }

        segmtree tree(k_val);
        for (int i = m; i < n + m; i++) {
            printf("%d ", tree.sum(pos[x[i]], i));
            tree.update(pos[x[i]], 0);
            tree.update(i, 1);
            pos[x[i]] = i;
        }
    }
    else if (type == 2) {
        pre_alocate_trees = new tree[1000006];
        tree *perm = {};
        for (int i = 0; i < m; i++)
            perm = insert(perm, i + 1, i);

        for (int i = 0; i < n; i++) {
            int val;
            scanf("%d", &val);
            int new_val;
            perm = erase(perm, val - 1, new_val);
            printf("%d ", new_val);
            perm = insert(perm, new_val, 0);
        }
        delete_nodes();
    }
    return 0;
}