Problem: On the Internet shopping site, on the same page as the product that the user is currently viewing, some other products that other users have bought in the past along with the product that they are currently viewing are displayed. It is believed that sales can be increased by presenting products that are considered to be highly relevant.

Similar things can be seen in local supermarkets (such as bread and jam) as a way to place items that are often bought together nearby. Your job is to write a program that will help you devise product placement. This time, I would like to set a certain standard number of times and find a combination of two products for which the number of times bought together is equal to or greater than the standard number of times.

When given the information of the products bought together and the standard number of times, create a program that outputs the combination of the two products bought together more than the standard number of times.



Input

The input is given in the following format.


N F
info1
info2
::
infoN


The first line gives the number of pieces of information N (1 ≤ N ≤ 100) and the reference number F (1 ≤ F ≤ 100) of the items bought together. The following N lines are given information on the products bought together. Information about the products bought together infoi is given in the following format.


M item1 item2 ... itemM


M (1 ≤ M ≤ 10) indicates how many products this information contains. itemj is the name of the item bought in this purchase and is a string of 1 to 30 length consisting of only lowercase letters. The same product is never given in infoi.

Output

The number of combinations of two products bought together more than the reference number of times is output on the first line, and all combinations are output on the second and subsequent lines. However, if there is no combination, nothing is output after the second line.

The output order is as follows after arranging the product names in the combination in the lexicographic order (the order in which the words are arranged in the English-Japanese dictionary).

* Compare the first product names, and the one with the earliest in lexicographic order comes first.
* If they are the same, compare the second product names and the lexicographic order comes first.



Separate product names with a single space, and separate product combinations with a single line break.

Examples

Input

5 2
3 bread milk banana
2 milk cornflakes
3 potato bread milk
4 cornflakes bread milk butter
2 potato bread


Output

3
bread milk
bread potato
cornflakes milk


Input

5 5
3 bread milk banana
2 milk cornflakes
3 potato bread milk
4 cornflakes bread milk butter
2 potato bread


Output

0

Solution (in CPP):

Solution:
#include <iostream>
using namespace std;
//include
//------------------------------------------
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>

using namespace std;

//math
//-------------------------------------------
template<class T> inline T sqr(T x) {return x*x;}

//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long ll;

//container util
//------------------------------------------
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())

//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

//clear memory
#define CLR(a) memset((a), 0 ,sizeof(a))

//debug
#define dump(x)  cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;

bool compss(const string& a, const string& b){
	int i=0;
	while(i<a.size() && i<b.size()){
		if(a[i] < b[i])return true;
		if(a[i] > b[i])return false;
		i++;
	}
	return a.size() < b.size();
}

typedef pair<string,string> PSS;
typedef vector<PSS> VSS;

bool comp(const PSS& a, const PSS& b){
	if(compss(a.first,b.first))return true;
	if(compss(b.first,a.first))return false;
	if(compss(a.second,b.second))return true;
//	if(compss(b.second,a.second))return false;
	return false;
}

int n,f;
int ctn[1000][1000];
int mp[10];
map<string, int> sref;
map<int, string> revref;
int main() {
	cin >> n >> f;
	int tps=0;
	REP(i,n){
		int t;
		cin >> t;
		REP(j,t){
			char ch[38];
			cin >> ch;
			string s(ch);
			if(sref.find(s)==sref.end()){
				sref[s] = tps++;
				revref[tps-1] = s;
			}
			mp[j] = sref[s];
		}
		REP(j,t){
			FOR(k,j+1,t){
				int a=mp[j], b=mp[k];
				if(a>b)swap(a,b);
				ctn[a][b]++;
			}
		}
	}

	VSS ps;

	REP(i,tps){
		FOR(j,i+1,tps){
			if(ctn[i][j] >= f){
				string a=revref[i],b=revref[j];
				if(!compss(a, b))swap(a,b);
				ps.push_back(MP(a,b));
			}
		}
	}

	sort(ALL(ps), comp);

	cout << ps.size() << endl;
	EACH(i,ps){
		cout  <<  (*i).first + " " + (*i).second << endl;
	}

	return 0;
}