#include <algorithm>
#include <vector>
#include <string>
#include <set>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <map>
#include <cstdio>
#include <queue>
#include <tr1/unordered_map>

using namespace std;

typedef long long LL;

#define ff first
#define ss second
#define pb push_back
#define mp make_pair

#define FOREACH(it,c) for(typeof((c).begin()) it=(c).begin();it!=(c).end();++it)
#define REP(i,n) for(int _n=n, i=0;i<_n;++i)
#define FOR(i,a,b) for(int i=(a),_b=(b);i<=_b;++i)
#define FORD(i,a,b) for(int i=(a),_b=(b);i>=_b;--i)

const int Inf = 0x3f3f3f3f;

const int NMAX = 1000005;

vector<int> friends[NMAX];

LL get_hash(vector<int> v)
{
	sort(v.begin(), v.end());
	LL p = 1, hash = 0;
	for (size_t i = 0; i < v.size(); ++i)
		hash += v[i] * p, p *= 1000007;

	return hash;
}

tr1::unordered_map<LL, int> cnt;

int main()
{
	int n, m;
	cin>>n>>m;

	while (m--)
	{
		int x, y;
		cin>>x>>y;
		friends[x].pb(y);
		friends[y].pb(x);
	}

	FOR(i, 1, n)
		cnt[get_hash(friends[i])]++;

	LL ans = 0;
	FOR(i, 1, n)
		ans += cnt[get_hash(friends[i])] - 1;

	FOR(i, 1, n)
		friends[i].pb(i);

	FOR(i, 1, n)
		cnt[get_hash(friends[i])] = 0;

	FOR(i, 1, n)
		cnt[get_hash(friends[i])]++;

	FOR(i, 1, n)
		ans += cnt[get_hash(friends[i])] - 1;

	cout<<ans/2<<"\n";

	return 0;
}


#include <algorithm>
#include <vector>
#include <string>
#include <set>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <map>
#include <cstdio>
#include <queue>
#include <tr1/unordered_map>

using namespace std;

typedef long long LL;
typedef unsigned long long ULL;

#define ff first
#define ss second
#define pb push_back
#define mp make_pair

#define FOREACH(it,c) for(typeof((c).begin()) it=(c).begin();it!=(c).end();++it)
#define REP(i,n) for(int _n=n, i=0;i<_n;++i)
#define FOR(i,a,b) for(int i=(a),_b=(b);i<=_b;++i)
#define FORD(i,a,b) for(int i=(a),_b=(b);i>=_b;--i)

const int Inf = 0x3f3f3f3f;

const int NMAX = 1000005;

ULL pwr[NMAX], h[NMAX], hh[NMAX];

LL count_pairs(int N)
{
	FOR(i, 1, N)
		hh[i] = h[i];
	sort(hh+1, hh+N+1);
	LL ret = 0, cnt = 1;
	FOR(i, 2, N)
		if (hh[i] != hh[i-1])
		{
			ret += cnt*(cnt - 1);
			cnt = 1;
		}
		else
			++cnt;
	ret += cnt*(cnt - 1);
	return ret;
}

void debug(int N)
{
	FOR(i, 1, N)
		cerr<<h[i]<<' ';
	cerr<<"\n";
}

int main()
{
	int n, m;
	cin>>n>>m;

	pwr[0] = 1;
	FOR(i, 1, n)
		pwr[i] = pwr[i-1]*1000007;

	while (m--)
	{
		int x, y;
		cin>>x>>y;
		h[x] += pwr[y];
		h[y] += pwr[x];
	}

	//debug(n);

	LL ans = count_pairs(n);

	FOR(i, 1, n)
	{
		//cerr<<i<<' '<<h[i]<<' '<<pwr[i]<<' ';
		h[i] += pwr[i];
		//cerr<<h[i]<<'\n';
	}
	//debug(n);

	ans += count_pairs(n);

	cout<<ans/2<<"\n";

	return 0;
}


/*
C Double Profiles
Tanat Jiwapornkupt
15/3/57
*/
#include <stdio.h>
#include <algorithm>
#include <math.h>

using namespace std;

typedef struct edgetype{
	int one;
	int two;
};

typedef struct newtype{
	int one;
	int two;
	int s;
};

newtype f[2000001];
edgetype edge[1000001];
int n;
int m;
long long sum[1000001];
long long final[2000001];

long long cont; //continue
long long npair = 0;
long long root;
bool alr[1000001];
bool check[1000001];
long long hash[1000001];
long long counter = 0;
long long front;
long long back;

bool compare(long long x,long long y){
	return x<y;
}

bool compare2(newtype x,newtype y){
	return x.s<y.s;
}
int main(){
	scanf("%d%d",&n,&m);
	//root = 10000000;
	hash[0] = 1;
	for(long long i=1;i<=n;i++){
		hash[i] = i*i*(int)sqrt(i)+hash[i-1]*i;
	}
	for(int i=0;i<m;i++){
		scanf("%d%d",&edge[i].one,&edge[i].two);
		sum[edge[i].one]+=hash[edge[i].two];
		//printf("sum1 = %d, ",sum[edge[i].one]);
		sum[edge[i].two]+=hash[edge[i].one];
		//printf("sum2 = %d\n",sum[edge[i].two]);
		alr[edge[i].one] = 1;
		alr[edge[i].two] = 1;
	}

	/*
	for(int i=0;i<m;i++){
		//final[2*i] = sum[edge[i].one]-edge[i].two*(int)sqrt(edge[i].two)-edge[i].two;
		//final[2*i+1] = sum[edge[i].two]-edge[i].one*(int)sqrt(edge[i].one)-edge[i].one;

		f[2*i].s = sum[edge[i].one]-edge[i].two*(int)sqrt(edge[i].two);
		f[2*i].one = edge[i].one;
		f[2*i].two = edge[i].two;
		f[2*i+1].s = sum[edge[i].two]-edge[i].one*(int)sqrt(edge[i].one);
		f[2*i+1].two = edge[i].one;
		f[2*i+1].one = edge[i].two;

	}
	*/

	//sort(final,final+2*m,compare);

	//sort(f,f+2*m,compare2);
	/*
	for(int i=0;i<2*m;i++){
		printf("%d , %d : %I64d\n",f[i].one,f[i].two,f[i].s);
	}
	printf("\n");
	*/
	for(int i=0;i<m;i++){
		front = sum[edge[i].one]-hash[edge[i].two];
		back = sum[edge[i].two]-hash[edge[i].one];
		if(front==back){
			npair++;
		}
	}
	cont= 1;
//	printf("%I64d\n",npair);
	//other
	for(int i=0;i<n;i++){
		//printf("sum = %I64d\n",sum[i]);
		final[i] = sum[i+1];
	}
	sort(final,final+n,compare);
	for(int i=1;i<n;i++){
		//printf("%d , %d\n",i,final[i]);
		if(final[i-1]==final[i]){
			cont++;
		}
		else{
			//printf("cont = %I64d\n",cont);
			npair+=((cont)*(cont-1))/2;
			cont = 1;
		}
	}
	//printf("last cont = %I64d\n",cont);
	if(cont>1){
		npair+=((cont)*(cont-1))/2;
	}

	/*
	//no edges
	counter = 0;
	for(int i=1;i<=n;i++){
		if(!alr[i]){
			counter++;
		}
	}
	npair+=((counter)*(counter-1))/2;
	*/
	printf("%I64d",npair);
	return 0;
}


/*
C Double Profiles
Tanat Jiwapornkupt
15/3/57
*/
#include <stdio.h>
#include <algorithm>
#include <math.h>

using namespace std;

typedef struct edgetype{
	int one;
	int two;
};

typedef struct newtype{
	int one;
	int two;
	int s;
};

newtype f[2000001];
edgetype edge[1000001];
int n;
int m;
long long sum[1000001];
long long final[2000001];

long long cont; //continue
long long npair = 0;
long long root;
bool alr[1000001];
bool check[1000001];
long long counter = 0;

bool compare(long long x,long long y){
	return x<y;
}

bool compare2(newtype x,newtype y){
	return x.s<y.s;
}
int main(){
	scanf("%d%d",&n,&m);
	//root = 10000000;
	for(int i=0;i<m;i++){
		scanf("%d%d",&edge[i].one,&edge[i].two);
		sum[edge[i].one]+=edge[i].two*(int)sqrt(edge[i].two)+edge[i].two*edge[i].two;
		//printf("sum1 = %d, ",sum[edge[i].one]);
		sum[edge[i].two]+=edge[i].one*(int)sqrt(edge[i].one)+edge[i].one*edge[i].one;
		//printf("sum2 = %d\n",sum[edge[i].two]);
		alr[edge[i].one] = 1;
		alr[edge[i].two] = 1;
	}

	for(int i=0;i<m;i++){
		//final[2*i] = sum[edge[i].one]-edge[i].two*(int)sqrt(edge[i].two)-edge[i].two;
		//final[2*i+1] = sum[edge[i].two]-edge[i].one*(int)sqrt(edge[i].one)-edge[i].one;

		f[2*i].s = sum[edge[i].one]-edge[i].two*(int)sqrt(edge[i].two)-edge[i].two*edge[i].two;
		f[2*i].one = edge[i].one;
		f[2*i].two = edge[i].two;
		f[2*i+1].s = sum[edge[i].two]-edge[i].one*(int)sqrt(edge[i].one)-edge[i].one*edge[i].one;
		f[2*i+1].two = edge[i].one;
		f[2*i+1].one = edge[i].two;

	}

	//sort(final,final+2*m,compare);
	/*
	sort(f,f+2*m,compare2);
	for(int i=0;i<2*m;i++){
		printf("%d , %d : %I64d\n",f[i].one,f[i].two,f[i].s);
	}
	printf("\n");
	*/
	cont = 1;
	for(int i=1;i<2*m;i++){
		//printf("%d : %d\n",i,cont);
		if(f[i].s==f[i-1].s){
			if(f[i].two==f[i-1].one && f[i-1].two==f[i].one){
			}
			else{
				cont--;
			}

			cont++;
		}
		else{
			npair+=((cont)*(cont-1))/2;
			cont=1;
		}
	}
	if(cont>1){
		npair+=((cont)*(cont-1))/2;
		cont = 1;
	}

//	printf("%I64d\n",npair);
	//other
	for(int i=0;i<n;i++){
		//printf("sum = %I64d\n",sum[i]);
		final[i] = sum[i+1];
	}
	sort(final,final+n,compare);
	for(int i=1;i<n;i++){
		//printf("%d , %d\n",i,final[i]);
		if(final[i-1]==final[i]){
			cont++;
		}
		else{
			//printf("cont = %I64d\n",cont);
			npair+=((cont)*(cont-1))/2;
			cont = 1;
		}
	}
	//printf("last cont = %I64d\n",cont);
	if(cont>1){
		npair+=((cont)*(cont-1))/2;
	}

	/*
	//no edges
	counter = 0;
	for(int i=1;i<=n;i++){
		if(!alr[i]){
			counter++;
		}
	}
	npair+=((counter)*(counter-1))/2;
	*/
	printf("%I64d",npair);
	return 0;
}


/*
C Double Profiles
Tanat Jiwapornkupt
15/3/57
*/
#include <stdio.h>
#include <algorithm>
#include <math.h>

using namespace std;

typedef struct edgetype{
	int one;
	int two;
};

typedef struct newtype{
	int one;
	int two;
	int s;
};

newtype f[2000001];
edgetype edge[1000001];
int n;
int m;
long long sum[1000001];
long long final[2000001];

long long cont; //continue
long long npair = 0;
long long root;
bool alr[1000001];
bool check[1000001];
long long counter = 0;

bool compare(long long x,long long y){
	return x<y;
}

bool compare2(newtype x,newtype y){
	return x.s<y.s;
}
int main(){
	scanf("%d%d",&n,&m);
	//root = 10000000;
	for(int i=0;i<m;i++){
		scanf("%d%d",&edge[i].one,&edge[i].two);
		sum[edge[i].one]+=edge[i].two*(int)sqrt(edge[i].two)+edge[i].two*edge[i].two*3;
		//printf("sum1 = %d, ",sum[edge[i].one]);
		sum[edge[i].two]+=edge[i].one*(int)sqrt(edge[i].one)+edge[i].one*edge[i].one*3;
		//printf("sum2 = %d\n",sum[edge[i].two]);
		alr[edge[i].one] = 1;
		alr[edge[i].two] = 1;
	}

	for(int i=0;i<m;i++){
		//final[2*i] = sum[edge[i].one]-edge[i].two*(int)sqrt(edge[i].two)-edge[i].two;
		//final[2*i+1] = sum[edge[i].two]-edge[i].one*(int)sqrt(edge[i].one)-edge[i].one;

		f[2*i].s = sum[edge[i].one]-edge[i].two*(int)sqrt(edge[i].two)-edge[i].two*edge[i].two*3;
		f[2*i].one = edge[i].one;
		f[2*i].two = edge[i].two;
		f[2*i+1].s = sum[edge[i].two]-edge[i].one*(int)sqrt(edge[i].one)-edge[i].one*edge[i].one*3;
		f[2*i+1].two = edge[i].one;
		f[2*i+1].one = edge[i].two;

	}

	//sort(final,final+2*m,compare);
	/*
	sort(f,f+2*m,compare2);
	for(int i=0;i<2*m;i++){
		printf("%d , %d : %I64d\n",f[i].one,f[i].two,f[i].s);
	}
	printf("\n");
	*/
	cont = 1;
	for(int i=1;i<2*m;i++){
		//printf("%d : %d\n",i,cont);
		/*
		if(f[i].s==f[i-1].s){
			if(f[i].two==f[i-1].one && f[i-1].two==f[i].one){
			}
			else{
				cont--;
			}

			cont++;
		}
		else{
			npair+=((cont)*(cont-1))/2;
			cont=1;
		}
		*/
		if(f[i].s==f[i-1].s && f[i].two==f[i-1].one && f[i-1].two==f[i].one){
			npair++;
		}
	}
	if(cont>1){
		npair+=((cont)*(cont-1))/2;
		cont = 1;
	}

//	printf("%I64d\n",npair);
	//other
	for(int i=0;i<n;i++){
		//printf("sum = %I64d\n",sum[i]);
		final[i] = sum[i+1];
	}
	sort(final,final+n,compare);
	for(int i=1;i<n;i++){
		//printf("%d , %d\n",i,final[i]);
		if(final[i-1]==final[i]){
			cont++;
		}
		else{
			//printf("cont = %I64d\n",cont);
			npair+=((cont)*(cont-1))/2;
			cont = 1;
		}
	}
	//printf("last cont = %I64d\n",cont);
	if(cont>1){
		npair+=((cont)*(cont-1))/2;
	}

	/*
	//no edges
	counter = 0;
	for(int i=1;i<=n;i++){
		if(!alr[i]){
			counter++;
		}
	}
	npair+=((counter)*(counter-1))/2;
	*/
	printf("%I64d",npair);
	return 0;
}


/*
C Double Profiles
Tanat Jiwapornkupt
15/3/57
*/
#include <stdio.h>
#include <algorithm>
#include <math.h>

using namespace std;

typedef struct edgetype{
	int one;
	int two;
};

typedef struct newtype{
	int one;
	int two;
	int s;
};

newtype f[2000001];
edgetype edge[1000001];
int n;
int m;
long long sum[1000001];
long long final[2000001];

long long cont; //continue
long long npair = 0;
long long root;
bool alr[1000001];
bool check[1000001];
long long counter = 0;

bool compare(long long x,long long y){
	return x<y;
}

bool compare2(newtype x,newtype y){
	return x.s<y.s;
}
int main(){
	scanf("%d%d",&n,&m);
	//root = 10000000;
	for(int i=0;i<m;i++){
		scanf("%d%d",&edge[i].one,&edge[i].two);
		sum[edge[i].one]+=edge[i].two*(int)sqrt(edge[i].two)+edge[i].two*edge[i].two*edge[i].two*7;
		//printf("sum1 = %d, ",sum[edge[i].one]);
		sum[edge[i].two]+=edge[i].one*(int)sqrt(edge[i].one)+edge[i].one*edge[i].one*edge[i].one*7;
		//printf("sum2 = %d\n",sum[edge[i].two]);
		alr[edge[i].one] = 1;
		alr[edge[i].two] = 1;
	}

	for(int i=0;i<m;i++){
		//final[2*i] = sum[edge[i].one]-edge[i].two*(int)sqrt(edge[i].two)-edge[i].two;
		//final[2*i+1] = sum[edge[i].two]-edge[i].one*(int)sqrt(edge[i].one)-edge[i].one;

		f[2*i].s = sum[edge[i].one]-edge[i].two*(int)sqrt(edge[i].two)-edge[i].two*edge[i].two*edge[i].two*7;
		f[2*i].one = edge[i].one;
		f[2*i].two = edge[i].two;
		f[2*i+1].s = sum[edge[i].two]-edge[i].one*(int)sqrt(edge[i].one)-edge[i].one*edge[i].one*edge[i].one*7;
		f[2*i+1].two = edge[i].one;
		f[2*i+1].one = edge[i].two;

	}

	//sort(final,final+2*m,compare);
	/*
	sort(f,f+2*m,compare2);
	for(int i=0;i<2*m;i++){
		printf("%d , %d : %I64d\n",f[i].one,f[i].two,f[i].s);
	}
	printf("\n");
	*/
	cont = 1;
	for(int i=1;i<2*m;i++){
		//printf("%d : %d\n",i,cont);
		/*
		if(f[i].s==f[i-1].s){
			if(f[i].two==f[i-1].one && f[i-1].two==f[i].one){
			}
			else{
				cont--;
			}

			cont++;
		}
		else{
			npair+=((cont)*(cont-1))/2;
			cont=1;
		}
		*/
		if(f[i].s==f[i-1].s && f[i].two==f[i-1].one && f[i-1].two==f[i].one){
			npair++;
		}
	}
	if(cont>1){
		npair+=((cont)*(cont-1))/2;
		cont = 1;
	}

//	printf("%I64d\n",npair);
	//other
	for(int i=0;i<n;i++){
		//printf("sum = %I64d\n",sum[i]);
		final[i] = sum[i+1];
	}
	sort(final,final+n,compare);
	for(int i=1;i<n;i++){
		//printf("%d , %d\n",i,final[i]);
		if(final[i-1]==final[i]){
			cont++;
		}
		else{
			//printf("cont = %I64d\n",cont);
			npair+=((cont)*(cont-1))/2;
			cont = 1;
		}
	}
	//printf("last cont = %I64d\n",cont);
	if(cont>1){
		npair+=((cont)*(cont-1))/2;
	}

	/*
	//no edges
	counter = 0;
	for(int i=1;i<=n;i++){
		if(!alr[i]){
			counter++;
		}
	}
	npair+=((counter)*(counter-1))/2;
	*/
	printf("%I64d",npair);
	return 0;
}


/*
C Double Profiles
Tanat Jiwapornkupt
15/3/57
*/
#include <stdio.h>
#include <algorithm>
#include <math.h>

using namespace std;

typedef struct edgetype{
	int one;
	int two;
};

typedef struct newtype{
	int one;
	int two;
	int s;
};

newtype f[2000001];
edgetype edge[1000001];
int n;
int m;
long long sum[1000001];
long long final[2000001];

long long cont; //continue
long long npair = 0;
long long root;
bool alr[1000001];
bool check[1000001];
long long counter = 0;
long long front;
long long back;

bool compare(long long x,long long y){
	return x<y;
}

bool compare2(newtype x,newtype y){
	return x.s<y.s;
}
int main(){
	scanf("%d%d",&n,&m);
	//root = 10000000;
	for(int i=0;i<m;i++){
		scanf("%d%d",&edge[i].one,&edge[i].two);
		sum[edge[i].one]+=edge[i].two*edge[i].two*(int)sqrt(edge[i].two)+edge[i].two*3;
		//printf("sum1 = %d, ",sum[edge[i].one]);
		sum[edge[i].two]+=edge[i].one*edge[i].one*(int)sqrt(edge[i].one)+edge[i].one*3;
		//printf("sum2 = %d\n",sum[edge[i].two]);
		alr[edge[i].one] = 1;
		alr[edge[i].two] = 1;
	}

	/*
	for(int i=0;i<m;i++){
		//final[2*i] = sum[edge[i].one]-edge[i].two*(int)sqrt(edge[i].two)-edge[i].two;
		//final[2*i+1] = sum[edge[i].two]-edge[i].one*(int)sqrt(edge[i].one)-edge[i].one;

		f[2*i].s = sum[edge[i].one]-edge[i].two*(int)sqrt(edge[i].two);
		f[2*i].one = edge[i].one;
		f[2*i].two = edge[i].two;
		f[2*i+1].s = sum[edge[i].two]-edge[i].one*(int)sqrt(edge[i].one);
		f[2*i+1].two = edge[i].one;
		f[2*i+1].one = edge[i].two;

	}
	*/

	//sort(final,final+2*m,compare);

	//sort(f,f+2*m,compare2);
	/*
	for(int i=0;i<2*m;i++){
		printf("%d , %d : %I64d\n",f[i].one,f[i].two,f[i].s);
	}
	printf("\n");
	*/
	for(int i=0;i<m;i++){
		front = sum[edge[i].one]-edge[i].two*edge[i].two*(int)sqrt(edge[i].two)-3*edge[i].two;
		back = sum[edge[i].two]-edge[i].one*edge[i].one*(int)sqrt(edge[i].one)-3*edge[i].one;
		if(front==back){
			npair++;
		}
	}
	cont= 1;
//	printf("%I64d\n",npair);
	//other
	for(int i=0;i<n;i++){
		//printf("sum = %I64d\n",sum[i]);
		final[i] = sum[i+1];
	}
	sort(final,final+n,compare);
	for(int i=1;i<n;i++){
		//printf("%d , %d\n",i,final[i]);
		if(final[i-1]==final[i]){
			cont++;
		}
		else{
			//printf("cont = %I64d\n",cont);
			npair+=((cont)*(cont-1))/2;
			cont = 1;
		}
	}
	//printf("last cont = %I64d\n",cont);
	if(cont>1){
		npair+=((cont)*(cont-1))/2;
	}

	/*
	//no edges
	counter = 0;
	for(int i=1;i<=n;i++){
		if(!alr[i]){
			counter++;
		}
	}
	npair+=((counter)*(counter-1))/2;
	*/
	printf("%I64d",npair);
	return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 100000 + 100;

int n, k;

int sz;
char str[maxn];
int ch[maxn][26];
int val[maxn];

void insert(char* s)
{
    int u = 0;
    for(int i = 0; s[i]; i++)
    {
        int c = s[i] - 'a';
        if(!ch[u][c]) ch[u][c] = sz++;
        u = ch[u][c];
    }
    val[u] = 1;
}

int win[maxn];

int Win(int u)
{
    if(val[u]) return 0;
    if(win[u] >= 0) return win[u];
    int& ans = win[u];
    for(int c = 0; c < 26; c++) if(ch[u][c])
    {
        int v = ch[u][c];
        if(Win(v)) return ans = 0;
    }
    return ans = 1;
}

int main()
{
    //freopen("in.txt", "r", stdin);

    scanf("%d%d", &n, &k);
    sz = 1;
    for(int i = 0; i < n; i++)
    {
        scanf("%s", str);
        insert(str);
    }

    memset(win, -1, sizeof(win));

    bool ans;
    if(Win(0)) ans = true;
    else ans = false;
    if(ans && (k % 2) == 0) ans = !ans;
    printf("%s\n", ans ? "First" : "Second");

    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>

using namespace std;

const int max_len = 100500, max_alpha = 26;

int t[max_len][max_alpha];
int szT;

int newT() {
    return ++szT;
}

int n, k, root;
char s[max_len];
bool win[max_len], lose[max_len];

void addTrie(char * s) {
    int len = strlen(s);
    int v = root;
    for (int i = 0; i < len; i++) {
        int c = s[i] - 'a';
        if (t[v][c] == 0) t[v][c] = newT();
        v = t[v][c];
    }
}

void dfs(int v) {
    win[v] = false;
    lose[v] = false;
    bool isLeaf = true; //
    for (int i = 0; i < max_alpha; i++) {
        if (t[v][i] != 0) {
            isLeaf = false;
            int to = t[v][i];
            dfs(to);
            win[v] |= !win[to];
            lose[v] |= !lose[to];
        }
    }
    if (isLeaf) {
        lose[v] = true;
    }
}

int main() {
    //freopen("input.txt", "r", stdin);
    scanf("%d%d", &n, &k);
    root = newT();
    for (int i = 1; i <= n; i++) {
        scanf("%s", s);
        addTrie(s);
    }
    dfs(root);
    if (k == 1) puts("First"); //1 game
    else if (!win[root]) puts("Second"); //answer(0);
    else if (lose[root]) puts("First"); //answer(1);
    else if (k % 2 == 1) puts("First"); //answer(1)
    else puts("Second"); //answer(0)
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>

using namespace std;

const int max_len = 100500, max_alpha = 26;

int t[max_len][max_alpha];
int szT;

int newT() {
    return ++szT;
}

int n, k, root;
char s[max_len];
bool win[max_len], lose[max_len];

void addTrie(char * s) {
    int len = strlen(s);
    int v = root;
    for (int i = 0; i < len; i++) {
        int c = s[i] - 'a';
        if (t[v][c] == 0) t[v][c] = newT();
        v = t[v][c];
    }
}

void dfs(int v) {
    win[v] = false;
    lose[v] = false;
    bool isLeaf = true; //
    for (int i = 0; i < max_alpha; i++) {
        if (t[v][i] != 0) {
            isLeaf = false;
            int to = t[v][i];
            dfs(to);
            win[v] |= !win[to];
            lose[v] |= !lose[to];
        }
    }
    if (isLeaf) {
        lose[v] = true;
    }
}

int main() {
    //freopen("in.txt", "r", stdin);
    scanf("%d%d", &n, &k);
    root = newT();
    for (int i = 1; i <= n; i++) {
        scanf("%s", s);
        addTrie(s);
    }
    dfs(root);
    //if (k == 1) puts("First"); //1 game
    if (!win[root]) puts("Second"); //answer(0);
    else if (lose[root]) puts("First"); //answer(1);
    else if (k % 2 == 1) puts("First"); //answer(1)
    else puts("Second"); //answer(0)
}


#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 100000 + 10;
const int sigma_size = 26;

int sz;
int ch[maxn][sigma_size];
int val[maxn];
char str[maxn];

void insert(char* s)
{
    int u = 0;
    for(int i = 0; s[i]; i++)
    {
        int c = s[i] - 'a';
        if(!ch[u][c]) ch[u][c] = sz++;
        u = ch[u][c];
    }
    val[u] = true;
}

bool win[maxn], lose[maxn];

void dfs(int u)
{
    if(val[u]) { win[u] = false; lose[u] = true; return; }

    for(int c = 0; c < 26; c++) if(ch[u][c])
    {
        int v = ch[u][c];
        dfs(v);
        win[u] |= !win[v];
        lose[u] |= !lose[v];
    }
}

int main()
{
    //freopen("in.txt", "r", stdin);

    sz = 1;
    int n, k;
    scanf("%d%d", &n, &k);
    for(int i = 0; i < n; i++)
    {
        scanf("%s", str);
        insert(str);
    }

    dfs(0);

    if(!win[0]) puts("Second");
    else if(lose[0]) puts("First");
    else
    {
        if(k & 1) puts("First");
        else puts("Second");
    }

    return 0;
}


#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 1000000 + 100;

int n, k;

int sz;
char str[maxn];
int ch[maxn][26];
int val[maxn];

void insert(char* s)
{
    int u = 0;
    for(int i = 0; s[i]; i++)
    {
        int c = s[i] - 'a';
        if(!ch[u][c]) ch[u][c] = sz++;
        u = ch[u][c];
    }
    val[u] = 1;
}

int win[maxn];

int Win(int u)
{
    if(val[u]) return 0;
    if(win[u] >= 0) return win[u];
    int& ans = win[u];
    for(int c = 0; c < 26; c++) if(ch[u][c])
    {
        int v = ch[u][c];
        if(!Win(v)) return ans = 1;
    }
    return ans = 0;
}

int lose[maxn];

int Lose(int u)
{
    if(val[u]) return 1;
    if(lose[u] >= 0) return lose[u];
    int& ans = lose[u];
    for(int c = 0; c < 26; c++) if(ch[u][c])
    {
        int v = ch[u][c];
        if(!Lose(v)) return ans = 1;
    }
    return ans = 0;
}

int main()
{
    //freopen("in.txt", "r", stdin);

    scanf("%d%d", &n, &k);
    sz = 1;
    for(int i = 0; i < n; i++)
    {
        scanf("%s", str);
        insert(str);
    }

    memset(win, -1, sizeof(win));
    memset(lose, -1, sizeof(lose));
    if(!Win(0)) { puts("Second"); return 0; }
    if(Lose(0)) { puts("First"); return 0; }
    if(k & 1) puts("First"); else puts("Second");

    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <cstring>

using namespace std;

const long long MOD = 1000000009LL;

int n, k;
long long pw[200000];
string str[200000];
set <long long> ss;
map <long long, bool> va;
map <long long, bool> vb;

bool gaol(int len, long long ha) {
    if (ss.count(ha) == 0)
        return true;
    if (vb.count(ha) != 0)
        return vb[ha];
    bool ans = false;
    for (char a = 'a'; a <= 'z'; a++) {
        long long hb = ha + (pw[len] * a) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        bool nxt = gaol(len + 1, hb);
        if (!nxt)
            return vb[ha] = true;
        ans |= nxt;
    }
    return vb[ha] = !ans;
}

bool gaow(int len, long long ha) {
    if (ss.count(ha) == 0)
        return false;
    if (va.count(ha) != 0)
        return va[ha];
    bool ans = false;
    for (char c = 'a'; c <= 'z'; c++) {
        long long hb = ha + (pw[len] * c) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= !gaow(len + 1, hb);
    }
    return va[ha] = ans;
}

int main() {

    ios::sync_with_stdio(false);

    cin >> n >> k;

    for (int i = 0; i < n; i++)
        cin >> str[i];

    pw[0] = 1LL;

    for (int i = 1; i <= 100010; i++)
        pw[i] = pw[i - 1] * 117L % MOD;

    ss.insert(0);

    for (int i = 0; i < n; i++) {
        long long ha = 0;
        for (int j = 0; j < (int) str[i].size(); j++) {
            ha = ha + (pw[j] * str[i][j]) % MOD;
            if (ha >= MOD)
                ha -= MOD;
            ss.insert(ha);
        }
    }

    bool g0 = gaow(0, 0);
    bool g1 = gaol(0, 0);

    if (g0 && g1) {
        printf("First\n");
    } else if (g0) {
        if (k % 2)
            printf("First\n");
        else
            printf("Second\n");
    } else if (g1) {
        printf("Second\n");
    }

    return 0;

}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <cstring>

using namespace std;

const long long MOD = 1000000009LL;

int n, k;
long long pw[200000];
string str[200000];
set <long long> ss;
map <long long, bool> va;
map <long long, bool> vb;

bool gaol(int len, long long ha) {
    if (ss.count(ha) == 0)
        return true;
    if (vb.count(ha) != 0)
        return vb[ha];
    bool ans = false;
    for (char a = 'a'; a <= 'z'; a++) {
        long long hb = ha + (pw[len] * a) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        bool nxt = gaol(len + 1, hb);
        if (!nxt)
            return vb[ha] = true;
        ans |= nxt;
    }
    return vb[ha] = !ans;
}

bool gaow(int len, long long ha) {
    if (ss.count(ha) == 0)
        return false;
    if (va.count(ha) != 0)
        return va[ha];
    bool ans = false;
    for (char c = 'a'; c <= 'z'; c++) {
        long long hb = ha + (pw[len] * c) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= !gaow(len + 1, hb);
    }
    return va[ha] = ans;
}

int main() {

    ios::sync_with_stdio(false);

    cin >> n >> k;

    for (int i = 0; i < n; i++)
        cin >> str[i];

    pw[0] = 1LL;

    for (int i = 1; i <= 100010; i++)
        pw[i] = pw[i - 1] * 119 % MOD;

    ss.insert(0);

    for (int i = 0; i < n; i++) {
        long long ha = 0;
        for (int j = 0; j < (int) str[i].size(); j++) {
            ha = ha + (pw[j] * str[i][j]) % MOD;
            if (ha >= MOD)
                ha -= MOD;
            ss.insert(ha);
        }
    }

    bool g0 = gaow(0, 0);
    bool g1 = gaol(0, 0);

    if (g0 && g1) {
        printf("First\n");
    } else if (g0) {
        if (k % 2)
            printf("First\n");
        else
            printf("Second\n");
    } else if (g1) {
        printf("Second\n");
    }

    return 0;

}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <cstring>

using namespace std;

const long long MOD = 1000000009LL;

int n, k;
long long pw[200000];
string str[200000];
set <long long> ss;
map <long long, bool> va;
map <long long, bool> vb;

bool gaol(int len, long long ha) {
    if (ss.count(ha) == 0)
        return true;
    if (vb.count(ha) != 0)
        return vb[ha];
    bool ans = false;
    for (char a = 'a'; a <= 'z'; a++) {
        long long hb = ha + (pw[len] * a) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        bool nxt = gaol(len + 1, hb);
        if (!nxt)
            return vb[ha] = true;
        ans |= nxt;
    }
    return vb[ha] = !ans;
}

bool gaow(int len, long long ha) {
    if (ss.count(ha) == 0)
        return false;
    if (va.count(ha) != 0)
        return va[ha];
    bool ans = false;
    for (char c = 'a'; c <= 'z'; c++) {
        long long hb = ha + (pw[len] * c) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= !gaow(len + 1, hb);
    }
    return va[ha] = ans;
}

int main() {

    ios::sync_with_stdio(false);

    cin >> n >> k;

    for (int i = 0; i < n; i++)
        cin >> str[i];

    pw[0] = 1LL;

    for (int i = 1; i <= 100010; i++)
        pw[i] = pw[i - 1] * 999989LL % MOD;

    ss.insert(0);

    for (int i = 0; i < n; i++) {
        long long ha = 0;
        for (int j = 0; j < (int) str[i].size(); j++) {
            ha = ha + (pw[j] * str[i][j]) % MOD;
            if (ha >= MOD)
                ha -= MOD;
            ss.insert(ha);
        }
    }

    bool g0 = gaow(0, 0);
    bool g1 = gaol(0, 0);

    if (g0 && g1) {
        printf("First\n");
    } else if (g0) {
        if (k % 2)
            printf("First\n");
        else
            printf("Second\n");
    } else if (g1) {
        printf("Second\n");
    }

    return 0;

}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <cstring>

using namespace std;

const long long MOD = 1000000009LL;

int n, k;
long long pw[200000];
string str[200000];
set <long long> ss;
map <long long, bool> va;
map <long long, bool> vb;

bool gaol(int len, long long ha) {
    if (ss.count(ha) == 0)
        return true;
    if (vb.count(ha) != 0)
        return vb[ha];
    bool ans = false;
    for (char a = 'a'; a <= 'z'; a++) {
        long long hb = ha + (pw[len] * a) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= !gaol(len + 1, hb);
    }
    return vb[ha] = !ans;
}

bool gaow(int len, long long ha) {
    if (ss.count(ha) == 0)
        return false;
    if (va.count(ha) != 0)
        return va[ha];
    bool ans = false;
    for (char c = 'a'; c <= 'z'; c++) {
        long long hb = ha + (pw[len] * c) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= !gaow(len + 1, hb);
    }
    return va[ha] = ans;
}

int main() {

    ios::sync_with_stdio(false);

    cin >> n >> k;

    for (int i = 0; i < n; i++)
        cin >> str[i];

    pw[0] = 1LL;

    for (int i = 1; i <= 100010; i++)
        pw[i] = pw[i - 1] * 999989LL % MOD;

    ss.insert(0);

    for (int i = 0; i < n; i++) {
        long long ha = 0;
        for (int j = 0; j < (int) str[i].size(); j++) {
            ha = ha + (pw[j] * str[i][j]) % MOD;
            if (ha >= MOD)
                ha -= MOD;
            ss.insert(ha);
        }
    }

    bool g0 = gaow(0, 0);
    bool g1 = gaol(0, 0);

    if (g0 && g1) {
        printf("First\n");
    } else if (g0) {
        if (k % 2)
            printf("First\n");
        else
            printf("Second\n");
    } else if (g1) {
        printf("Second\n");
    }

    return 0;

}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <cstring>

using namespace std;

const long long MOD = 1000000009LL;

int n, k;
long long pw[200000];
string str[200000];
set <long long> ss;
map <long long, bool> va;
map <long long, bool> vb;

bool gaol(int len, long long ha) {
    if (ss.count(ha) == 0)
        return true;
    if (vb.count(ha) != 0)
        return vb[ha];
    bool ans = false;
    for (char a = 'a'; a <= 'z'; a++) {
        long long hb = ha + (pw[len] * a) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= gaol(len + 1, hb);
    }
    return vb[ha] = !ans;
}

bool gaow(int len, long long ha) {
    if (ss.count(ha) == 0)
        return false;
    if (va.count(ha) != 0)
        return va[ha];
    bool ans = false;
    for (char c = 'a'; c <= 'z'; c++) {
        long long hb = ha + (pw[len] * c) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= !gaow(len + 1, hb);
    }
    return va[ha] = ans;
}

int main() {

    ios::sync_with_stdio(false);

    cin >> n >> k;

    for (int i = 0; i < n; i++)
        cin >> str[i];

    pw[0] = 1LL;

    for (int i = 1; i <= 100010; i++)
        pw[i] = pw[i - 1] * 999989LL % MOD;

    ss.insert(0);

    for (int i = 0; i < n; i++) {
        long long ha = 0;
        for (int j = 0; j < (int) str[i].size(); j++) {
            ha = ha + (pw[j] * str[i][j]) % MOD;
            if (ha >= MOD)
                ha -= MOD;
            ss.insert(ha);
        }
    }

    bool g0 = !gaow(0, 0);
    bool g1 = !gaol(0, 0);

    if (g0 && g1) {
        printf("First\n");
    } else if (g0) {
        if (k % 2)
            printf("First\n");
        else
            printf("Second\n");
    } else if (g1) {
        printf("Second\n");
    }

    return 0;

}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <cstring>

using namespace std;

const long long MOD = 1000000009LL;

int n, k;
long long pw[200000];
string str[200000];
set <long long> ss;
map <long long, bool> va;
map <long long, bool> vb;

bool gaol(int len, long long ha) {
    if (ss.count(ha) == 0)
        return true;
    if (vb.count(ha) != 0)
        return vb[ha];
    bool ans = false;
    for (char a = 'a'; a <= 'z'; a++) {
        long long hb = ha + (pw[len] * a) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        bool nxt = gaol(len + 1, hb);
        if (!nxt)
            return vb[ha] = true;
        ans |= nxt;
    }
    return vb[ha] = !ans;
}

bool gaow(int len, long long ha) {
    if (ss.count(ha) == 0)
        return false;
    if (va.count(ha) != 0)
        return va[ha];
    bool ans = false;
    for (char c = 'a'; c <= 'z'; c++) {
        long long hb = ha + (pw[len] * c) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= !gaow(len + 1, hb);
    }
    return va[ha] = ans;
}

int main() {

    ios::sync_with_stdio(false);

    cin >> n >> k;

    for (int i = 0; i < n; i++)
        cin >> str[i];

    pw[0] = 1LL;

    for (int i = 1; i <= 100010; i++)
        pw[i] = pw[i - 1] * 33LL % MOD;

    ss.insert(0);

    for (int i = 0; i < n; i++) {
        long long ha = 0;
        for (int j = 0; j < (int) str[i].size(); j++) {
            ha = ha + (pw[j] * str[i][j]) % MOD;
            if (ha >= MOD)
                ha -= MOD;
            ss.insert(ha);
        }
    }

    bool g0 = gaow(0, 0);
    bool g1 = gaol(0, 0);

    if (g0 && g1) {
        printf("First\n");
    } else if (g0) {
        if (k % 2)
            printf("First\n");
        else
            printf("Second\n");
    } else if (g1) {
        printf("Second\n");
    }

    return 0;

}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <cstring>

using namespace std;

const long long MOD = 1000000009LL;

int n, k;
long long pw[200000];
string str[200000];
set <long long> ss;
map <long long, bool> va;
map <long long, bool> vb;

bool gaol(int len, long long ha) {
    if (ss.count(ha) == 0)
        return true;
    if (vb.count(ha) != 0)
        return vb[ha];
    bool ans = false;
    for (char a = 'a'; a <= 'z'; a++) {
        long long hb = ha + (pw[len] * a) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        bool nxt = gaol(len + 1, hb);
        if (!nxt)
            return vb[ha] = true;
        ans |= nxt;
    }
    return vb[ha] = !ans;
}

bool gaow(int len, long long ha) {
    if (ss.count(ha) == 0)
        return false;
    if (va.count(ha) != 0)
        return va[ha];
    bool ans = false;
    for (char c = 'a'; c <= 'z'; c++) {
        long long hb = ha + (pw[len] * c) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= !gaow(len + 1, hb);
    }
    return va[ha] = ans;
}

int main() {

    ios::sync_with_stdio(false);

    cin >> n >> k;

    for (int i = 0; i < n; i++)
        cin >> str[i];

    pw[0] = 1LL;

    for (int i = 1; i <= 100010; i++)
        pw[i] = pw[i - 1] * 81799LL % MOD;

    ss.insert(0);

    for (int i = 0; i < n; i++) {
        long long ha = 0;
        for (int j = 0; j < (int) str[i].size(); j++) {
            ha = ha + (pw[j] * str[i][j]) % MOD;
            if (ha >= MOD)
                ha -= MOD;
            ss.insert(ha);
        }
    }

    bool g0 = gaow(0, 0);
    bool g1 = gaol(0, 0);

    if (g0 && g1) {
        printf("First\n");
    } else if (g0) {
        if (k % 2)
            printf("First\n");
        else
            printf("Second\n");
    } else if (g1) {
        printf("Second\n");
    }

    return 0;

}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <cstring>

using namespace std;

const long long MOD = 1000000009LL;

int n, k;
long long pw[200000];
string str[200000];
set <long long> ss;
map <long long, bool> va;
map <long long, bool> vb;

bool gaol(int len, long long ha) {
    if (ss.count(ha) == 0)
        return true;
    if (vb.count(ha) != 0)
        return vb[ha];
    bool ans = false;
    for (char a = 'a'; a <= 'z'; a++) {
        long long hb = ha + (pw[len] * a) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        bool nxt = gaol(len + 1, hb);
        if (!nxt)
            return vb[ha] = true;
        ans |= nxt;
    }
    return vb[ha] = !ans;
}

bool gaow(int len, long long ha) {
    if (ss.count(ha) == 0)
        return false;
    if (va.count(ha) != 0)
        return va[ha];
    bool ans = false;
    for (char c = 'a'; c <= 'z'; c++) {
        long long hb = ha + (pw[len] * c) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= !gaow(len + 1, hb);
    }
    return va[ha] = ans;
}

int main() {

    ios::sync_with_stdio(false);

    cin >> n >> k;

    for (int i = 0; i < n; i++)
        cin >> str[i];

    pw[0] = 1LL;

    for (int i = 1; i <= 100010; i++)
        pw[i] = pw[i - 1] * 1223863LL % MOD;

    ss.insert(0);

    for (int i = 0; i < n; i++) {
        long long ha = 0;
        for (int j = 0; j < (int) str[i].size(); j++) {
            ha = ha + (pw[j] * str[i][j]) % MOD;
            if (ha >= MOD)
                ha -= MOD;
            ss.insert(ha);
        }
    }

    bool g0 = gaow(0, 0);
    bool g1 = gaol(0, 0);

    if (g0 && g1) {
        printf("First\n");
    } else if (g0) {
        if (k % 2)
            printf("First\n");
        else
            printf("Second\n");
    } else if (g1) {
        printf("Second\n");
    }

    return 0;

}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <cstring>

using namespace std;

const long long MOD = 1000000009LL;

int n, k;
long long pw[200000];
string str[200000];
set <long long> ss;
map <long long, bool> va;
map <long long, bool> vb;

bool gaol(int len, long long ha) {
    if (ss.count(ha) == 0)
        return true;
    if (vb.count(ha) != 0)
        return vb[ha];
    bool ans = false;
    for (char a = 'a'; a <= 'z'; a++) {
        long long hb = ha + (pw[len] * a) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        bool nxt = gaol(len + 1, hb);
        if (!nxt)
            return vb[ha] = true;
        ans |= nxt;
    }
    return vb[ha] = !ans;
}

bool gaow(int len, long long ha) {
    if (ss.count(ha) == 0)
        return false;
    if (va.count(ha) != 0)
        return va[ha];
    bool ans = false;
    for (char c = 'a'; c <= 'z'; c++) {
        long long hb = ha + (pw[len] * c) % MOD;
        if (hb >= MOD)
            hb -= MOD;
        if (ss.count(hb) == 0)
            continue;
        ans |= !gaow(len + 1, hb);
    }
    return va[ha] = ans;
}

int main() {

    ios::sync_with_stdio(false);

    cin >> n >> k;

    for (int i = 0; i < n; i++)
        cin >> str[i];

    pw[0] = 1LL;

    for (int i = 1; i <= 100010; i++)
        pw[i] = pw[i - 1] * 81799LL % MOD;

    ss.insert(0);

    for (int i = 0; i < n; i++) {
        long long ha = 0;
        for (int j = 0; j < (int) str[i].size(); j++) {
            ha = ha + (pw[j] * str[i][j]) % MOD;
            if (ha >= MOD)
                ha -= MOD;
            ss.insert(ha);
        }
    }

    bool g0 = gaow(0, 0);
    bool g1 = gaol(0, 0);

    if (g0 && g1) {
        printf("First\n");
    } else if (g0) {
        if (k % 2)
            printf("First\n");
        else
            printf("Second\n");
    } else if (true) {
        printf("Second\n");
    }

    return 0;

}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>

using namespace std;
typedef long long int64;
typedef pair<int, int> PII;
const int MOD = 1000000007;
const double EPSILON = 1e-10;

#define FORU(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REPU(i, a, b) for (int i = (a); i < (b); ++i)
#define REPD(i, a, b) for (int i = (a); i > (b); --i)
#define SIZE(A) ((int) A.size())
#define PB(X) push_back(X)
#define MP(A, B) make_pair(A, B)

template<class T> inline T tmin(T a, T b) {return (a < b) ? a : b;}
template<class T> inline T tmax(T a, T b) {return (a > b) ? a : b;}
template<class T> inline T tabs(T a) {return (a > 0) ? a : -a;}
template<class T> T gcd(T a, T b) {if (b == 0) return a; return gcd(b, a % b);}

class Node {
public:
	Node() {
		value = '$';
	}
	~Node() {}

	Node(char c) {
		value = c;
	}

	char getChar() {
		return value;
	}

	void setChar(char c) {
		value = c;
	}

	void addChild(Node *s) {
		child.push_back(s);
	}

	vector<Node *> getChild() {
		return child;
	}

	Node *findChild(char c) {
		for (int i = 0; i < child.size(); ++i) {
			if (child[i]->getChar() == c) return child[i];
		}
		return NULL;
	}

	char value;
	vector<Node *> child;
};

class Trie
{
public:
	Trie();
	~Trie();
	void addString(string s);
	bool isWin(Node *node);
	bool isWin();
	bool isLose(Node *node);
	bool isLose();

	Node *root;
};

Trie::Trie() {
	root = new Node();
}

void Trie::addString(string s) {
	Node *current = root;
	for (int i = 0; i < s.size(); ++i) {
		Node *children = current->findChild(s[i]);
		if (children == NULL) {
			Node *tmp = new Node(s[i]);
			current->addChild(tmp);
			current = tmp;
		}
		else current = children;
	}
}

bool Trie::isWin(Node *node) {
	if (node->child.size() == 0) return false;
	bool ans = false;
	for (int i = 0; i < node->child.size(); ++i) {
		ans = (ans || !isWin(node->child[i]));
	}
	return ans;
}

bool Trie::isWin() {
	return isWin(root);
}

bool Trie::isLose(Node *node) {
	if (node->child.size() == 0) return true;
	bool ans = false;
	for (int i = 0; i < node->child.size(); ++i) {
		ans = (ans || !isLose(node->child[i]));
	}
	return ans;
}

bool Trie::isLose() {
	return isLose(root);
}

int main(int argc, char const *argv[]) {

    ios_base::sync_with_stdio(false);
    int n, k;
    string s;

    Trie *trie = new Trie();

    cin >> n >> k;

    REPU(i, 0, n) {
    	cin >> s;
    	trie->addString(s);
    }
    bool ansWin = trie->isWin();
    bool ansLose = trie->isLose();

    //printf("%d %d\n", ansWin, ansLose);

    if (ansWin && ansLose) printf("First\n");
    else if (ansWin && !ansLose) {
    	if (k % 2) printf("First\n");
    	else printf("Second\n");
    }
    else if (!ansWin && ansLose) printf("Second\n");

    return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>

using namespace std;
typedef long long int64;
typedef pair<int, int> PII;
const int MOD = 1000000007;
const double EPSILON = 1e-10;

#define FORU(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REPU(i, a, b) for (int i = (a); i < (b); ++i)
#define REPD(i, a, b) for (int i = (a); i > (b); --i)
#define SIZE(A) ((int) A.size())
#define PB(X) push_back(X)
#define MP(A, B) make_pair(A, B)

template<class T> inline T tmin(T a, T b) {return (a < b) ? a : b;}
template<class T> inline T tmax(T a, T b) {return (a > b) ? a : b;}
template<class T> inline T tabs(T a) {return (a > 0) ? a : -a;}
template<class T> T gcd(T a, T b) {if (b == 0) return a; return gcd(b, a % b);}

class Node {
public:
	Node() {
		value = '\0';
		isString = false;
	}
	~Node() {}

	Node(char c) {
		value = c;
		isString = false;
	}

	char getChar() {
		return value;
	}

	void setChar(char c) {
		value = c;
	}

	void addChild(Node *s) {
		child.push_back(s);
	}

	vector<Node *> getChild() {
		return child;
	}

	void markString() {
		isString = true;
	}

	bool getMark() {
		return isString;
	}

	Node *findChild(char c) {
		for (int i = 0; i < child.size(); ++i) {
			if (child[i]->getChar() == c) return child[i];
		}
		return NULL;
	}

	char value;
	bool isString;
	vector<Node *> child;
};

class Trie
{
public:
	Trie();
	~Trie();
	void addString(string s);
	bool isWin(Node *node);
	bool isWin();

	Node *root;
};

Trie::Trie() {
	root = new Node();
}

void Trie::addString(string s) {
	Node *current = root;
	for (int i = 0; i < s.size(); ++i) {
		Node *children = current->findChild(s[i]);
		if (children == NULL) {
			Node *tmp = new Node(s[i]);
			current->addChild(tmp);
			current = tmp;
		}
		else current = children;
		if (i == s.size() - 1) current->markString();
	}
}

bool Trie::isWin(Node *node) {
	if (node == NULL) return false;
	bool ans = false;
	for (int i = 0; i < node->child.size(); ++i) {
		ans = (ans || !isWin(node->child[i]));
	}
	return ans;
}

bool Trie::isWin() {
	return isWin(root);
}

int main(int argc, char const *argv[]) {

    ios_base::sync_with_stdio(false);
    int n, k;
    string s;

    Trie *trie = new Trie();

    cin >> n >> k;

    REPU(i, 0, n) {
    	cin >> s;
    	trie->addString(s);
    }
    bool ans = trie->isWin();
    if (ans && k % 2 == 0) printf("Second\n");
    else if (ans && k % 2 == 1) printf("First\n");
    else printf("Second\n");

    return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>

using namespace std;
typedef long long int64;
typedef pair<int, int> PII;
const int MOD = 1000000007;
const double EPSILON = 1e-10;

#define FORU(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REPU(i, a, b) for (int i = (a); i < (b); ++i)
#define REPD(i, a, b) for (int i = (a); i > (b); --i)
#define SIZE(A) ((int) A.size())
#define PB(X) push_back(X)
#define MP(A, B) make_pair(A, B)

template<class T> inline T tmin(T a, T b) {return (a < b) ? a : b;}
template<class T> inline T tmax(T a, T b) {return (a > b) ? a : b;}
template<class T> inline T tabs(T a) {return (a > 0) ? a : -a;}
template<class T> T gcd(T a, T b) {if (b == 0) return a; return gcd(b, a % b);}

class Node {
public:
	Node() {
		value = '\0';
		isString = false;
	}
	~Node() {}

	Node(char c) {
		value = c;
		isString = false;
	}

	char getChar() {
		return value;
	}

	void setChar(char c) {
		value = c;
	}

	void addChild(Node *s) {
		child.push_back(s);
	}

	vector<Node *> getChild() {
		return child;
	}

	void markString() {
		isString = true;
	}

	bool getMark() {
		return isString;
	}

	Node *findChild(char c) {
		for (int i = 0; i < child.size(); ++i) {
			if (child[i]->getChar() == c) return child[i];
		}
		return NULL;
	}

	char value;
	bool isString;
	vector<Node *> child;
};

class Trie
{
public:
	Trie();
	~Trie();
	void addString(string s);
	bool isWin(Node *node);
	bool isWin();
	bool isLose(Node *node);
	bool isLose();

	Node *root;
};

Trie::Trie() {
	root = new Node();
}

void Trie::addString(string s) {
	Node *current = root;
	for (int i = 0; i < s.size(); ++i) {
		Node *children = current->findChild(s[i]);
		if (children == NULL) {
			Node *tmp = new Node(s[i]);
			current->addChild(tmp);
			current = tmp;
		}
		else current = children;
		if (i == s.size() - 1) current->markString();
	}
}

bool Trie::isWin(Node *node) {
	if (node == NULL) return false;
	bool ans = false;
	for (int i = 0; i < node->child.size(); ++i) {
		ans = (ans || !isWin(node->child[i]));
	}
	return ans;
}

bool Trie::isWin() {
	for (int i = 0; i < root->child.size(); ++i) {
		if (isWin(root->child[i])) return true;
	}
	return false;
}

bool Trie::isLose(Node *node) {
	if (node == NULL) return true;
	bool ans = false;
	for (int i = 0; i < node->child.size(); ++i) {
		ans = (ans || !isLose(node->child[i]));
	}
	return ans;
}

bool Trie::isLose() {
	for (int i = 0; i < root->child.size(); ++i) {
		if (isLose(root->child[i])) return true;
	}
	return false;
}

int main(int argc, char const *argv[]) {

    ios_base::sync_with_stdio(false);
    int n, k;
    string s;

    Trie *trie = new Trie();

    cin >> n >> k;

    REPU(i, 0, n) {
    	cin >> s;
    	trie->addString(s);
    }
    bool ansWin = trie->isWin();
    bool ansLose = trie->isLose();

    if (ansWin && ansLose) printf("First\n");
    else if (ansWin && !ansLose) {
    	if (k % 2) printf("First\n");
    	else printf("Second\n");
    }
    else if (!ansWin && ansLose) printf("Second\n");

    return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>

using namespace std;
typedef long long int64;
typedef pair<int, int> PII;
const int MOD = 1000000007;
const double EPSILON = 1e-10;

#define FORU(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REPU(i, a, b) for (int i = (a); i < (b); ++i)
#define REPD(i, a, b) for (int i = (a); i > (b); --i)
#define SIZE(A) ((int) A.size())
#define PB(X) push_back(X)
#define MP(A, B) make_pair(A, B)

template<class T> inline T tmin(T a, T b) {return (a < b) ? a : b;}
template<class T> inline T tmax(T a, T b) {return (a > b) ? a : b;}
template<class T> inline T tabs(T a) {return (a > 0) ? a : -a;}
template<class T> T gcd(T a, T b) {if (b == 0) return a; return gcd(b, a % b);}

bool solve(vector<string> word) {
	vector<string> G[26];
	bool e[26];
	memset(e, 0, sizeof(e));
	REPU(i, 0, SIZE(word)) {
		if (word[i].size() == 1) return true;
		if (word[i].size() % 2) {
			e[word[i][0]-'a'] = true;
			G[word[i][0]-'a'].PB(word[i].substr(1, word[i].size()-1));
		}
	}

	REPU(i, 0, SIZE(word)) {
		if (word[i].size() % 2 == 0 && e[word[i][0]-'0']) {
			G[word[i][0]-'a'].PB(word[i].substr(1, word[i].size()-1));
		}
	}

	bool check = true, ans = false;
	FORU(i, 0, 25) {
		if (SIZE(G[i]) > 0) {
			check = false;
			if(!solve(G[i])) ans = true;
		}
	}
	if (check) return false;
	return ans;
}

int main(int argc, char const *argv[]) {

    ios_base::sync_with_stdio(false);
    vector<string> word;
    int n, k;
    string tmp;

    cin >> n >> k;
    REPU(i, 0, n) {
    	cin >> tmp;
    	word.PB(tmp);
    }

    if (solve(word)) {
    	if (k % 2) printf("First\n");
    	else printf("Second\n");
    }
    else printf("Second\n");

    return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>

using namespace std;
typedef long long int64;
typedef pair<int, int> PII;
const int MOD = 1000000007;
const double EPSILON = 1e-10;

#define FORU(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REPU(i, a, b) for (int i = (a); i < (b); ++i)
#define REPD(i, a, b) for (int i = (a); i > (b); --i)
#define SIZE(A) ((int) A.size())
#define PB(X) push_back(X)
#define MP(A, B) make_pair(A, B)

template<class T> inline T tmin(T a, T b) {return (a < b) ? a : b;}
template<class T> inline T tmax(T a, T b) {return (a > b) ? a : b;}
template<class T> inline T tabs(T a) {return (a > 0) ? a : -a;}
template<class T> T gcd(T a, T b) {if (b == 0) return a; return gcd(b, a % b);}

class Node {
public:
	Node() {
		value = '$';
	}
	~Node() {}

	Node(char c) {
		value = c;
	}

	char getChar() {
		return value;
	}

	void setChar(char c) {
		value = c;
	}

	void addChild(Node *s) {
		child.push_back(s);
	}

	vector<Node *> getChild() {
		return child;
	}

	Node *findChild(char c) {
		for (int i = 0; i < child.size(); ++i) {
			if (child[i]->getChar() == c) return child[i];
		}
		return NULL;
	}

	char value;
	vector<Node *> child;
};

class Trie
{
public:
	Trie();
	~Trie();
	void addString(string s);
	bool isWin(Node *node);
	bool isWin();
	bool isLose(Node *node);
	bool isLose();

	Node *root;
};

Trie::Trie() {
	root = new Node();
}

void Trie::addString(string s) {
	Node *current = root;
	for (int i = 0; i < s.size(); ++i) {
		Node *children = current->findChild(s[i]);
		if (children == NULL) {
			Node *tmp = new Node(s[i]);
			current->addChild(tmp);
			current = tmp;
		}
		else current = children;
	}
}

bool Trie::isWin(Node *node) {
	if (node->child.size() == 0) return true;
	bool ans = false;
	for (int i = 0; i < node->child.size(); ++i) {
		ans = (ans || !isWin(node->child[i]));
	}
	return ans;
}

bool Trie::isWin() {
	for (int i = 0; i < root->child.size(); ++i) {
		if (isWin(root->child[i])) return true;
	}
	return false;
}

bool Trie::isLose(Node *node) {
	if (node->child.size() == 0) return false;
	bool ans = false;
	for (int i = 0; i < node->child.size(); ++i) {
		ans = (ans || !isLose(node->child[i]));
	}
	return ans;
}

bool Trie::isLose() {
	for (int i = 0; i < root->child.size(); ++i) {
		if (isLose(root->child[i])) return true;
	}
	return false;
}

int main(int argc, char const *argv[]) {

    ios_base::sync_with_stdio(false);
    int n, k;
    string s;

    Trie *trie = new Trie();

    cin >> n >> k;

    REPU(i, 0, n) {
    	cin >> s;
    	trie->addString(s);
    }
    bool ansWin = trie->isWin();
    bool ansLose = trie->isLose();

    //printf("%d %d\n", ansWin, ansLose);

    if (ansWin && ansLose) printf("First\n");
    else if (ansWin && !ansLose) {
    	if (k % 2) printf("First\n");
    	else printf("Second\n");
    }
    else if (!ansWin && ansLose) printf("Second\n");

    return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>

using namespace std;
typedef long long int64;
typedef pair<int, int> PII;
const int MOD = 1000000007;
const double EPSILON = 1e-10;

#define FORU(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REPU(i, a, b) for (int i = (a); i < (b); ++i)
#define REPD(i, a, b) for (int i = (a); i > (b); --i)
#define SIZE(A) ((int) A.size())
#define PB(X) push_back(X)
#define MP(A, B) make_pair(A, B)

template<class T> inline T tmin(T a, T b) {return (a < b) ? a : b;}
template<class T> inline T tmax(T a, T b) {return (a > b) ? a : b;}
template<class T> inline T tabs(T a) {return (a > 0) ? a : -a;}
template<class T> T gcd(T a, T b) {if (b == 0) return a; return gcd(b, a % b);}

bool solve(vector<string> word) {
	vector<string> st;
	REPU(i, 0, SIZE(word)) {
		if (word[i].size() == 1) return true;
		if (word[i].size() % 2)
			st.PB(word[i].substr(1, word[i].size()-1));
	}
	if (SIZE(st) == 0) return false;
	return (!solve(st));
}

int main(int argc, char const *argv[]) {

    ios_base::sync_with_stdio(false);
    vector<string> word;
    int n, k;
    string tmp;
    bool e[256];

    memset(e, 0, sizeof(e));

    cin >> n >> k;
    REPU(i, 0, n) {
    	cin >> tmp;
    	word.PB(tmp);
    }

    if (solve(word)) {
    	if (k % 2) printf("First\n");
    	else printf("Second\n");
    }
    else printf("Second\n");

    return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>

using namespace std;
typedef long long int64;
typedef pair<int, int> PII;
const int MOD = 1000000007;
const double EPSILON = 1e-10;

#define FORU(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REPU(i, a, b) for (int i = (a); i < (b); ++i)
#define REPD(i, a, b) for (int i = (a); i > (b); --i)
#define SIZE(A) ((int) A.size())
#define PB(X) push_back(X)
#define MP(A, B) make_pair(A, B)

template<class T> inline T tmin(T a, T b) {return (a < b) ? a : b;}
template<class T> inline T tmax(T a, T b) {return (a > b) ? a : b;}
template<class T> inline T tabs(T a) {return (a > 0) ? a : -a;}
template<class T> T gcd(T a, T b) {if (b == 0) return a; return gcd(b, a % b);}

class Node {
public:
	Node() {
		value = '$';
	}
	~Node() {}

	Node(char c) {
		value = c;
	}

	char getChar() {
		return value;
	}

	void setChar(char c) {
		value = c;
	}

	void addChild(Node *s) {
		child.push_back(s);
	}

	vector<Node *> getChild() {
		return child;
	}

	Node *findChild(char c) {
		for (int i = 0; i < child.size(); ++i) {
			if (child[i]->getChar() == c) return child[i];
		}
		return NULL;
	}

	char value;
	vector<Node *> child;
};

class Trie
{
public:
	Trie();
	~Trie();
	void addString(string s);
	bool isWin(Node *node);
	bool isWin();
	bool isLose(Node *node);
	bool isLose();

	Node *root;
};

Trie::Trie() {
	root = new Node();
}

void Trie::addString(string s) {
	Node *current = root;
	for (int i = 0; i < s.size(); ++i) {
		Node *children = current->findChild(s[i]);
		if (children == NULL) {
			Node *tmp = new Node(s[i]);
			current->addChild(tmp);
			current = tmp;
		}
		else current = children;
	}
}

bool Trie::isWin(Node *node) {
	if (node->child.size() == 0) return false;
	bool ans = false;
	for (int i = 0; i < node->child.size(); ++i) {
		ans = (ans || !isWin(node->child[i]));
	}
	return ans;
}

bool Trie::isWin() {
	return isWin(root);
}

bool Trie::isLose(Node *node) {
	if (node->child.size() == 0) return true;
	bool ans = false;
	for (int i = 0; i < node->child.size(); ++i) {
		ans = (ans || !isLose(node->child[i]));
	}
	return ans;
}

bool Trie::isLose() {
	return isLose(root);
}

int main(int argc, char const *argv[]) {

    ios_base::sync_with_stdio(false);
    int n, k;
    string s;

    Trie *trie = new Trie();

    cin >> n >> k;

    REPU(i, 0, n) {
    	cin >> s;
    	trie->addString(s);
    }
    bool ansWin = trie->isWin();
    bool ansLose = trie->isLose();

    //printf("%d %d\n", ansWin, ansLose);

    if (ansWin && ansLose) printf("First\n");
    else if (ansWin && !ansLose) {
    	if (k % 2) printf("First\n");
    	else printf("Second\n");
    }
    else if (!ansWin) printf("Second\n");

    return 0;
}


#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cassert>

using namespace std;
typedef long long int64;
typedef pair<int, int> PII;
const int MOD = 1000000007;
const double EPSILON = 1e-10;

#define FORU(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define REPU(i, a, b) for (int i = (a); i < (b); ++i)
#define REPD(i, a, b) for (int i = (a); i > (b); --i)
#define SIZE(A) ((int) A.size())
#define PB(X) push_back(X)
#define MP(A, B) make_pair(A, B)

template<class T> inline T tmin(T a, T b) {return (a < b) ? a : b;}
template<class T> inline T tmax(T a, T b) {return (a > b) ? a : b;}
template<class T> inline T tabs(T a) {return (a > 0) ? a : -a;}
template<class T> T gcd(T a, T b) {if (b == 0) return a; return gcd(b, a % b);}

bool solve(vector<string> word) {
	vector<string> G[256];
	bool e[256];
	memset(e, 0, sizeof(e));
	REPU(i, 0, SIZE(word)) {
		if (word[i].size() == 1) return true;
		if (word[i].size() % 2) {
			e[word[i][0]] = true;
			G[word[i][0]].PB(word[i].substr(1, word[i].size()-1));
		}
	}

	REPU(i, 0, SIZE(word)) {
		if (word[i].size() % 2 == 0 && e[word[i][0]]) {
			G[word[i][0]].PB(word[i].substr(1, word[i].size()-1));
		}
	}

	bool check = true, ans = false;
	FORU(i, 0, 255) {
		if (SIZE(G[i]) > 0) {
			check = false;
			if(!solve(G[i])) ans = true;
		}
	}
	if (check) return false;
	return ans;
}

int main(int argc, char const *argv[]) {

    ios_base::sync_with_stdio(false);
    vector<string> word;
    int n, k;
    string tmp;
    bool e[256];

    memset(e, 0, sizeof(e));

    cin >> n >> k;
    REPU(i, 0, n) {
    	cin >> tmp;
    	word.PB(tmp);
    }

    if (solve(word)) {
    	if (k % 2) printf("First\n");
    	else printf("Second\n");
    }
    else printf("Second\n");

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
struct node{
  int s[26],ok[2];
}nn;
vector<node> V;
int p=0,n,len,k;
char str[100005];
void dfs(int id){
  int cl=0,cw=0,cnt=0;
  for(int i=0;i<26;i++){
    int to=V[id].s[i];
    if(to==-1) continue;
    cnt++;
    dfs(to);
    if(!V[to].ok[1]) cw=1;
    if(!V[to].ok[0]) cl=1;
  }
  if(!cnt){
    V[id].ok[0]=1;
    return;
  }
  if(cw) V[id].ok[1]=1;
  if(cl) V[id].ok[0]=1;
  return;
}
int main(){
  for(int i=0;i<26;i++) nn.s[i]=-1;
  for(int i=0;i<2;i++) nn.ok[i]=0;

  V.push_back(nn);
  scanf("%d %d",&n,&k);
  for(int i=0;i<n;i++){
    scanf("\n%s",str);
    len=strlen(str);
    int cp=0;
    for(int j=0;j<len;j++){
      if(V[cp].s[str[j]-'a']==-1){
        V[cp].s[str[j]-'a']=++p;
        V.push_back(nn);
      }
      cp=V[cp].s[str[j]-'a'];
    }
  }
  dfs(0);
  int a=V[0].ok[0],b=V[0].ok[1];
  if(a && b) printf("First\n");
  else if(a) printf("Second\n");
  else if(b) printf("%s\n",k&1?"First":"Second");
  return 0;
}


#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
struct node{
  int child[26],val;
  node(){
    for(int i=0;i<26;i++) child[i]=-1;
    val=-1;
  }
}s[100005];
int n,k,p=0;
char str[100005];
int dfs(int id,int cp){
  if(id==-1) return 1-cp;
  int mini=1,maxi=0;
  for(int i=0;i<26;i++){
    int v=dfs(s[id].child[i],1-cp);
    mini=min(mini,v);
    maxi=max(maxi,v);
  }
  if(cp==0) s[id].val=mini;
  else s[id].val=maxi;
  return s[id].val;
}
int main(){
  s[0]=node();
  scanf("%d %d",&n,&k);
  for(int i=1;i<=n;i++){
    scanf("\n%s",str);
    int len=strlen(str);
    int cur=0;
    for(int j=0;j<len;j++){
      if(s[cur].child[str[j]-'a']==-1){
        s[cur].child[str[j]-'a']=++p;
        s[p]=node();
      }
      cur=s[cur].child[str[j]-'a'];
    }
  }
  int x=dfs(0,0);
  if(x==1) printf("Second\n");
  else printf("First\n");
  return 0;
}


#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
struct node{
  int child[26],val[2];
  node(){
    for(int i=0;i<26;i++) child[i]=-1;
    val[0]=val[1]=0;
  }
}s[100005];
int n,k,p=0;
char str[100005];
int dfs(int id,int cp,int m){
  if(id==-1){
    if(m==0) return 1-cp;
    if(m==1) return cp;
  }
  int mini=1,maxi=0;
  for(int i=0;i<26;i++){
    int v=dfs(s[id].child[i],1-cp,m);
    mini=min(mini,v);
    maxi=max(maxi,v);
  }
  if(cp==0) s[id].val[m]=mini;
  else s[id].val[m]=maxi;
  return s[id].val[m];
}
int main(){
  s[0]=node();
  scanf("%d %d",&n,&k);
  for(int i=1;i<=n;i++){
    scanf("\n%s",str);
    int len=strlen(str);
    int cur=0;
    for(int j=0;j<len;j++){
      if(s[cur].child[str[j]-'a']==-1){
        s[cur].child[str[j]-'a']=++p;
        s[p]=node();
      }
      cur=s[cur].child[str[j]-'a'];
    }
  }
  int x=dfs(0,0,0);
  int y=dfs(0,0,1);
  if(x==0 && y==1) printf("Second\n");
  if(x==1 && y==1) printf("First\n");
  if(x==1 && y==0) printf("%s\n",(k%2==1)?"First":"Second");
  return 0;
}


#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
struct node{
  int child[26],val[2];
  node(){
    for(int i=0;i<26;i++) child[i]=-1;
    val[0]=val[1]=-1;
  }
}s[100005];
int n,k,p=0;
char str[100005];
int dfs(int id,int cp,int m){
  if(id==-1){
    if(m==0) return 1-cp;
    if(m==1) return cp;
  }
  int mini=1,maxi=0;
  for(int i=0;i<26;i++){
    int v=dfs(s[id].child[i],1-cp,m);
    mini=min(mini,v);
    maxi=max(maxi,v);
  }
  if(cp==0) s[id].val[m]=mini;
  else s[id].val[m]=maxi;
  return s[id].val[m];
}
int main(){
  s[0]=node();
  scanf("%d %d",&n,&k);
  for(int i=1;i<=n;i++){
    scanf("\n%s",str);
    int len=strlen(str);
    int cur=0;
    for(int j=0;j<len;j++){
      if(s[cur].child[str[j]-'a']==-1){
        s[cur].child[str[j]-'a']=++p;
        s[p]=node();
      }
      cur=s[cur].child[str[j]-'a'];
    }
  }
  int x=dfs(0,0,0);
  int y=dfs(0,0,1);
  if(x==0 && y==1) printf("Second\n");
  if(x==1 && y==1) printf("First\n");
  if(x==1 && y==0) printf("%s\n",(k%2==1)?"First":"Second");
  return 0;
}


#include<bits/stdc++.h>
using namespace std;
struct node{
  int s[26],ok[2];
}nn;
vector<node> V;
int p=0,n,len,k;
char str[100005];
void dfs(int id){
  int cl=0,cw=0,cnt=0;
  for(int i=0;i<26;i++){
    int to=V[id].s[i];
    if(to==-1) continue;
    cnt++;
    dfs(to);
    if(!V[to].ok[1]) cw=1;
    if(!V[to].ok[0]) cl=1;
  }
  if(!cnt){
    V[id].ok[0]=1;
    return;
  }
  if(cw) V[id].ok[1]=1;
  if(cl) V[id].ok[0]=1;
  return;
}
int main(){
  for(int i=0;i<26;i++) nn.s[i]=-1;
  for(int i=0;i<2;i++) nn.ok[i]=0;

  V.push_back(nn);
  scanf("%d %d",&n,&k);
  for(int i=0;i<n;i++){
    scanf("\n%s",str);
    len=strlen(str);
    int cp=0;
    for(int j=0;j<len;j++){
      if(V[cp].s[str[j]-'a']==-1){
        V[cp].s[str[j]-'a']=++p;
        V.push_back(nn);
      }
      cp=V[cp].s[str[j]-'a'];
    }
  }
  dfs(0);
  int a=V[0].ok[0],b=V[0].ok[1];
  if(a && b) printf("First\n");
  else if(a) printf("Second\n");
  else if(b) printf("%s\n",k&2?"First":"Second");
  return 0;
}


#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
struct node{
  int child[26],val;
  node(){
    for(int i=0;i<26;i++) child[i]=-1;
    val=-1;
  }
}s[100005];
int n,k,p=0;
char str[100005];
int dfs(int id,int cp){
  if(id==-1) return 1-cp;
  int mini=1,maxi=0;
  for(int i=0;i<26;i++){
    int v=dfs(s[id].child[i],1-cp);
    mini=min(mini,v);
    maxi=max(maxi,v);
  }
  if(cp==0) s[id].val=mini;
  else s[id].val=maxi;
  return s[id].val;
}
int main(){
  s[0]=node();
  scanf("%d %d",&n,&k);
  for(int i=1;i<=n;i++){
    scanf("\n%s",str);
    int len=strlen(str);
    int cur=0;
    for(int j=0;j<len;j++){
      if(s[cur].child[str[j]-'a']==-1){
        s[cur].child[str[j]-'a']=++p;
        s[p]=node();
      }
      cur=s[cur].child[str[j]-'a'];
    }
  }
  int x=dfs(0,0);
  if(x==1) printf("Second\n");
  else if(k&1) printf("First\n");
  else printf("Second\n");
  return 0;
}


#include<bits/stdc++.h>
using namespace std;
struct node{
  int s[26],ok[2];
}nn;
vector<node> V;
int p=0,n,len,k;
char str[100005];
void dfs(int id){
  int cl=0,cw=0,cnt=0;
  for(int i=0;i<26;i++){
    int to=V[id].s[i];
    if(to==-1) continue;
    cnt++;
    dfs(to);
    if(!V[to].ok[1]) cw=1;
    if(!V[to].ok[0]) cl=1;
  }
  if(!cnt){
    V[id].ok[0]=1;
    return;
  }
  if(cw) V[id].ok[1]=1;
  if(cl) V[id].ok[0]=1;
  return;
}
int main(){
  for(int i=0;i<26;i++) nn.s[i]=-1;
  for(int i=0;i<2;i++) nn.ok[i]=0;

  V.push_back(nn);
  scanf("%d %d",&n,&k);
  for(int i=0;i<n;i++){
    scanf("\n%s",str);
    len=strlen(str);
    int cp=0;
    for(int j=0;j<len;j++){
      if(V[cp].s[str[j]-'a']==-1){
        V[cp].s[str[j]-'a']=++p;
        V.push_back(nn);
      }
      cp=V[cp].s[str[j]-'a'];
    }
  }
  dfs(0);
  int a=V[0].ok[0],b=V[0].ok[1];
  if(a && b) printf("First\n");
  else if(a) printf("Second\n");
  else if(b) printf("%s\n",k&1?"First":"Second");
  else printf("Second\n");
  return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
//#include<set>
#include<stdlib.h>
#include<ctype.h>
#include<utility>
#include<cmath>
using namespace std;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define eps 1e-8
#define ll long long
#define i64 __int64
#define pb push_back
#define sz(b) (int)b.size()
#define lson k<<1
#define rson k<<1|1
#define INF 1000000005
#define MOD 1000000007
#define CLR(t,x) memset(t,x,sizeof(t));
#define REP(k,x,y) for(k=x;k<y;k++)
#define N 100005
char s[N];
int a,b,l,child[N][26],end[N],num[N],sum;
inline void insert()
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int k=s[i]-'a';
        if(!child[p][k])
        {
            memset(child[++l],0,sizeof(child[l]));
            p=child[p][k]=l;
        }
        else p=child[p][k];
        num[p]++;
    }
    end[p]=1;
}
inline void dfs(int u,int flag)
{
    if(end[u])
    {
        if(flag%2==1) a=1;
        else b=1;
        return;
    }
    int cnt=0;
    for(int i=0;i<26;i++) if(child[u][i]) cnt++;
    if(cnt>1&&flag%2==0||cnt==1)
    {
        for(int i=0;i<26;i++) if(child[u][i]) dfs(child[u][i],flag+1);
    }
    return;
}
inline void dfs2(int u,int flag)
{
    if(end[u])
    {
        if(flag%2==1) sum++;
        return;
    }
    for(int i=0;i<26;i++)
    {
        if(child[u][i])
        {
            dfs2(child[u][i],flag+1);
            if(!u)
            {
                if(!sum) b=1;
                else if(sum==num[child[u][i]]) a=1;
                sum=0;
            }
        }
    }
}
int main()
{
    int n,k;l=0;
    CLR(child[0],0);
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%s",s);
        insert();
    }
    a=b=sum=0;
    dfs(0,0);
    dfs2(0,0);
    if(k==54533605) cout<<a<<" "<<b<<endl;
    if(a&&b) puts("First");
    else if(!a) puts("Second");
    else if(!b&&a)
    {
        if(k&1) puts("First");
        else puts("Second");
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
//#include<set>
#include<stdlib.h>
#include<ctype.h>
#include<utility>
#include<cmath>
using namespace std;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define eps 1e-8
#define ll long long
#define i64 __int64
#define pb push_back
#define sz(b) (int)b.size()
#define lson k<<1
#define rson k<<1|1
#define INF 1000000005
#define MOD 1000000007
#define CLR(t,x) memset(t,x,sizeof(t));
#define REP(k,x,y) for(k=x;k<y;k++)
#define N 100005
char s[N];
int a,b,l,child[N][26],end[N];
inline void insert()
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int k=s[i]-'a';
        if(!child[p][k])
        {
            memset(child[++l],0,sizeof(child[l]));
            p=child[p][k]=l;
        }
        else p=child[p][k];
    }
    end[p]=1;
}
inline void dfs(int u,int flag)
{
    if(end[u])
    {
        if(flag%2==1) a=1;
        else b=1;
        return;
    }
    int cnt=0;
    for(int i=0;i<26;i++) if(child[u][i]) cnt++;
    if(cnt>1&&flag%2==0||cnt==1)
    {
        for(int i=0;i<26;i++) if(child[u][i]) dfs(child[u][i],flag+1);
    }
    return;
}
int main()
{
    int n,k;l=0;
    CLR(child[0],0);
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%s",s);
        insert();
    }
    dfs(0,0);
    if(k==54533605) cout<<a<<" "<<b<<endl;
    if(a&&b) puts("First");
    else if(!a) puts("Second");
    else if(!b&&a)
    {
        if(k&1) puts("First");
        else puts("Second");
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
//#include<set>
#include<stdlib.h>
#include<ctype.h>
#include<utility>
#include<cmath>
using namespace std;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define eps 1e-8
#define ll long long
#define i64 __int64
#define pb push_back
#define sz(b) (int)b.size()
#define lson k<<1
#define rson k<<1|1
#define INF 1000000005
#define MOD 1000000007
#define CLR(t,x) memset(t,x,sizeof(t));
#define REP(k,x,y) for(k=x;k<y;k++)
#define N 100005
char s[N];
int a,b,l,child[N][26],end[N],num[N],sum;
inline void insert()
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int k=s[i]-'a';
        if(!child[p][k])
        {
            memset(child[++l],0,sizeof(child[l]));
            p=child[p][k]=l;
        }
        else p=child[p][k];
        num[p]++;
    }
    end[p]=1;
}
inline void dfs(int u,int flag)
{
    if(end[u])
    {
        if(flag%2==1) a=1;
        else b=1;
        return;
    }
    int cnt=0;
    for(int i=0;i<26;i++) if(child[u][i]) cnt++;
    if(cnt>1&&flag%2==0||cnt==1)
    {
        for(int i=0;i<26;i++) if(child[u][i]) dfs(child[u][i],flag+1);
    }
    return;
}
inline void dfs2(int u,int flag)
{
    if(end[u])
    {
        if(flag%2==1) sum++;
        return;
    }
    for(int i=0;i<26;i++)
    {
        if(child[u][i])
        {
            dfs2(child[u][i],flag+1);
            if(!u)
            {
                if(!sum) b=1;
                else if(sum==num[child[u][i]]) a=1;
                sum=0;
            }
        }
    }
}
int main()
{
    int n,k;l=0;
    CLR(child[0],0);
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%s",s);
        insert();
    }
    a=b=sum=0;
    dfs(0,0);
    dfs2(0,0);
    if(a&&b) puts("First");
    else if(!a) puts("Second");
    else if(!b&&a)
    {
        if(k&1) puts("First");
        else puts("Second");
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
//#include<set>
#include<stdlib.h>
#include<ctype.h>
#include<utility>
#include<cmath>
using namespace std;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define eps 1e-8
#define ll long long
#define i64 __int64
#define pb push_back
#define sz(b) (int)b.size()
#define lson k<<1
#define rson k<<1|1
#define INF 1000000005
#define MOD 1000000007
#define CLR(t,x) memset(t,x,sizeof(t));
#define REP(k,x,y) for(k=x;k<y;k++)
#define N 100005
char s[N];
int l,child[N][26],dan[N],dp1[N],dp2[N];
inline void insert()
{
    int p=1;
    for(int i=0;s[i];i++)
    {
        int k=(int)(s[i]-'a');
        if(!child[p][k])
        {
            memset(child[++l],0,sizeof(child[l]));
            p=child[p][k]=l;
        }
        else p=child[p][k];
    }
    dan[p]=1;
}
inline void dfs(int u)
{
    if(dan[u])
    {
        dp1[u]=0;
        dp2[u]=1;
        return;
    }
    for(int i=0;i<26;i++)
    {
        if(child[u][i])
        {
            dfs(child[u][i]);
            dp1[u]|=(!dp1[child[u][i]]);
            dp2[u]|=(!dp2[child[u][i]]);
        }
    }
}
int main()
{
    int n,k;
    l=1;CLR(child[1],0);
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%s",s);
        insert();
    }
    dfs(1);
    if(!dp1[1]) puts("Second");
    else if(dp2[1]) puts("First");
    else
    {
        if(k%2) puts("First");
        else puts("Second");
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
//#include<set>
#include<stdlib.h>
#include<ctype.h>
#include<utility>
#include<cmath>
using namespace std;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define eps 1e-8
#define ll long long
#define i64 __int64
#define pb push_back
#define sz(b) (int)b.size()
#define lson k<<1
#define rson k<<1|1
#define INF 1000000005
#define MOD 1000000007
#define CLR(t,x) memset(t,x,sizeof(t));
#define REP(k,x,y) for(k=x;k<y;k++)
#define N 100005
char s[N];
int a,b,l,child[N][26],end[N];
inline void insert()
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int k=s[i]-'a';
        if(!child[p][k])
        {
            memset(child[++l],0,sizeof(child[l]));
            p=child[p][k]=l;
        }
        else p=child[p][k];
    }
    end[p]=1;
}
inline void dfs(int u,int flag)
{
    if(end[u])
    {
        if(flag) a=1;
        else b=1;
        return;
    }
    int cnt=0;
    for(int i=0;i<26;i++) if(child[u][i]) cnt++;
    if(cnt>1&&flag%2==0||cnt==1)
    {
        for(int i=0;i<26;i++) if(child[u][i]) dfs(child[u][i],flag+1);
    }
    return;
}
int main()
{
    int n,k;l=0;
    CLR(child[0],0);
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%s",s);
        insert();
    }
    dfs(0,0);
    if(a&&b) puts("First");
    else if(!a) puts("Second");
    else if(!b&&a)
    {
        if(k&1) puts("First");
        else puts("Second");
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
//#include<set>
#include<stdlib.h>
#include<ctype.h>
#include<utility>
#include<cmath>
using namespace std;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define eps 1e-8
#define ll long long
#define i64 __int64
#define pb push_back
#define sz(b) (int)b.size()
#define lson k<<1
#define rson k<<1|1
#define INF 1000000005
#define MOD 1000000007
#define CLR(t,x) memset(t,x,sizeof(t));
#define REP(k,x,y) for(k=x;k<y;k++)
#define N 100005
char s[N];
int l,child[N][26],dp1[N],dp2[N];
inline void insert()
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int k=s[i]-'a';
        if(!child[p][k])
        {
            memset(child[++l],0,sizeof(child[l]));
            p=child[p][k]=l;
        }
        else p=child[p][k];
    }
}
inline void dfs(int u)
{
    int leaf=1;
    for(int i=0;i<26;i++)
    {
        if(child[u][i])
        {
            leaf=0;
            dfs(child[u][i]);
            dp1[u]|=!dp1[child[u][i]];
            dp2[u]|=!dp2[child[u][i]];
        }
    }
    if(leaf) dp2[u]=1,dp1[u]=0;
}
int main()
{
    int n,k;
    l=0;CLR(child[0],0);
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%s",s);
        insert();
    }
    dfs(0);
    if(dp1[0]&&dp2[0]) puts("First");
    else if(!dp1[0]) puts("Second");
    else if(!dp2[0]&&dp1[0])
    {
        if(k&1) puts("First");
        else puts("Second");
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
//#include<set>
#include<stdlib.h>
#include<ctype.h>
#include<utility>
#include<cmath>
using namespace std;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define eps 1e-8
#define ll long long
#define i64 __int64
#define pb push_back
#define sz(b) (int)b.size()
#define lson k<<1
#define rson k<<1|1
#define INF 1000000005
#define MOD 1000000007
#define CLR(t,x) memset(t,x,sizeof(t));
#define REP(k,x,y) for(k=x;k<y;k++)
#define N 500005
char s[N];
int l,child[N][26],end[N],dp1[N],dp2[N];
inline void insert()
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int k=s[i]-'a';
        if(!child[p][k])
        {
            memset(child[++l],0,sizeof(child[l]));
            p=child[p][k]=l;
        }
        else p=child[p][k];
    }
    end[p]=1;
}
inline void dfs(int u)
{
    if(end[u])
    {
        dp1[u]=0;
        dp2[u]=1;
        return;
    }
    for(int i=0;i<26;i++)
    {
        if(child[u][i])
        {
            dfs(child[u][i]);
            dp1[u]|=(1-dp1[child[u][i]]);
            dp2[u]|=(1-dp2[child[u][i]]);
        }
    }
}
int main()
{
    int n,k;l=0;
    CLR(child[0],0);
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%s",s);
        insert();
    }
    dfs(0);
    if(dp1[0]&&dp2[0]) puts("First");
    else if(!dp1[0]) puts("Second");
    else if(!dp2[0]&&dp1[0])
    {
        if(k&1) puts("First");
        else puts("Second");
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
//#include<set>
#include<stdlib.h>
#include<ctype.h>
#include<utility>
#include<cmath>
using namespace std;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define eps 1e-8
#define ll long long
#define i64 __int64
#define pb push_back
#define sz(b) (int)b.size()
#define lson k<<1
#define rson k<<1|1
#define INF 1000000005
#define MOD 1000000007
#define CLR(t,x) memset(t,x,sizeof(t));
#define REP(k,x,y) for(k=x;k<y;k++)
#define N 100005
char s[N];
int l,child[N][26],dan[N],dp1[N],dp2[N];
inline void insert()
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int k=(int)(s[i]-'a');
        if(!child[p][k])
        {
            memset(child[++l],0,sizeof(child[l]));
            p=child[p][k]=l;
        }
        else p=child[p][k];
    }
    dan[p]=1;
}
inline void dfs(int u)
{
    if(dan[u])
    {
        dp1[u]=0;
        dp2[u]=1;
        return;
    }
    for(int i=0;i<26;i++)
    {
        if(child[u][i])
        {
            dfs(child[u][i]);
            dp1[u]|=(!dp1[child[u][i]]);
            dp2[u]|=(!dp2[child[u][i]]);
        }
    }
}
int main()
{
    int n,k;
    l=0;CLR(child[0],0);
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%s",s);
        insert();
    }
    dfs(0);
    if(!dp1[0]) puts("Second");
    else if(dp2[0]) puts("First");
    else
    {
        if(k%2) puts("First");
        else puts("Second");
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
//#include<set>
#include<stdlib.h>
#include<ctype.h>
#include<utility>
#include<cmath>
using namespace std;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define eps 1e-8
#define ll long long
#define i64 __int64
#define pb push_back
#define sz(b) (int)b.size()
#define lson k<<1
#define rson k<<1|1
#define INF 1000000005
#define MOD 1000000007
#define CLR(t,x) memset(t,x,sizeof(t));
#define REP(k,x,y) for(k=x;k<y;k++)
#define N 100005
char s[N];
int l,child[N][26],end[N],dp1[N],dp2[N];
inline void insert()
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int k=s[i]-'a';
        if(!child[p][k])
        {
            memset(child[++l],0,sizeof(child[l]));
            p=child[p][k]=l;
        }
        else p=child[p][k];
    }
    end[p]=1;
}
inline void dfs(int u)
{
    if(end[u])
    {
        dp1[u]=0;
        dp2[u]=1;
        return;
    }
    for(int i=0;i<26;i++)
    {
        if(child[u][i])
        {
            dfs(child[u][i]);
            dp1[u]|=(1-dp1[child[u][i]]);
            dp2[u]|=(1-dp2[child[u][i]]);
        }
    }
}
int main()
{
    int n,k;l=0;
    CLR(child[0],0);
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%s",s);
        insert();
    }
    dfs(0);
    if(dp1[0]&&dp2[0]) puts("First");
    else if(!dp1[0]) puts("Second");
    else if(!dp2[0]&&dp1[0])
    {
        if(k&1) puts("First");
        else puts("Second");
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
//#include<set>
#include<stdlib.h>
#include<ctype.h>
#include<utility>
#include<cmath>
using namespace std;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#define eps 1e-8
#define ll long long
#define i64 __int64
#define pb push_back
#define sz(b) (int)b.size()
#define lson k<<1
#define rson k<<1|1
#define INF 1000000005
#define MOD 1000000007
#define CLR(t,x) memset(t,x,sizeof(t));
#define REP(k,x,y) for(k=x;k<y;k++)
#define N 100005
char s[N];
int a,b,l,child[N][26],end[N];
inline void insert()
{
    int p=0;
    for(int i=0;s[i];i++)
    {
        int k=s[i]-'a';
        if(!child[p][k])
        {
            memset(child[++l],0,sizeof(child[l]));
            p=child[p][k]=l;
        }
        else p=child[p][k];
    }
    end[p]=1;
}
inline void dfs(int u,int flag)
{
    if(end[u])
    {
        if(flag%2==1) a=1;
        else b=1;
        return;
    }
    int cnt=0;
    for(int i=0;i<26;i++) if(child[u][i]) cnt++;
    if(cnt>1&&flag%2==0||cnt==1)
    {
        for(int i=0;i<26;i++) if(child[u][i]) dfs(child[u][i],flag+1);
    }
    return;
}
int main()
{
    int n,k;l=0;
    CLR(child[0],0);
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)
    {
        scanf("%s",s);
        insert();
    }
    dfs(0,0);
    if(a&&b) puts("First");
    else if(!a) puts("Second");
    else if(!b&&a)
    {
        if(k&1) puts("First");
        else puts("Second");
    }
    return 0;
}


/*
 * Author: Adarsh Pugalia
 * Algorithm: Implementation of tries.
 *				Insertion: O(N)
 * 				Search Word: O(N)
 *				Search Prefix: O(N)
 * 				Delete: O(N)
 *				N: the length of the string/prefix
 */

#include <iostream>
#include <stdio.h>
#include <vector>
#include <math.h>
#include <set>
#include <queue>
#include <algorithm>
#include <stack>
#include <cmath>
#include <cassert>

#define ll long long int
#define vi vector <int>
#define vl vector <ll>
#define vpii vector <pair<int, int> >
#define vpll vector <pair<ll, ll> >
#define pll pair<ll, ll>

#define f first
#define s second

#define sd(n) scanf("%d", &n)
#define sl(n) scanf("%lld", &n)

#define pb push_back
#define pob pop_back

#define max_size 505
#define max_capacity INT_MAX
#define max_string_size 1000
#define max_node_size 340
#define max_power 26
#define max_sieve_size 105

#define MOD 1000000007

using namespace std;

class TrieNode
{
	public:
		ll words;
		ll prefixes;
		TrieNode* child[26];
		ll dp[2];

		TrieNode()
		{
			words = 0;
			prefixes = 0;
			for(ll i=0; i<26; i++)
				child[i] = NULL;
		}
};

class Trie
{
	public:
		TrieNode *root;

		void init()
		{
			root = new TrieNode();
		}

		void insert(string word)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<word.length())
			{
				temp->prefixes++;
				if(temp->child[word[position]-'a']==NULL)
					temp->child[word[position]-'a'] = new TrieNode();

				temp = temp->child[word[position]-'a'];
				position++;
			}

			temp->words++;
		}

		ll count_words(string word)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<word.length())
			{
				if(temp->child[word[position]-'a']==NULL)
					return 0;

				temp = temp->child[word[position]-'a'];
				position++;
			}

			return temp->words;
		}

		ll count_prefixes(string prefix)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<prefix.length())
			{
				if(temp->child[prefix[position]-'a']==NULL)
					return 0;

				temp = temp->child[prefix[position]-'a'];
				position++;
			}

			return temp->prefixes;
		}

		bool remove(string word)
		{
			TrieNode* temp = root;
			ll position = 0;

			while(position<word.length())
			{
				if(temp->child[word[position]-'a']==NULL)
				{
					TrieNode *temp2 = root;
					ll temp_position = 0;
					while(position!=temp_position)
					{
						temp2->prefixes++;
						temp2 = temp2->child[word[temp_position]-'a'];
						temp_position++;
					}
					return false;
				}

				temp->prefixes--;
				temp = temp->child[word[position]-'a'];
				position++;
			}

			temp->words--;
			return true;
		}
}trie;

void dfs(TrieNode *temp, ll index)
{
	ll child_count = 0;
	ll win = 0, loss = 0;
	for(ll i=0; i<26; i++)
	{
		if(temp->child[i]!=NULL)
		{
			dfs(temp->child[i], index+1);
			child_count++;

			win = win | !temp->child[i]->dp[0];
			loss = loss | !temp->child[i]->dp[1];
		}
	}

	if(child_count==0)
	{
		temp->dp[0] = 0;
		temp->dp[1] = 1;
	}
	else
	{
		temp->dp[0] = win;
		temp->dp[1] = loss;
	}

	//cout<<index<<" "<<temp->dp[0]<<" "<<temp->dp[1]<<endl;
}

int main()
{
	ll n, m;
	cin>>n>>m;

	trie.init();
	for(ll i=0; i<n; i++)
	{
		string w;
		cin>>w;

		trie.insert(w);
	}

	dfs(trie.root, 0);

	if(trie.root->dp[0]==0)
	{
		cout<<"Second";
	}
	else if(trie.root->dp[0]==1 && trie.root->dp[1]==0)
	{
		if(m%2==1)
			cout<<"First";
		else
			cout<<"Second";
	}
	else if(trie.root->dp[0]==1 && trie.root->dp[1]==1)
	{
		cout<<"First";
	}

	return 0;
}


/*
 * Author: Adarsh Pugalia
 * Algorithm: Implementation of tries.
 *				Insertion: O(N)
 * 				Search Word: O(N)
 *				Search Prefix: O(N)
 * 				Delete: O(N)
 *				N: the length of the string/prefix
 */

#include <iostream>
#include <stdio.h>
#include <vector>
#include <math.h>
#include <set>
#include <queue>
#include <algorithm>
#include <stack>
#include <cmath>
#include <cassert>

#define ll long long int
#define vi vector <int>
#define vl vector <ll>
#define vpii vector <pair<int, int> >
#define vpll vector <pair<ll, ll> >
#define pll pair<ll, ll>

#define f first
#define s second

#define sd(n) scanf("%d", &n)
#define sl(n) scanf("%lld", &n)

#define pb push_back
#define pob pop_back

#define max_size 505
#define max_capacity INT_MAX
#define max_string_size 1000
#define max_node_size 340
#define max_power 26
#define max_sieve_size 105

#define MOD 1000000007

using namespace std;

class TrieNode
{
	public:
		ll words;
		ll prefixes;
		TrieNode* child[26];
		ll dp[2];

		TrieNode()
		{
			words = 0;
			prefixes = 0;
			for(ll i=0; i<26; i++)
				child[i] = NULL;
		}
};

class Trie
{
	public:
		TrieNode *root;

		void init()
		{
			root = new TrieNode();
		}

		void insert(string word)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<word.length())
			{
				temp->prefixes++;
				if(temp->child[word[position]-'a']==NULL)
					temp->child[word[position]-'a'] = new TrieNode();

				temp = temp->child[word[position]-'a'];
				position++;
			}

			temp->words++;
		}

		ll count_words(string word)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<word.length())
			{
				if(temp->child[word[position]-'a']==NULL)
					return 0;

				temp = temp->child[word[position]-'a'];
				position++;
			}

			return temp->words;
		}

		ll count_prefixes(string prefix)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<prefix.length())
			{
				if(temp->child[prefix[position]-'a']==NULL)
					return 0;

				temp = temp->child[prefix[position]-'a'];
				position++;
			}

			return temp->prefixes;
		}

		bool remove(string word)
		{
			TrieNode* temp = root;
			ll position = 0;

			while(position<word.length())
			{
				if(temp->child[word[position]-'a']==NULL)
				{
					TrieNode *temp2 = root;
					ll temp_position = 0;
					while(position!=temp_position)
					{
						temp2->prefixes++;
						temp2 = temp2->child[word[temp_position]-'a'];
						temp_position++;
					}
					return false;
				}

				temp->prefixes--;
				temp = temp->child[word[position]-'a'];
				position++;
			}

			temp->words--;
			return true;
		}
}trie;

void dfs(TrieNode *temp, ll index)
{
	ll child_count = 0;
	ll win = 0, loss = 0;
	for(ll i=0; i<26; i++)
	{
		if(temp->child[i]!=NULL)
		{
			dfs(temp->child[i], index+1);
			child_count++;

			win = win | !temp->child[i]->dp[0];
			loss = loss | !temp->child[i]->dp[1];
		}
	}

	if(child_count==0)
	{
		temp->dp[0] = 0;
		temp->dp[1] = 1;
	}
	else
	{
		temp->dp[0] = win;
		temp->dp[1] = loss;
	}

	cout<<index<<" "<<temp->dp[0]<<" "<<temp->dp[1]<<endl;
}

int main()
{
	ll n, m;
	cin>>n>>m;

	trie.init();
	for(ll i=0; i<n; i++)
	{
		string w;
		cin>>w;

		trie.insert(w);
	}

	dfs(trie.root, 0);

	if(trie.root->dp[0]==0)
	{
		cout<<"Second";
	}
	else if(trie.root->dp[0]==1 && trie.root->dp[1]==0)
	{
		if(m%2==1)
			cout<<"First";
		else
			cout<<"Second";
	}
	else if(trie.root->dp[0]==1 && trie.root->dp[1]==1)
	{
		cout<<"First";
	}

	return 0;
}


/*
 * Author: Adarsh Pugalia
 * Algorithm: Implementation of tries.
 *				Insertion: O(N)
 * 				Search Word: O(N)
 *				Search Prefix: O(N)
 * 				Delete: O(N)
 *				N: the length of the string/prefix
 */

#include <iostream>
#include <stdio.h>
#include <vector>
#include <math.h>
#include <set>
#include <queue>
#include <algorithm>
#include <stack>
#include <cmath>
#include <cassert>

#define ll long long int
#define vi vector <int>
#define vl vector <ll>
#define vpii vector <pair<int, int> >
#define vpll vector <pair<ll, ll> >
#define pll pair<ll, ll>

#define f first
#define s second

#define sd(n) scanf("%d", &n)
#define sl(n) scanf("%lld", &n)

#define pb push_back
#define pob pop_back

#define max_size 505
#define max_capacity INT_MAX
#define max_string_size 1000
#define max_node_size 340
#define max_power 26
#define max_sieve_size 105

#define MOD 1000000007

using namespace std;

class TrieNode
{
	public:
		ll words;
		ll prefixes;
		TrieNode* child[26];
		ll dp[2];

		TrieNode()
		{
			words = 0;
			prefixes = 0;
			for(ll i=0; i<26; i++)
				child[i] = NULL;
		}
};

class Trie
{
	public:
		TrieNode *root;

		void init()
		{
			root = new TrieNode();
		}

		void insert(string word)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<word.length())
			{
				temp->prefixes++;
				if(temp->child[word[position]-'a']==NULL)
					temp->child[word[position]-'a'] = new TrieNode();

				temp = temp->child[word[position]-'a'];
				position++;
			}

			temp->words++;
		}

		ll count_words(string word)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<word.length())
			{
				if(temp->child[word[position]-'a']==NULL)
					return 0;

				temp = temp->child[word[position]-'a'];
				position++;
			}

			return temp->words;
		}

		ll count_prefixes(string prefix)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<prefix.length())
			{
				if(temp->child[prefix[position]-'a']==NULL)
					return 0;

				temp = temp->child[prefix[position]-'a'];
				position++;
			}

			return temp->prefixes;
		}

		bool remove(string word)
		{
			TrieNode* temp = root;
			ll position = 0;

			while(position<word.length())
			{
				if(temp->child[word[position]-'a']==NULL)
				{
					TrieNode *temp2 = root;
					ll temp_position = 0;
					while(position!=temp_position)
					{
						temp2->prefixes++;
						temp2 = temp2->child[word[temp_position]-'a'];
						temp_position++;
					}
					return false;
				}

				temp->prefixes--;
				temp = temp->child[word[position]-'a'];
				position++;
			}

			temp->words--;
			return true;
		}
}trie;

void dfs(TrieNode *temp)
{
	ll child_count = 0;
	ll win = 0, loss = 0;
	for(ll i=0; i<26; i++)
	{
		if(temp->child[i]!=NULL)
		{
			dfs(temp->child[i]);
			child_count++;

			win = win | temp->child[i]->dp[1];
			loss = loss | temp->child[i]->dp[0];
		}
	}

	if(child_count==0)
	{
		temp->dp[0] = 0;
		temp->dp[1] = 1;
	}
	else
	{
		temp->dp[0] = win;
		temp->dp[1] = loss;
	}
}

int main()
{
	ll n, m;
	cin>>n>>m;

	trie.init();
	for(ll i=0; i<n; i++)
	{
		string w;
		cin>>w;

		trie.insert(w);
	}

	dfs(trie.root);

	if(trie.root->dp[0]==1 && trie.root->dp[1]==0)
	{
		if(m%2==1)
			cout<<"First";
		else
			cout<<"Second";
	}
	else if(trie.root->dp[0]==0 && trie.root->dp[1]==1)
	{
		cout<<"Second";
	}
	else
	{
		cout<<"First";
	}

	return 0;
}


/*
 * Author: Adarsh Pugalia
 * Algorithm: Implementation of tries.
 *				Insertion: O(N)
 * 				Search Word: O(N)
 *				Search Prefix: O(N)
 * 				Delete: O(N)
 *				N: the length of the string/prefix
 */

#include <iostream>
#include <stdio.h>
#include <vector>
#include <math.h>
#include <set>
#include <queue>
#include <algorithm>
#include <stack>
#include <cmath>
#include <cassert>

#define ll long long int
#define vi vector <int>
#define vl vector <ll>
#define vpii vector <pair<int, int> >
#define vpll vector <pair<ll, ll> >
#define pll pair<ll, ll>

#define f first
#define s second

#define sd(n) scanf("%d", &n)
#define sl(n) scanf("%lld", &n)

#define pb push_back
#define pob pop_back

#define max_size 505
#define max_capacity INT_MAX
#define max_string_size 1000
#define max_node_size 340
#define max_power 26
#define max_sieve_size 105

#define MOD 1000000007

using namespace std;

class TrieNode
{
	public:
		ll words;
		ll prefixes;
		TrieNode* child[26];
		ll dp[2];

		TrieNode()
		{
			words = 0;
			prefixes = 0;
			for(ll i=0; i<26; i++)
				child[i] = NULL;
		}
};

class Trie
{
	public:
		TrieNode *root;

		void init()
		{
			root = new TrieNode();
		}

		void insert(string word)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<word.length())
			{
				temp->prefixes++;
				if(temp->child[word[position]-'a']==NULL)
					temp->child[word[position]-'a'] = new TrieNode();

				temp = temp->child[word[position]-'a'];
				position++;
			}

			temp->words++;
		}

		ll count_words(string word)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<word.length())
			{
				if(temp->child[word[position]-'a']==NULL)
					return 0;

				temp = temp->child[word[position]-'a'];
				position++;
			}

			return temp->words;
		}

		ll count_prefixes(string prefix)
		{
			TrieNode *temp = root;
			ll position = 0;

			while(position<prefix.length())
			{
				if(temp->child[prefix[position]-'a']==NULL)
					return 0;

				temp = temp->child[prefix[position]-'a'];
				position++;
			}

			return temp->prefixes;
		}

		bool remove(string word)
		{
			TrieNode* temp = root;
			ll position = 0;

			while(position<word.length())
			{
				if(temp->child[word[position]-'a']==NULL)
				{
					TrieNode *temp2 = root;
					ll temp_position = 0;
					while(position!=temp_position)
					{
						temp2->prefixes++;
						temp2 = temp2->child[word[temp_position]-'a'];
						temp_position++;
					}
					return false;
				}

				temp->prefixes--;
				temp = temp->child[word[position]-'a'];
				position++;
			}

			temp->words--;
			return true;
		}
}trie;

void dfs(TrieNode *temp)
{
	ll child_count = 0;
	ll win = 0, loss = 1;
	for(ll i=0; i<26; i++)
	{
		if(temp->child[i]!=NULL)
		{
			dfs(temp->child[i]);
			child_count++;

			win = win | !temp->child[i]->dp[0];
			loss = loss | !temp->child[i]->dp[1];
		}
	}

	if(child_count==0)
	{
		temp->dp[0] = 0;
		temp->dp[1] = 1;
	}
	else
	{
		temp->dp[0] = win;
		temp->dp[1] = loss;
	}
}

int main()
{
	ll n, m;
	cin>>n>>m;

	trie.init();
	for(ll i=0; i<n; i++)
	{
		string w;
		cin>>w;

		trie.insert(w);
	}

	dfs(trie.root);

	if(trie.root->dp[0]==1 && trie.root->dp[1]==0)
	{
		if(m%2==1)
			cout<<"First";
		else
			cout<<"Second";
	}
	else if(trie.root->dp[0]==0 && trie.root->dp[1]==1)
	{
		cout<<"Second";
	}
	else
	{
		cout<<"First";
	}

	return 0;
}