#include "bits/stdc++.h"
using namespace std;


// Source: ecnerwala
// Fast recursion with lambdas
// Use it like:
// auto f = y_combinator([](auto self,....)->return_type{...self(...)});
template <class Fun>
class y_combinator_result {
  Fun fun_;

 public:
  template <class T>
  explicit y_combinator_result(T &&fun) : fun_(std::forward<T>(fun)) {}

  template <class... Args>
  decltype(auto) operator()(Args &&...args) {
    return fun_(std::ref(*this), std::forward<Args>(args)...);
  }
};

template <class Fun>
decltype(auto) y_combinator(Fun &&fun) {
  return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);

  int tt;
  cin >> tt;
  while(tt--) {
    struct Node {
      array<int, 26> children;
      int cnt, fin;

      Node() {
        for (int i =0; i < 26; i++) children[i] = -1;
        cnt = fin = 0;
      }
    };
    vector<Node> trie;
    trie.push_back(Node{});

    auto insert = [&](string s)->void {
      int curr = 0;
      for (auto& c : s) {
        trie[curr].cnt++;
        int cidx = c - 'a';
        if (trie[curr].children[cidx] == -1) {
          trie[curr].children[cidx] = trie.size();
          trie.push_back(Node{});
        }
        curr = trie[curr].children[cidx];
      }
      trie[curr].fin++;
      trie[curr].cnt++;
    };

    int n, k;
    cin >> n >> k;
    vector<string> v(n);
    for (auto& x : v) cin >> x, insert(x);

    string ans = "";
    y_combinator([&](auto self, int trie_node, int k)->void {
      int num_non_empty = 0;
      for (int i =0; i < 26; i++) {
        if (trie[trie_node].children[i] != -1) {
          num_non_empty++;
        }
      }
      k = max(0, k - trie[trie_node].fin);
      k = max(0, k - num_non_empty);
      if (k == 0) return;
      for (int i =0; i < 26; i++) {
        if (trie[trie_node].children[i] != -1) {
          int nxt = trie[trie_node].children[i];
          int r = min(k, trie[nxt].cnt - 1);
          k -= r;
          if (k == 0) {
            ans.push_back('a' + i);
            self(nxt, r+1);
            break;
          }
        }
      }
    })(0, k);

    if (ans.empty()) {
      cout << "EMPTY\n";
      continue;
    }
    cout << ans << '\n';
  }
}
// Choose k strings
// the lexmax of the pairwise LCPs of the k strings should be lexmin