from sys import stdin
input = stdin.readline
from types import GeneratorType

def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        to = f(*args, **kwargs)
        while True:
            if type(to) is GeneratorType:
                stack.append(to)
                to = next(to)
            else:
                stack.pop()
                if not stack:
                    break
                to = stack[-1].send(to)
        return to
    return wrappedfunc

class Trie:
    def __init__(self, N, type):
        self.tree = [[-1]*26 for _ in range(N+1)]
        self.arrive = [0]*(N+1)
        self.last = [0]*(N+1)
        self.nex = 1
        if type == 0:
            self.base = ord("a")
        else:
            self.base = ord("A")
    
    def insert(self, S):
        now = 0
        self.arrive[now] += 1
        for s in S:
            if self.tree[now][ord(s)-self.base] == -1:
                self.tree[now][ord(s)-self.base] = self.nex
                now = self.nex
                self.nex += 1
            else:
                now = self.tree[now][ord(s)-self.base]
            self.arrive[now] += 1
        self.last[now] += 1
    
    def search(self, S):
        now = 0
        for s in S:
            if self.tree[now][ord(s)-self.base] == -1:
                return 0
            now = self.tree[now][ord(s)-self.base]
        return self.last[now]
    
    def start_with(self, S):
        now = 0
        for s in S:
            if self.tree[now][ord(s)-self.base] == -1:
                return 0
            now = self.tree[now][ord(s)-self.base]
        return self.arrive[now]

    def count(self):
        return self.arrive[0]

def code(s):
    return ord(s)-ord("a")
def codeR(n):
    return chr(ord("a")+n)

@bootstrap
def dfs(n, c):
    if 1 <= n and c+(T.arrive[n]-T.last[n]) <= N-M:
        print("Yes")
        exit(print("".join(ans)))
    for i in range(26):
        if T.tree[n][i] != -1:
            ans.append(codeR(i))
            yield dfs(T.tree[n][i], c+T.last[T.tree[n][i]])
            ans.pop()
        elif c <= N-M:
            ans.append(codeR(i))
            print("Yes")
            exit(print("".join(ans)))
    yield

N, M = map(int, input().split())
S = [input().rstrip("\n") for _ in range(N)]

T = Trie(sum(len(s) for s in S), 0)
for s in S:
    T.insert(s)

ans = []
dfs(0, 0)

print("No")