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

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
#include <experimental/iterator>
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define orange(...) safe
#define debug(...) safe
#endif

template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;

struct Int {
  string s;
  bool operator<(const Int &rhs) const {
    if (s.size() != rhs.s.size())
      return s.size() < rhs.s.size();
    for (int i = 0; i < ssize(s); ++i)
      if (s[i] != rhs.s[i])
        return s[i] < rhs.s[i];
    return false;
  }
  bool operator>(const Int &rhs) const {
    if (s.size() != rhs.s.size())
      return s.size() > rhs.s.size();
    for (int i = 0; i < ssize(s); ++i)
      if (s[i] != rhs.s[i])
        return s[i] > rhs.s[i];
    return false;
  }
};

ostream &operator<<(ostream &os, const Int &s) {
  return os << s.s;
}

struct H {
  int l;
  vector<int> ds, p;
  H(vector<int> ds_, int c) : l(c), ds(ds_), p(ds.size()) {
    for (size_t i = 1; i < p.size(); ++i) {
      p[i] = l - (p.size() - i);
    }
  }
  bool operator>(const H &rhs) const {
    return gen() > rhs.gen();
  }
  Int gen() const {
    Int ret;
    ret.s.assign(l, '0');
    for (size_t i = 0; i + 1 < p.size(); ++i) {
      for (int j = p[i]; j < p[i + 1]; ++j)
        ret.s[j] = char(ds[i] + '0');
    }
    for (int i = p.back(); i < l; ++i)
      ret.s[i] = char(ds.back() + '0');
    if (ret.s[0] == '0') {
      for (int j = 1; j < l; ++j) {
        if (ret.s[j] != '0') {
          swap(ret.s[0], ret.s[j]);
          break;
        }
      }
    }
    return ret;
  }
  bool step() {
    for (size_t i = 1; i <= p.size(); ++i) {
      p[p.size() - i]--;
      if (i == p.size())
        return false;
      if (p[p.size() - i] == p[p.size() - i - 1]) {
        p[p.size() - i] = l - i;
      } else {
        break;
      }
    }
    return true;
  }
};

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int n, k;
  cin >> n >> k;
  vector<uint32_t> a(n);
  for (auto &S : a) {
    for (int i = 0; i < 6; ++i) {
      int x;
      cin >> x;
      S |= 1u << x;
    }
  }

  min_heap<H> h;

  set<array<int, 10>> done;
  min_heap<Int> ans;
  for (uint32_t S = 2; S < 1024; ++S) {
    int c = 0;
    for (auto s : a)
      c += !!(S & s);
    ++c;

    vector<int> ds;
    for (int i = 0; i < 10; ++i) {
      if ((S >> i) & 1)
        ds.push_back(i);
    }

    c = max(c, int(ds.size()));
    
    h.emplace(ds, c);
   }

  for (int i = 0; i < k; ++i) {
    while (not h.empty()) {
      if (ans.empty() or h.top().gen() < ans.top()) {
        auto cur = h.top();
        h.pop();
        auto curi = cur.gen();
        array<int, 10> ds = {};
        for (auto c : curi.s)
          ds[c - '0']++;
        if (done.insert(ds).second)
          ans.push(curi);
        if (cur.step()) {
          h.push(cur);
        }
      } else {
        break;
      }
    }
    auto cur = ans.top();
    ans.pop();
    cout << cur << " \n"[i + 1 == k];
    if (next_permutation(all(cur.s))) {
      ans.push(cur);
    } else {
      array<int, 10> ds = {};
      for (auto c : cur.s)
        ds[c - '0']++;

      for (int c = 0; c < 10; ++c) {
        ds[c]++;
        if (done.insert(ds).second) {
          Int nxt;
          int found = -1;
          if (ds[0] > 0) {
            for (int x = 1; x < 10; ++x) {
              if (ds[x]) {
                found = x;
                break;
              }
            }
          }
          if (ds[0] == 0 or found != -1) {
            if (found != -1) {
              nxt.s += char('0' + found);
              ds[found]--;
            }
            for (int x = 0; x < 10; ++x)
              for (int w = 0; w < ds[x]; ++w)
                nxt.s += char('0' + x);
            ans.push(nxt);
            if (found != -1) {
              ds[found]++;
            }
          }
        }
        ds[c]--;
      }
    }
  }
  return 0;
}