/*
 * 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[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;
}


/*
 * 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 = 1, 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;
}


/*
 * 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 = 1, 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;
}


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

int ch[111111][26];
int win[111111], lose[111111];
int n, k, sz;
char s[111111];

void insert(char *s) {
    int v = 0, n = strlen(s);
    for (int i = 0; i < n; i ++) {
        int x = s[i] - 'a';
        if (!ch[v][x]) {
            memset(ch[sz], 0, sizeof(ch[sz]));
            ch[v][x] = sz ++;
        }
        v = ch[v][x];
    }
}
void dfs(int v) {
    win[v] = lose[v] = 0;
    int flag = 0;
    for (int i = 0; i < 26; i ++) if (ch[v][i]) {
        int u = ch[v][i];
        dfs(u);
        if (!win[u])  win[v] = 1;
        if(!lose[u])  lose[v] = 1;
    }
    if (flag) lose[v] = 1;
}
int main() {
    scanf("%d%d", &n, &k);
    sz = 1;
    memset(ch[0], 0, sizeof(ch[0]));
    for (int i = 1; i <= n; i ++) {
        scanf("%s", s);
        insert(s);
    }
    dfs(0);
    if (!win[0]) {
        puts("First");
        return 0;
    }
    else if (lose[0]) {
        puts("First");
        return 0;
    }
    else  {
        puts(k & 1 ? "First" : "Second");
        return 0;
    }
};


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

int ch[111111][26];
int win[111111], lose[111111];
int n, k, sz;
char s[111111];

void insert(char *s) {
    int v = 0, n = strlen(s);
    for (int i = 0; i < n; i ++) {
        int x = s[i] - 'a';
        if (!ch[v][x]) {
            memset(ch[sz], 0, sizeof(ch[sz]));
            ch[v][x] = sz ++;
        }
        v = ch[v][x];
    }
}
void dfs(int v) {
    win[v] = lose[v] = 0;
    int flag = 1;
    for (int i = 0; i < 26; i ++) if (ch[v][i]) {
        flag = 0;
        int u = ch[v][i];
        dfs(u);
        if (!win[u])  win[v] = 1;
        if(!lose[u])  lose[v] = 1;
    }
    if (flag) lose[v] = 1;
}
int main() {
    scanf("%d%d", &n, &k);
    sz = 1;
    memset(ch[0], 0, sizeof(ch[0]));
    for (int i = 1; i <= n; i ++) {
        scanf("%s", s);
        insert(s);
    }
    dfs(0);
    if (!win[0]) {
        puts("First");
        return 0;
    }
    else if (lose[0]) {
        puts("First");
        return 0;
    }
    else  {
        puts(k & 1 ? "First" : "Second");
        return 0;
    }
};


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

int ch[111111][26];
int win[111111], lose[111111];
int n, k, sz;
char s[100010];

void insert(char *s) {
    int v = 0, n = strlen(s);
    for (int i = 0; i < n; i ++) {
        int x = s[i] - 'a';
        if (!ch[v][x]) {
            memset(ch[sz], 0, sizeof(ch[sz]));
            ch[v][x] = sz++;
        }
        v = ch[v][x];
    }
}
void dfs(int v) {
    win[v] = lose[v] = 0;
    bool flag = 1;
    for (int i = 0; i < 26; i ++) if(ch[v][i]) {
        flag = 0;
        int u = ch[v][i];
        dfs(u);
        if (!win[u])  win[v] = 1;
        if (!lose[u]) lose[v] = 1;
    }
    if (flag) lose[v] = 1;
}
int main() {
    scanf("%d%d", &n, &k);
    memset(ch[0], 0, sizeof(ch[0]));
    sz = 1;
    for (int i = 1; i <= n; i ++) {
        scanf("%s", s);
        insert(s);
    }
    dfs(0);
    if (!lose[0] && win[0]) {
        puts(k & 1 ? "First" : "Second");
        return 0;
    }
    if (win[0] && lose[0]) {
        puts("First");
        return 0;
    }
    puts("Second");
    return 0;
}

/*
First
Second
*/


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

int ch[111111][26];
int win[111111], lose[111111];
int n, k, sz;
char s[100010];

void insert(char *s) {
    int v = 0, n = strlen(s);
    for (int i = 0; i < n; i ++) {
        int x = s[i] - 'a';
        if (!ch[v][x]) {
            memset(ch[sz], 0, sizeof(ch[sz]));
            ch[v][x] = sz++;
        }
        v = ch[v][x];
    }
}
void dfs(int v) {
    win[v] = lose[v] = 0;
    bool flag = 1;
    for (int i = 0; i < 26; i ++) if(ch[v][i]) {
        flag = 0;
        int u = ch[v][i];
        dfs(u);
        win[v] |= !win[u];
        lose[v] = !lose[u];
    }
    if (flag) lose[v] = 1;
}
int main() {
    scanf("%d%d", &n, &k);
    memset(ch[0], 0, sizeof(ch[0]));
    sz = 1;
    for (int i = 1; i <= n; i ++) {
        scanf("%s", s);
        insert(s);
    }
    dfs(0);
    if (k == 1) puts(win[0] ? "First" : "Second");
    else if(win[0] && lose[0]) puts("First");
    else if(win[0]) puts(k & 1 ? "First" : "Second");
    else puts("Second");
    return 0;
}

/*
First
Second
*/


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

int ch[111111][26];
int win[111111], lose[111111];
int n, k, sz;
char s[111111];

void insert(char *s) {
    int v = 0, n = strlen(s);
    for (int i = 0; i < n; i ++) {
        int x = s[i] - 'a';
        if (!ch[v][x]) {
            memset(ch[sz], 0, sizeof(ch[sz]));
            ch[v][x] = sz ++;
        }
        v = ch[v][x];
    }
}
void dfs(int v) {
    win[v] = lose[v] = 0;
    int flag = 1;
    for (int i = 0; i < 26; i ++) if (ch[v][i]) {
        flag = 0;
        int u = ch[v][i];
        dfs(u);
        if (!win[u])  win[v] = 1;
        if(!lose[u])  lose[v] = 1;
    }
    if (flag) lose[v] = 1;
}
int main() {
    scanf("%d%d", &n, &k);
    sz = 1;
    memset(ch[0], 0, sizeof(ch[0]));
    for (int i = 1; i <= n; i ++) {
        scanf("%s", s);
        insert(s);
    }
    dfs(0);
    if (!win[0]) {
        puts("Second");
        return 0;
    }
    else if (lose[0]) {
        puts("First");
        return 0;
    }
    else  {
        puts(k & 1 ? "First" : "Second");
        return 0;
    }
};


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

int ch[111111][26];
int win[111111], lose[111111];
int n, k, sz;
char s[100010];

void insert(char *s) {
    int v = 0, n = strlen(s);
    for (int i = 0; i < n; i ++) {
        int x = s[i] - 'a';
        if (!ch[v][x]) {
            memset(ch[sz], 0, sizeof(ch[sz]));
            ch[v][x] = sz++;
        }
        v = ch[v][x];
    }
}
void dfs(int v) {
    win[v] = lose[v] = 0;
    bool flag = 1;
    for (int i = 0; i < 26; i ++) if(ch[v][i]) {
        flag = 0;
        int u = ch[v][i];
        dfs(u);
        win[v] |= !win[u];
        lose[v] = !lose[u];
    }
    if (flag) lose[v] = 1;
}
int main() {
    scanf("%d%d", &n, &k);
    memset(ch[0], 0, sizeof(ch[0]));
    sz = 1;
    for (int i = 1; i <= n; i ++) {
        scanf("%s", s);
        insert(s);
    }
    dfs(0);
    if (!lose[0] && win[0]) {
        puts(k & 1 ? "First" : "Second");
        return 0;
    }
    if (win[0] && lose[0]) {
        puts("First");
        return 0;
    }
    puts("Second");
    return 0;
}

/*
First
Second
*/


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

int ch[111111][26];
int win[111111], lose[111111];
int n, k, sz;
char s[100010];

void insert(char *s) {
    int v = 0, n = strlen(s);
    for (int i = 0; i < n; i ++) {
        int x = s[i] - 'a';
        if (!ch[v][x]) {
            memset(ch[sz], 0, sizeof(ch[sz]));
            ch[v][x] = sz++;
        }
        v = ch[v][x];
    }
}
void dfs(int v) {
    win[v] = lose[v] = 0;
    bool flag = 1;
    for (int i = 0; i < 26; i ++) if(ch[v][i]) {
        flag = 0;
        int u = ch[v][i];
        dfs(u);
        if (!win[u])  win[v] = 1;
        if (!lose[u]) lose[v] = 1;
    }
    if (flag) lose[v] = 1;
}
int main() {
    scanf("%d%d", &n, &k);
    memset(ch[0], 0, sizeof(ch[0]));
    sz = 1;
    for (int i = 1; i <= n; i ++) {
        scanf("%s", s);
        insert(s);
    }
    dfs(0);
    if (!win[0]) puts("Second");
    else if (lose[0]) puts("First");
    else puts(k & 1 ? "First" : "Second");
    return 0;
}

/*
First
Second
*/


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <set>
#include <cstring>
#include <iomanip>
#include <map>
#include <algorithm>
#include <stack>
#include <queue>
#include <list>
#include <string>
#include <vector>
#include <new>
#include <bitset>
#include <ctime>
#include <cassert>
#include <stdint.h>
#include <unistd.h>

 using namespace std;

#define ll long long int
#define INF 1000000000
#define PI acos(-1.0)
#define EPS 1e-9

template < typename X > X gcd( X a, X b ) { if( !b ) return a ; else return gcd(b, a%b) ; }

typedef vector<int> vi;
typedef pair<int, int> ii;

const int N = 1e5 + 10 ;
int n, k, i, T[N][26], M[N << 2], l, t, j, c, p, P[N << 2] ;
char s[N] ;

int main() {
    scanf("%d %d", &n, &k ) ;
    p = 1 ;
    memset( M, -1, sizeof M ) ;
    for( i = 1; i <= n; ++i ) {
        scanf("%s", s) ;
        l = (int) strlen( s ) ;
        t = 0 ;
        for( j = 0; j < l; ++j ) {
            c = s[j] - 'a' ;
            if( !T[t][c] ) {
                T[t][c] = p++ ;
                P[p - 1] = t ;
            }
            t = T[t][c] ;
        }
        if( M[t] == -1 )
            M[t] = 0 ;
        for( j = l - 1; j >= 0 ; --j ) {
            c = s[j] - 'a' ;
            t = P[t] ;
            if( M[t] == -1 ) {
                M[t] = 1 - M[ T[t][c] ] ;
            }
            else {
                if( M[t] && M[ T[t][c] ] )
                    M[t] = 0 ;
            }
        }
    }
    if( M[0] == 0 ) {
        puts("Second");
        return 0 ;
    }
    if( k & 1 )
        puts("First");
    else
        puts("Second") ;
    return 0 ;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <set>
#include <cstring>
#include <iomanip>
#include <map>
#include <algorithm>
#include <stack>
#include <queue>
#include <list>
#include <string>
#include <vector>
#include <new>
#include <bitset>
#include <ctime>
#include <cassert>
#include <stdint.h>
#include <unistd.h>

 using namespace std;

#define ll long long int
#define INF 1000000000
#define PI acos(-1.0)
#define EPS 1e-9

template < typename X > X gcd( X a, X b ) { if( !b ) return a ; else return gcd(b, a%b) ; }

typedef vector<int> vi;
typedef pair<int, int> ii;

const int N = 1e5 + 10 ;
int n, k, i, T[N][26], M[N], l, t, j, c, p, P[N] ;
char s[N] ;

int main() {
    scanf("%d %d", &n, &k ) ;
    p = 1 ;
    memset( M, -1, sizeof M ) ;
    for( i = 1; i <= n; ++i ) {
        scanf("%s", s) ;
        l = (int) strlen( s ) ;
        t = 0 ;
        for( j = 0; j < l; ++j ) {
            c = s[j] - 'a' ;
            if( !T[t][c] ) {
                T[t][c] = p++ ;
                P[p - 1] = t ;
            }
            t = T[t][c] ;
        }
        if( M[t] == -1 )
            M[t] = 1 ;
        for( j = l - 1; j >= 0 ; --j ) {
            c = s[i] - 'a' ;
            t = P[t] ;
            if( M[t] == -1 ) {
                M[t] = 1 - M[ T[t][c] ] ;
            }
            else {
                if( M[t] && M[ T[t][c] ] )
                    M[t] = 0 ;
            }
        }
    }
    if( M[0] == 0 ) {
        puts("Second");
        return 0 ;
    }
    if( k & 1 )
        puts("First");
    else
        puts("Second") ;
    return 0 ;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <set>
#include <cstring>
#include <iomanip>
#include <map>
#include <algorithm>
#include <stack>
#include <queue>
#include <list>
#include <string>
#include <vector>
#include <new>
#include <bitset>
#include <ctime>
#include <cassert>
#include <stdint.h>
#include <unistd.h>

 using namespace std;

#define ll long long int
#define INF 1000000000
#define PI acos(-1.0)
#define EPS 1e-9

template < typename X > X gcd( X a, X b ) { if( !b ) return a ; else return gcd(b, a%b) ; }

typedef vector<int> vi;
typedef pair<int, int> ii;

const int N = 1e5 + 10 ;
int n, k, i, T[N][26], l, t, j, c, p, P[N << 2], W[N], L[N] ;
char s[N] ;

int main() {
    scanf("%d %d", &n, &k ) ;
    p = 1 ;
    memset( W, -1, sizeof W ) ;
    for( i = 1; i <= n; ++i ) {
        scanf("%s", s) ;
        l = (int) strlen( s ) ;
        t = 0 ;
        for( j = 0; j < l; ++j ) {
            c = s[j] - 'a' ;
            if( !T[t][c] ) {
                T[t][c] = p++ ;
                P[p - 1] = t ;
            }
            t = T[t][c] ;
        }
        if( W[t] == -1 ) {
            W[t] = 0 ;
            L[t] = 1 ;
        }
        for( j = l - 1; j >= 0 ; --j ) {
            c = s[j] - 'a' ;
            t = P[t] ;
            if( W[t] == -1 )
                W[t] = 1 - W[ T[t][c] ] ;
            else
                W[t] |= 1 - W[ T[t][c] ] ;
            if( L[t] == -1 )
                L[t] = 1 - L[ T[t][c] ] ;
            else
                L[t] |= 1 - W[ T[t][c] ] ;
        }
    }
    if( !W[0] ) {
        puts("Second");
        return 0;
    }
    if( L[0] ) {
        puts("First");
        return 0 ;
    }
    if( k & 1 )
        puts("First") ;
    else
        puts("Second") ;
    return 0 ;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <set>
#include <cstring>
#include <iomanip>
#include <map>
#include <algorithm>
#include <stack>
#include <queue>
#include <list>
#include <string>
#include <vector>
#include <new>
#include <bitset>
#include <ctime>
#include <cassert>
#include <stdint.h>
#include <unistd.h>

 using namespace std;

#define ll long long int
#define INF 1000000000
#define PI acos(-1.0)
#define EPS 1e-9

template < typename X > X gcd( X a, X b ) { if( !b ) return a ; else return gcd(b, a%b) ; }

typedef vector<int> vi;
typedef pair<int, int> ii;

const int N = 2e5 + 10 ;
int n, k, T[N][26], W[N], L[N], i, j, p, t, l, c ;
char s[N];

int main() {
    scanf("%d %d", &n, &k) ;
    getchar();
    p = 1 ;
    for( i = 1; i <= n; ++i ) {
        t = 0 ;
        scanf("%s", s) ;
        l = (int) strlen( s ) ;
        for( j = 0; j < l; ++j ) {
            c = s[j] - 'a' ;
            if( !T[t][c] ) {
                T[t][c] = p++ ;
            }
            t = T[t][c] ;
        }
    }
    for( i = p - 1; i >= 0; --i ) {
        for( j = 0; j < 26; ++j ) {
            if( T[i][j] )
                break;
        }
        if( j == 26 ) {
            W[i] = 0 ;
            L[i] = 1 ;
            continue ;
        }
        W[i] = L[i] = 0 ;
        for( j = 0; j < 26; ++j ) {
            if( T[i][j] ) {
                if( !W[ T[i][j] ] )
                    W[i] = 1;
                if( !L[ T[i][j] ] )
                    L[i] = 1;
            }
        }
    }
    if( !W[0] ) {
        puts("Second");
        return 0 ;
    }
    if( L[0] ) {
        puts("First");
        return 0 ;
    }
    if( k & 1 )
        puts("First");
    else
        puts("Second");
    return 0 ;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <set>
#include <cstring>
#include <iomanip>
#include <map>
#include <algorithm>
#include <stack>
#include <queue>
#include <list>
#include <string>
#include <vector>
#include <new>
#include <bitset>
#include <ctime>
#include <cassert>
#include <stdint.h>
#include <unistd.h>

 using namespace std;

#define ll long long int
#define INF 1000000000
#define PI acos(-1.0)
#define EPS 1e-9

template < typename X > X gcd( X a, X b ) { if( !b ) return a ; else return gcd(b, a%b) ; }

typedef vector<int> vi;
typedef pair<int, int> ii;

const int N = 1e5 + 10 ;
int n, k, i, T[N][26], M[N << 2], l, t, j, c, p, P[N << 2] ;
char s[N] ;

int main() {
    scanf("%d %d", &n, &k ) ;
    p = 1 ;
    memset( M, -1, sizeof M ) ;
    for( i = 1; i <= n; ++i ) {
        scanf("%s", s) ;
        l = (int) strlen( s ) ;
        t = 0 ;
        for( j = 0; j < l; ++j ) {
            c = s[j] - 'a' ;
            if( !T[t][c] ) {
                T[t][c] = p++ ;
                P[p - 1] = t ;
            }
            t = T[t][c] ;
        }
        if( M[t] == -1 )
            M[t] = 0 ;
        for( j = l - 1; j >= 0 ; --j ) {
            c = s[j] - 'a' ;
            t = P[t] ;
            if( M[t] == -1 ) {
                M[t] = 1 - M[ T[t][c] ] ;
            }
            else {
                if( M[t] && M[ T[t][c] ] )
                    M[t] = 0 ;
            }
        }
    }
    c = t = 0 ;
    for( i = 0; i < 26; ++i )
        if( T[0][i] ) {
            if( M[ T[0][i] ] )
                c++ ;
            else
                t++;
        }
    if( c > 0 && t > 0 )
        M[0] = 2 ;
    else
    if( c > 0 )
        M[0] = 0 ;
    else
        M[0] = 1 ;
    if( M[0] == 0 ) {
        puts("Second");
        return 0 ;
    }
    if( M[0] == 1 ) {
        if( k & 1 )
            puts("First");
        else
            puts("Second");
        return 0 ;
    }
    puts("First");
    return 0 ;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <set>
#include <cstring>
#include <iomanip>
#include <map>
#include <algorithm>
#include <stack>
#include <queue>
#include <list>
#include <string>
#include <vector>
#include <new>
#include <bitset>
#include <ctime>
#include <cassert>
#include <stdint.h>
#include <unistd.h>

 using namespace std;

#define ll long long int
#define INF 1000000000
#define PI acos(-1.0)
#define EPS 1e-9

template < typename X > X gcd( X a, X b ) { if( !b ) return a ; else return gcd(b, a%b) ; }

typedef vector<int> vi;
typedef pair<int, int> ii;

const int N = 1e5 + 10 ;
int n, k, i, T[N][26], l, t, j, c, p, P[N << 2], W[N], L[N] ;
char s[N] ;

int main() {
    scanf("%d %d", &n, &k ) ;
    p = 1 ;
    memset( W, -1, sizeof W ) ;
    for( i = 1; i <= n; ++i ) {
        scanf("%s", s) ;
        l = (int) strlen( s ) ;
        t = 0 ;
        for( j = 0; j < l; ++j ) {
            c = s[j] - 'a' ;
            if( !T[t][c] ) {
                T[t][c] = p++ ;
                P[p - 1] = t ;
            }
            t = T[t][c] ;
        }
    }
    for( i = n; i >= 0; --i ) {
        for( j = 0; j < 26; ++j ) {
            if( T[i][j] ) {
                break ;
            }
        }
        if( j == 26 ) {
            W[i] = 0 ;
            L[i] = 1 ;
            continue ;
        }
        W[i] = L[i] = 0 ;
        for( j = 0; j < 26; ++j ) {
            if( T[i][j] ) {
                if( !W[ T[i][j] ] )
                    W[i] = 1 ;
                if( !L[ T[i][j] ] )
                    L[i] = 1 ;
            }
        }
    }
    if( !W[0] ) {
        puts("Second");
        return 0;
    }
    if( L[0] ) {
        puts("First");
        return 0 ;
    }
    if( k & 1 )
        puts("First") ;
    else
        puts("Second") ;
    return 0 ;
}


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

using namespace std;

#define F first
#define S second
#define PB push_back
#define MP make_pair

const double PI = acos(-1.0);
const double EPS = 1e-9;
const int INF = 2123123123;
const int MOD = 1e7+7;

typedef long long ll;
typedef pair<int,int> pii;

#define ALL(c) (c).begin(), (c).end()
#define SZ(a) (int)(a).size()
#define RESET(a,x) memset(a,x,sizeof(a))
#define EXIST(a,s) ((s).find(a) != (s).end())
#define FORIT(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define MX(a,b) a = max((a),(b));
#define MN(a,b) a = min((a),(b));

inline void OPEN(const string &s) {
	freopen((s + ".in").c_str(), "r", stdin);
	freopen((s + ".out").c_str(), "w", stdout);
}

#define MAXN 100100

int n,k;
string s;
int thirty[MAXN];
map<int,int> cacha;
map<pair<int,int>,int> vis, memo;

int win(int p, int hash) {
	if (!EXIST(hash,cacha)) return (p+1)%2;
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	int ret = p%2;
	for (int i = 1; i <= 26; i++) {
		if (p%2) ret &= win(p+1, (hash + thirty[p] * i)%MOD);
		else ret |= win(p+1, (hash + thirty[p] * i)%MOD);
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int lose(int p, int hash) {
	if (!EXIST(hash,cacha)) return (p)%2;
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	int ret = (p+1)%2;
	for (int i = 1; i <= 26; i++) {
		if (p%2) ret |= lose(p+1, (hash + thirty[p] * i)%MOD);
		else ret &= lose(p+1, (hash + thirty[p] * i)%MOD);
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int main() {
	scanf("%d%d", &n, &k);
	thirty[0] = 1;
	for (int i = 1; i <= MAXN; i++) thirty[i] = (thirty[i-1] * 30) % MOD;
	cacha[0] = 1;
	for (int i = 0; i < n; i++) {
		cin >> s;
		int nn = SZ(s);
		int hash = 0;
		for (int j = 0; j < nn; j++) {
			hash = (hash + thirty[j] * (s[j] - 'a' + 1))%MOD;
			cacha[hash] = 1;
		}
	}
	int canwin = win(0, 0);
	vis.clear();
	int canlose = lose(0,0);
	if (canwin && canlose) puts("First");
	else if (canwin) {
		if (k%2) puts("First");
		else puts("Second");
	}
	else if (canlose) puts("Second");
	else puts("Second");
}


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

using namespace std;

// Abbrev
#define F first
#define S second
#define PB push_back
#define MP make_pair

// Macros
#define ALL(c) (c).begin(), (c).end()
#define SZ(a) (int)(a).size()
#define RESET(a,x) memset(a,x,sizeof(a))
#define EXIST(a,s) ((s).find(a) != (s).end())
#define FORIT(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define MX(a,b) a = max((a),(b));
#define MN(a,b) a = min((a),(b));

// Typedef
typedef long long ll;

// Const
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int INF = 2123123123;
const int MOD = 1e9+7;

// Functions
inline void OPEN(const string &s) {
	freopen((s + ".in").c_str(), "r", stdin);
	freopen((s + ".out").c_str(), "w", stdout);
}

#define MAXN 100100

int n,k;
int node;
int cacha[MAXN][26];
int vis[MAXN], memo[MAXN];

int win(int cur) {
	if (vis[cur]) return memo[cur];
	int ret = 0;
	for (int i = 0; i < 26; i++) {
		int v = cacha[cur][i];
		if (v >= 0) {
			if (!win(v)) ret = 1;
		}
	}
	vis[cur] = 1; memo[cur] = ret;
	return ret;
}

int lose(int cur) {
	if (vis[cur]) return memo[cur];
	int ret = 1;
	for (int i = 0; i < 26; i++) {
		int v = cacha[cur][i];
		if (v >= 0) {
			if (lose(v)) ret = 0;
		}
	}
	vis[cur] = 1; memo[cur] = ret;
	return ret;
}

int main() {
	scanf("%d%d", &n, &k);
	node = 1;
	RESET(cacha,-1);
	for (int i = 0; i < n; i++) {
		string s;
		cin >> s;
		int l = SZ(s);
		int curnode = 0;
		for (int j = 0; j < l; j++) {
			if (cacha[curnode][s[j]-'a'] < 0) {
				cacha[curnode][s[j]-'a'] = node++;
			}
			curnode = cacha[curnode][s[j]-'a'];
		}
	}
	int canwin = win(0);
	RESET(vis,0);
	int canlose = lose(0);
	if (canwin && canlose) puts("First");
	else if (canwin) {
		if (k%2) puts("First");
		else puts("Second");
	}
	else puts("Second");
	//printf("%d %d\n", canwin, canlose);

	return 0;
}


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

using namespace std;

#define F first
#define S second
#define PB push_back
#define MP make_pair

const double PI = acos(-1.0);
const double EPS = 1e-9;
const int INF = 2123123123;
const int MOD = 1e7+7;

typedef long long ll;
typedef pair<int,int> pii;

#define ALL(c) (c).begin(), (c).end()
#define SZ(a) (int)(a).size()
#define RESET(a,x) memset(a,x,sizeof(a))
#define EXIST(a,s) ((s).find(a) != (s).end())
#define FORIT(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define MX(a,b) a = max((a),(b));
#define MN(a,b) a = min((a),(b));

inline void OPEN(const string &s) {
	freopen((s + ".in").c_str(), "r", stdin);
	freopen((s + ".out").c_str(), "w", stdout);
}

#define MAXN 100100

int n,k;
string s;
int thirty[MAXN];
map<int,int> cacha;
map<pair<int,int>,int> vis, memo;

int win(int p, int hash) {
	if (!EXIST(hash,cacha)) return (p+1)%2;
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	int ret = p%2;
	for (int i = 1; i <= 26; i++) {
		if (p%2) ret &= win(p+1, (hash + thirty[p] * i)%MOD);
		else ret |= win(p+1, (hash + thirty[p] * i)%MOD);
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int lose(int p, int hash) {
	if (!EXIST(hash,cacha)) return (p)%2;
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	int ret = (p+1)%2;
	for (int i = 1; i <= 26; i++) {
		if (p%2) ret |= lose(p+1, (hash + thirty[p] * i)%MOD);
		else ret &= lose(p+1, (hash + thirty[p] * i)%MOD);
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int main() {
	scanf("%d%d", &n, &k);
	thirty[0] = 1;
	for (int i = 1; i < MAXN; i++) thirty[i] = (thirty[i-1] * 30) % MOD;
	cacha[0] = 1;
	for (int i = 0; i < n; i++) {
		cin >> s;
		int nn = SZ(s);
		int hash = 0;
		for (int j = 0; j < nn; j++) {
			hash = (hash + thirty[j] * (s[j] - 'a' + 1))%MOD;
			cacha[hash] = 1;
		}
	}
	int canwin = win(0, 0);
	vis.clear();
	int canlose = lose(0,0);
	if (canwin && canlose) puts("First");
	else if (canwin) {
		if (k%2) puts("First");
		else puts("Second");
	}
	else if (canlose) puts("Second");
	else puts("Second");
}


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

using namespace std;

#define F first
#define S second
#define PB push_back
#define MP make_pair

const double PI = acos(-1.0);
const double EPS = 1e-9;
const int INF = 2123123123;
const int MOD = 1e7+7;

typedef long long ll;
typedef pair<int,int> pii;

#define ALL(c) (c).begin(), (c).end()
#define SZ(a) (int)(a).size()
#define RESET(a,x) memset(a,x,sizeof(a))
#define EXIST(a,s) ((s).find(a) != (s).end())
#define FORIT(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define MX(a,b) a = max((a),(b));
#define MN(a,b) a = min((a),(b));

inline void OPEN(const string &s) {
	freopen((s + ".in").c_str(), "r", stdin);
	freopen((s + ".out").c_str(), "w", stdout);
}

#define MAXN 100100

int n,k;
string s;
int thirty[MAXN];
map<int,int> cacha;
map<pair<int,int>,int> vis, memo;

int win(int p, int hash) {
	if (!EXIST(hash,cacha)) return (p+1)%2;
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	int ret = p%2;
	for (int i = 1; i <= 26; i++) {
		if (p%2) ret &= win(p+1, (hash + thirty[p] * i)%MOD);
		else ret |= win(p+1, (hash + thirty[p] * i)%MOD);
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int lose(int p, int hash) {
	// 1 means lose and 0 means win
	if (!EXIST(hash,cacha)) return (p)%2;
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	int ret = (p+1)%2;
	for (int i = 1; i <= 26; i++) {
		if (p%2) ret |= lose(p+1, (hash + thirty[p] * i)%MOD);
		else ret &= lose(p+1, (hash + thirty[p] * i)%MOD);
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int main() {
	scanf("%d%d", &n, &k);
	thirty[0] = 1;
	for (int i = 1; i <= MAXN; i++) thirty[i] = (thirty[i-1] * 30) % MOD;
	cacha[0] = 1;
	for (int i = 0; i < n; i++) {
		cin >> s;
		int nn = SZ(s);
		int hash = 0;
		for (int j = 0; j < nn; j++) {
			hash = (hash + thirty[j] * (s[j] - 'a' + 1))%MOD;
			cacha[hash] = 1;
		}
	}
	int canwin = win(0, 0);
	vis.clear();
	int canlose = lose(0,0);
	if (canwin && canlose) puts("First");
	else if (canwin) {
		if (k%2) puts("First");
		else puts("Second");
	}
	else if (canlose) puts("Second");
	else puts("Second");

	printf("%d %d\n", canwin, canlose);
}


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

using namespace std;

#define F first
#define S second
#define PB push_back
#define MP make_pair

const double PI = acos(-1.0);
const double EPS = 1e-9;
const int INF = 2123123123;
const int MOD = 1e7+7;

typedef long long ll;
typedef pair<int,int> pii;

#define ALL(c) (c).begin(), (c).end()
#define SZ(a) (int)(a).size()
#define RESET(a,x) memset(a,x,sizeof(a))
#define EXIST(a,s) ((s).find(a) != (s).end())
#define FORIT(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define MX(a,b) a = max((a),(b));
#define MN(a,b) a = min((a),(b));

inline void OPEN(const string &s) {
	freopen((s + ".in").c_str(), "r", stdin);
	freopen((s + ".out").c_str(), "w", stdout);
}

#define MAXN 100100

int n,k;
string s;
int thirty[MAXN];
map<int,int> cacha;
map<pair<int,int>,int> vis, memo;

// kalo 0, berarti giliran pertama
// kalo 1, giliran kedua

int win(int p, int hash) {
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	// kalo lagi giliran pertama, ya gagal
	int ret = p%2;
	for (int i = 1; i <= 26; i++) {
		int newhash = (hash+thirty[p]*i)%MOD;
		// dia ternyata bisa jalan, masih win
		// kalo ada jalan yg dia pasti win, ya win
		if (EXIST(newhash,cacha)) {
			// kalo giliran kedua, dia usaha supaya gak pasti menang
			if (p%2) ret &= win(p+1, newhash);
			else ret |= win(p+1, newhash);
		}
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int lose(int p, int hash) {
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	// kalo lagi giliran pertama, ya berhasil
	int ret = (p)%2;
	int init = 0;
	for (int i = 1; i <= 26; i++) {
		int newhash = (hash+thirty[p]*i)%MOD;
		if (EXIST(newhash,cacha)) {
			if (!init) {
				ret = (p+1)%2;
				init = 1;
			}
			if (p%2) ret |= lose(p+1, newhash);
			// kalo lagi giliran pertama, dia nyari yg supaya gagal
			else ret &= lose(p+1, newhash);
		}
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int main() {
	scanf("%d%d", &n, &k);
	thirty[0] = 1;
	for (int i = 1; i < MAXN; i++) thirty[i] = (thirty[i-1] * 30) % MOD;
	for (int i = 0; i < n; i++) {
		cin >> s;
		int nn = SZ(s);
		int hash = 0;
		for (int j = 0; j < nn; j++) {
			hash = (hash + thirty[j] * (s[j] - 'a' + 1))%MOD;
			cacha[hash] = 1;
		}
	}
	int canwin = win(0, 0);
	vis.clear();
	int canlose = !lose(0,0);
	if (canwin && canlose) puts("First");
	else if (canwin) {
		if (k%2) puts("First");
		else puts("Second");
	}
	else if (canlose) puts("Second");
	else puts("Second");
	//printf("%d %d\n", canwin, canlose);
}


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

using namespace std;

#define F first
#define S second
#define PB push_back
#define MP make_pair

const double PI = acos(-1.0);
const double EPS = 1e-9;
const int INF = 2123123123;
const int MOD = 1e7+7;

typedef long long ll;
typedef pair<int,int> pii;

#define ALL(c) (c).begin(), (c).end()
#define SZ(a) (int)(a).size()
#define RESET(a,x) memset(a,x,sizeof(a))
#define EXIST(a,s) ((s).find(a) != (s).end())
#define FORIT(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define MX(a,b) a = max((a),(b));
#define MN(a,b) a = min((a),(b));

inline void OPEN(const string &s) {
	freopen((s + ".in").c_str(), "r", stdin);
	freopen((s + ".out").c_str(), "w", stdout);
}

#define MAXN 100100

int n,k;
string s;
int thirty[MAXN];
map<int,int> cacha;
map<pair<int,int>,int> vis, memo;

int win(int p, int hash) {
	if (!EXIST(hash,cacha)) return (p+1)%2;
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	int ret = p%2;
	for (int i = 1; i <= 26; i++) {
		if (p%2) ret &= win(p+1, (hash + thirty[p] * i)%MOD);
		else ret |= win(p+1, (hash + thirty[p] * i)%MOD);
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int lose(int p, int hash) {
	// 1 means lose and 0 means win
	if (!EXIST(hash,cacha)) return (p)%2;
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	int ret = (p+1)%2;
	for (int i = 1; i <= 26; i++) {
		if (p%2) ret |= lose(p+1, (hash + thirty[p] * i)%MOD);
		else ret &= lose(p+1, (hash + thirty[p] * i)%MOD);
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int main() {
	scanf("%d%d", &n, &k);
	thirty[0] = 1;
	for (int i = 1; i <= MAXN; i++) thirty[i] = (thirty[i-1] * 30) % MOD;
	cacha[0] = 1;
	for (int i = 0; i < n; i++) {
		cin >> s;
		int nn = SZ(s);
		int hash = 0;
		for (int j = 0; j < nn; j++) {
			hash = (hash + thirty[j] * (s[j] - 'a' + 1))%MOD;
			cacha[hash] = 1;
		}
	}
	int canwin = win(0, 0);
	vis.clear();
	int canlose = lose(0,0);
	if (canwin && canlose) puts("First");
	else if (canwin) {
		if (k%2) puts("First");
		else puts("Second");
	}
	else if (canlose) puts("Second");
	else puts("Second");

	//printf("%d %d\n", canwin, canlose);
}


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

using namespace std;

#define F first
#define S second
#define PB push_back
#define MP make_pair

typedef long long ll;

const double PI = acos(-1.0);
const double EPS = 1e-9;
const int INF = 2123123123;
const ll MOD = 1e12+7;

#define ALL(c) (c).begin(), (c).end()
#define SZ(a) (int)(a).size()
#define RESET(a,x) memset(a,x,sizeof(a))
#define EXIST(a,s) ((s).find(a) != (s).end())
#define FORIT(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define MX(a,b) a = max((a),(b));
#define MN(a,b) a = min((a),(b));

inline void OPEN(const string &s) {
	freopen((s + ".in").c_str(), "r", stdin);
	freopen((s + ".out").c_str(), "w", stdout);
}

#define MAXN 100100

int n,k;
string s;
ll thirty[MAXN];
map<ll,int> cacha;
map<pair<ll,ll>,int> vis, memo;

// kalo 0, berarti giliran pertama
// kalo 1, giliran kedua

int win(int p, int hash) {
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	// kalo lagi giliran pertama, ya gagal
	int ret = p%2;
	for (int i = 1; i <= 26; i++) {
		int newhash = (hash+thirty[p]*i)%MOD;
		// dia ternyata bisa jalan, masih win
		// kalo ada jalan yg dia pasti win, ya win
		if (EXIST(newhash,cacha)) {
			// kalo giliran kedua, dia usaha supaya gak pasti menang
			if (p%2) ret &= win(p+1, newhash);
			else ret |= win(p+1, newhash);
		}
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int lose(int p, int hash) {
	if (EXIST(MP(p,hash),vis)) return memo[MP(p,hash)];
	// kalo lagi giliran pertama, ya berhasil
	int ret = (p)%2;
	int init = 0;
	for (int i = 1; i <= 26; i++) {
		int newhash = (hash+thirty[p]*i)%MOD;
		if (EXIST(newhash,cacha)) {
			if (!init) {
				ret = (p+1)%2;
				init = 1;
			}
			if (p%2) ret |= lose(p+1, newhash);
			// kalo lagi giliran pertama, dia nyari yg supaya gagal
			else ret &= lose(p+1, newhash);
		}
	}
	vis[MP(p,hash)] = 1;
	memo[MP(p,hash)] = ret;
	return ret;
}

int main() {
	scanf("%d%d", &n, &k);
	thirty[0] = 1;
	for (int i = 1; i < MAXN; i++) thirty[i] = (thirty[i-1] * 30) % MOD;
	for (int i = 0; i < n; i++) {
		cin >> s;
		int nn = SZ(s);
		int hash = 0;
		for (int j = 0; j < nn; j++) {
			hash = (hash + thirty[j] * (s[j] - 'a' + 1))%MOD;
			cacha[hash] = 1;
		}
	}
	int canwin = win(0, 0);
	vis.clear();
	int canlose = !lose(0,0);
	if (canwin && canlose) puts("First");
	else if (canwin) {
		if (k%2) puts("First");
		else puts("Second");
	}
	else if (canlose) puts("Second");
	else puts("Second");
	//printf("%d %d\n", canwin, canlose);
}


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

using namespace std;

// Abbrev
#define F first
#define S second
#define PB push_back
#define MP make_pair

// Macros
#define ALL(c) (c).begin(), (c).end()
#define SZ(a) (int)(a).size()
#define RESET(a,x) memset(a,x,sizeof(a))
#define EXIST(a,s) ((s).find(a) != (s).end())
#define FORIT(it,v) for(__typeof(v.begin()) it = v.begin(); it != v.end(); ++it)
#define MX(a,b) a = max((a),(b));
#define MN(a,b) a = min((a),(b));

// Typedef
typedef long long ll;

// Const
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int INF = 2123123123;
const int MOD = 1e9+7;

// Functions
inline void OPEN(const string &s) {
	freopen((s + ".in").c_str(), "r", stdin);
	freopen((s + ".out").c_str(), "w", stdout);
}

#define MAXN 100100

int n,k;
int node;
int cacha[MAXN][26];
int vis[MAXN], memo[MAXN];

int win(int cur) {
	if (vis[cur]) return memo[cur];
	int ret = 0;
	for (int i = 0; i < 26; i++) {
		int v = cacha[cur][i];
		if (v >= 0) {
			if (!win(v)) ret = 1;
		}
	}
	vis[cur] = 1; memo[cur] = ret;
	return ret;
}

int lose(int cur) {
	if (vis[cur]) return memo[cur];
	int ret = 1;
	for (int i = 0; i < 26; i++) {
		int v = cacha[cur][i];
		if (v >= 0) {
			ret = 0;
			if (!lose(v)) {
				ret = 1;
				break;
			}
		}
	}
	vis[cur] = 1; memo[cur] = ret;
	return ret;
}

int main() {
	scanf("%d%d", &n, &k);
	node = 1;
	RESET(cacha,-1);
	for (int i = 0; i < n; i++) {
		string s;
		cin >> s;
		int l = SZ(s);
		int curnode = 0;
		for (int j = 0; j < l; j++) {
			if (cacha[curnode][s[j]-'a'] < 0) {
				cacha[curnode][s[j]-'a'] = node++;
			}
			curnode = cacha[curnode][s[j]-'a'];
		}
	}
	int canwin = win(0);
	RESET(vis,0);
	int canlose = lose(0);
	if (canwin && canlose) puts("First");
	else if (canwin) {
		if (k%2) puts("First");
		else puts("Second");
	}
	else puts("Second");
	//printf("%d %d\n", canwin, canlose);

	return 0;
}


#include <cstdio>
#include <vector>
#define N 1000000+1
using namespace std;

int maxUsed=0;
char value[N];
char get[N];
vector<int> child[N];

void maketree(int parent=0,int index=0){

    if(get[index]=='\0') return;

    int i;
    for(i=0;i<child[parent].size();i++){
        if(value[child[parent][i]]==get[index]) break;
    }

    if(i<child[parent].size()){
        maketree(child[parent][i],index+1);
    }
    else{
        value[++maxUsed]=get[index];
        child[parent].push_back(maxUsed);
        maketree(maxUsed,index+1);
    }
}

bool canWin(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canWin(child[parent][i])) return 1;
    }

    return 0;
}

bool canLoss(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canLoss(child[parent][i])) return 1;
    }

    return 0;
}

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
        maketree();
    }

    bool winAbility=canWin(),lossAbility=canLoss(),result;

    if(winAbility&&lossAbility) result=1;
    else{
        if(winAbility) result=k%2;
        else result=0;
    }

    //if(k==6) printf("%d,%d",winAbility,lossAbility);
    printf("%s\n",(result)?"First":"Second");
}

int main()
{
    //freopen("sampleInput.txt","r",stdin);
    solve();
    return 0;
}


#include <cstdio>
#include <vector>
#define N 1000000+1
using namespace std;

int maxUsed=0;
char value[N];
char get[N];
vector<int> child[N];

void maketree(int parent=0,int index=0){

    if(get[index]=='\0') return;

    int i;
    for(i=0;i<child[parent].size();i++){
        if(value[child[parent][i]]==get[index]) break;
    }

    if(i<child[parent].size()){
        maketree(child[parent][i],index+1);
    }
    else{
        value[++maxUsed]=get[index];
        child[parent].push_back(maxUsed);
        maketree(maxUsed,index+1);
    }
}

bool canWin(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canWin(child[parent][i])) return 1;
    }

    return 0;
}

bool canLoss(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canLoss(child[parent][i])) return 1;
    }

    return 0;
}

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
        maketree();
    }

    bool winAbility=canWin(),lossAbility=canLoss(),result;

    if(winAbility&&lossAbility) result=1;
    else{
        if(winAbility) result=k%2;
        else result=0;
    }

    if(k==6) printf("%d,%d",winAbility,lossAbility);
    printf("%s\n",(result)?"First":"Second");
}

int main()
{
    freopen("sampleInput.txt","r",stdin);
    solve();
    return 0;
}


#include <cstdio>
#include <vector>
#define N 100000+1
using namespace std;

int maxUsed=0;
char value[N];
char get[N];
vector<int> child[N];

void maketree(int parent=0,int index=0){

    if(get[index]=='\0') return;

    int i;
    for(i=0;i<child[parent].size();i++){
        if(value[child[parent][i]]==get[index]) break;
    }

    if(i<child[parent].size()){
        maketree(child[parent][i],index+1);
    }
    else{
        value[++maxUsed]=get[index];
        child[parent].push_back(maxUsed);
        maketree(maxUsed,index+1);
    }
}

bool canWin(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canWin(child[parent][i])) return 1;
    }

    return 0;
}

bool canLoss(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canLoss(child[parent][i])) return 1;
    }

    return 0;
}

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
        maketree();
    }

    bool winAbility=canWin(),lossAbility=canLoss(),result;

    if(winAbility&&lossAbility) result=1;
    else{
        if(winAbility) result=k%2;
        else result=0;
    }

    //if(k==6) printf("%d,%d",winAbility,lossAbility);
    printf("%s\n",(result)?"First":"Second");
}

int main()
{
    freopen("sampleInput.txt","r",stdin);
    solve();
    return 0;
}


#include <cstdio>
#include <vector>
#define N 100000+1
using namespace std;

int maxUsed=0;
char value[N];
char get[N];
vector<int> child[N];

void maketree(int parent=0,int index=0){

    if(get[index]=='\0') return;

    int i;
    for(i=0;i<child[parent].size();i++){
        if(value[child[parent][i]]==get[index]) break;
    }

    if(i<child[parent].size()){
        maketree(child[parent][i],index+1);
    }
    else{
        value[++maxUsed]=get[index];
        child[parent].push_back(maxUsed);
        maketree(maxUsed,index+1);
    }
}

bool canWin(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canWin(child[parent][i])) return 1;
    }

    return 0;
}

bool canLoss(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canLoss(child[parent][i])) return 1;
    }

    return 0;
}

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
        maketree();
    }

    bool winAbility=canWin(),lossAbility=canLoss(),result;

    if(winAbility&&lossAbility) result=1;
    else{
        if(winAbility) result=k%2;
        else result=0;
    }
    printf("%d\n",k);
    if(k==6) printf("%d,%d",winAbility,lossAbility);
    printf("%s\n",(result)?"First":"Second");
}

int main()
{
    //freopen("sampleInput.txt","r",stdin);
    solve();
    return 0;
}


#include <cstdio>
#include <vector>
#define N 100000+1
using namespace std;

int maxUsed=0;
char value[N];
char get[N];
vector<int> child[N];

void maketree(int parent=0,int index=0){

    if(get[index]=='\0') return;

    int i;
    for(i=0;i<child[parent].size();i++){
        if(value[child[parent][i]]==get[index]) break;
    }

    if(i<child[parent].size()){
        maketree(child[parent][i],index+1);
    }
    else{
        value[++maxUsed]=get[index];
        child[parent].push_back(maxUsed);
        maketree(maxUsed,index+1);
    }
}

bool canWin(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canWin(child[parent][i])) return 1;
    }

    return 0;
}

bool canLoss(int parent=0){

    if(child[parent].empty()) return 1;

    for(int i=0;i<child[parent].size();i++){
        if(!canLoss(child[parent][i])) return 1;
    }

    return 0;
}

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
        maketree();
    }

    bool winAbility=canWin(),lossAbility=canLoss(),result;

    if(winAbility&&lossAbility) result=1;
    else{
        if(winAbility) result=k%2;
        else result=0;
    }

    //if(k==6) printf("%d,%d",winAbility,lossAbility);
    printf("%s\n",(result)?"First":"Second");
}

int main()
{
    //freopen("sampleInput.txt","r",stdin);
    solve();
    return 0;
}


#include <cstdio>
#include <vector>
#define N 100000+1
using namespace std;

int maxUsed=0;
char value[N];
char get[N];
vector<int> child[N];

void maketree(int parent=0,int index=0){

    if(get[index]=='\0') return;

    int i;
    for(i=0;i<child[parent].size();i++){
        if(value[child[parent][i]]==get[index]) break;
    }

    if(i<child[parent].size()){
        maketree(child[parent][i],index+1);
    }
    else{
        value[++maxUsed]=get[index];
        child[parent].push_back(maxUsed);
        maketree(maxUsed,index+1);
    }
}

bool canWin(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canWin(child[parent][i])) return 1;
    }

    return 0;
}

bool canLoss(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canLoss(child[parent][i])) return 1;
    }

    return 0;
}

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
        maketree();
    }

    bool winAbility=canWin(),lossAbility=canLoss(),result;

    if(winAbility&&lossAbility) result=1;
    else{
        if(winAbility) result=k%2;
        else result=0;
    }

    if(k==6) printf("%d,%d",winAbility,lossAbility);
    printf("%s\n",(result)?"First":"Second");
}

int main()
{
    freopen("sampleInput.txt","r",stdin);
    solve();
    return 0;
}


#include<cstdio>
using namspace std;

char get[100000+1]

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
    }

    printf("%s\n",(k%2)?"First":"Second");
}

int main()
{
    solve();
    return 0;
}


#include <cstdio>
#include <vector>
#define N 100000+1
using namespace std;

int maxUsed=0;
char value[N];
char get[N];
vector<int> child[N];

void maketree(int parent=0,int index=0){

    if(get[index]=='\0') return;

    int i;
    for(i=0;i<child[parent].size();i++){
        if(value[child[parent][i]]==get[index]) break;
    }

    if(i<child[parent].size()){
        maketree(child[parent][i],index+1);
    }
    else{
        value[++maxUsed]=get[index];
        child[parent].push_back(maxUsed);
        maketree(maxUsed,index+1);
    }
}

bool canWin(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canWin(child[parent][i])) return 1;
    }

    return 0;
}

bool canLoss(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canLoss(child[parent][i])) return 1;
    }

    return 0;
}

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
        maketree();
    }

    bool winAbility=canWin(),lossAbility=canLoss(),result;

    if(winAbility&&lossAbility) result=1;
    else{
        if(winAbility) result=k%2;
        else result=0;
    }

    printf("%s\n",(result)?"First":"Second");
}

int main()
{
    //freopen("sampleInput.txt","r",stdin);
    solve();
    return 0;
}


#include <cstdio>
#include <vector>
#define N 100000+1
using namespace std;

int maxUsed=0;
char value[N];
char get[N];
vector<int> child[N];

void maketree(int parent=0,int index=0){

    if(get[index]=='\0') return;

    int i;
    for(i=0;i<child[parent].size();i++){
        if(value[child[parent][i]]==get[index]) break;
    }

    if(i<child[parent].size()){
        maketree(child[parent][i],index+1);
    }
    else{
        value[++maxUsed]=get[index];
        child[parent].push_back(maxUsed);
        maketree(maxUsed,index+1);
    }
}

bool canWin(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canWin(child[parent][i])) return 1;
    }

    return 0;
}

bool canLoss(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canLoss(child[parent][i])) return 1;
    }

    return 0;
}

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
        maketree();
    }

    bool winAbility=canWin(),lossAbility=canLoss(),result;

    if(winAbility&&lossAbility) result=1;
    else{
        if(winAbility) result=k%2;
        else result=0;
    }

    printf("%s\n",(result)?"First":"Second");
}

int main()
{
    solve();
    return 0;
}


#include <cstdio>
#include <vector>
#define N 100000+1
using namespace std;

int maxUsed=0;
char value[N];
char get[N];
vector<int> child[N];

void maketree(int parent=0,int index=0){

    if(get[index]=='\0') return;

    int i;
    for(i=0;i<child[parent].size();i++){
        if(value[child[parent][i]]==get[index]) break;
    }

    if(i<child[parent].size()){
        maketree(child[parent][i],index+1);
    }
    else{
        value[++maxUsed]=get[index];
        child[parent].push_back(maxUsed);
        maketree(maxUsed,index+1);
    }
}

bool canWin(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canWin(child[parent][i])) return 1;
    }

    return 0;
}

bool canLoss(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canLoss(child[parent][i])) return 1;
    }

    return 0;
}

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
        maketree();
    }

    bool winAbility=canWin(),lossAbility=canLoss(),result;

    if(winAbility&&lossAbility) result=1;
    else{
        if(winAbility) result=k%2;
        else result=0;
    }

    if(k==6) printf("%d,%d",winAbility,lossAbility);
    printf("%s\n",(result)?"First":"Second");
}

int main()
{
    //freopen("sampleInput.txt","r",stdin);
    solve();
    return 0;
}


#include <cstdio>
#include <vector>
#define N 100000+1
using namespace std;

int maxUsed=0;
char value[N];
char get[N];
vector<int> child[N];

void maketree(int parent=0,int index=0){

    if(get[index]=='\0') return;

    int i;
    for(i=0;i<child[parent].size();i++){
        if(value[child[parent][i]]==get[index]) break;
    }

    if(i<child[parent].size()){
        maketree(child[parent][i],index+1);
    }
    else{
        value[++maxUsed]=get[index];
        child[parent].push_back(maxUsed);
        maketree(maxUsed,index+1);
    }
}

bool canWin(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canWin(child[parent][i])) return 1;
    }

    return 0;
}

bool canLoss(int parent=0){

    for(int i=0;i<child[parent].size();i++){
        if(!canLoss(child[parent][i])) return 1;
    }

    return 0;
}

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
        maketree();
    }

    bool winAbility=canWin(),lossAbility=canLoss(),result;

    if(winAbility&&lossAbility) result=1;
    else{
        if(winAbility) result=k%2;
        else result=0;
    }

    //if(k==6) printf("%d,%d",winAbility,lossAbility);
    printf("%s\n",(result)?"First":"Second");
}

int main()
{
    //freopen("sampleInput.txt","r",stdin);
    solve();
    return 0;
}


#include<cstdio>

char get[100000+1];

void solve(){

    int n,k;
    scanf("%d%d",&n,&k);

    for(int i=0;i<n;i++){
        scanf(" %s",get);
    }

    printf("%s\n",(k%2)?"First":"Second");
}

int main()
{
    solve();
    return 0;
}


#include<cstdio>
//#include<cstring>
#include<algorithm>
//#include<cmath>
#include<string>
#include<iostream>
using namespace std;
//#define ll long long
string s1[100000];
bool f(int a,int b,int i)
{
//printf("%d %d %d\n",a,b,i);
    if(a+1==b)return (s1[a].length()-i)&1;
    bool bl=0;
    while(a<b&&s1[a].length()==i)++a;
    int c=a,d;
    while(1)
    {
        for(d=c+1;d<b&&s1[c][i]==s1[d][i];++d);
//printf("~~~~~%d %d\n",c,d));
        bl|=!f(c,d,i+1);c=d;
        if(bl)return 1;
        if(d==b)break;
    }
    return 0;
}
int main()
{
    //freopen("cpp.txt","r",stdin);
    int n,k,a;bool bl=0;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;++i)
        cin>>s1[i];
    sort(s1,s1+n);
//for(int i=0;i<n;++i)
//cout<<s1[i]<<endl;
//printf("%d\n",f(0,n,0));
    puts(f(0,n,0)&&(k&1)?"First":"Second");
}


#include<cstdio>
//#include<cstring>
#include<algorithm>
//#include<cmath>
#include<string>
#include<iostream>
using namespace std;
//#define ll long long
string s1[100000];
bool f(int a,int b,int i)
{
//printf("%d %d %d\n",a,b,i);
    if(a+1==b)return (s1[a].length()-i)&1;
    bool bl=0;
    while(a+1<b&&s1[a].length()==i)++a;
    int c=a,d;
    while(1)
    {
        for(d=c+1;d<b&&s1[c][i]==s1[d][i];++d);
//printf("~~~~~%d %d\n",c,d));
        bl|=!f(c,d,i+1);c=d;
        if(bl)return 1;
        if(d==b)break;
    }
    return 0;
}
int main()
{
    int n,k,a;bool bl=0;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;++i)
        cin>>s1[i];
    sort(s1,s1+n);
//for(int i=0;i<n;++i)
//cout<<s1[i]<<endl;
//printf("%d\n",f(0,n,0));
    puts(f(0,n,0)&&(k&1)?"First":"Second");
}


#include<cstdio>
//#include<cstring>
#include<algorithm>
//#include<cmath>
#include<string>
#include<iostream>
using namespace std;
//#define ll long long
string s1[100000];
bool f(int a,int b,int i)
{
//printf("%d %d %d\n",a,b,i);
    if(a+1==b)return (s1[a].length()-i)&1;
    while(a<b&&s1[a].length()==i)++a;
    if(a==b)return 0;
    int c=a,d;bool bl=0;
    while(1)
    {
        for(d=c+1;d<b&&s1[c][i]==s1[d][i];++d);
//printf("~~~~~%d %d\n",c,d));
        bl|=!f(c,d,i+1);c=d;
        if(bl)return 1;
        if(c==b)break;
    }
    return 0;
}
bool f1(int a,int b,int i)
{
//printf("%d %d %d\n",a,b,i);
    if(a+1==b)return (s1[a].length()-i+1)&1;
    while(a<b&&s1[a].length()==i)++a;
    if(a==b)return 1;
    int c=a,d;bool bl=0;
    while(1)
    {
        for(d=c+1;d<b&&s1[c][i]==s1[d][i];++d);
//printf("~~~~~%d %d\n",c,d));
        bl|=!f1(c,d,i+1);c=d;
        if(bl)return 1;
        if(c==b)break;
    }
    return 0;
}
int main()
{
    //freopen("cpp.txt","r",stdin);
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;++i)
        cin>>s1[i];
    sort(s1,s1+n);
//for(int i=0;i<n;++i)
//cout<<s1[i]<<endl;
//printf("%d\n",f(0,n,0));
    puts(f(0,n,0)&&(f1(0,n,0)||(k&1))?"First":"Second");
}


#include<cstdio>
//#include<cstring>
#include<algorithm>
//#include<cmath>
#include<string>
#include<iostream>
using namespace std;
//#define ll long long
string s1[100000];
bool f(int a,int b,int i)
{
//printf("%d %d %d\n",a,b,i);
    //if(a+1==b)return (s1[a].length()-i)&1;
    while(a<b&&s1[a].length()==i)++a;
    if(a==b)return 0;
    int c=a,d;bool bl=0;
    while(1)
    {
        for(d=c+1;d<b&&s1[c][i]==s1[d][i];++d);
//printf("~~~~~%d %d\n",c,d));
        bl|=!f(c,d,i+1);c=d;
        if(bl)return 1;
        if(c==b)break;
    }
    return 0;
}
int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;++i)
        cin>>s1[i];
    sort(s1,s1+n);
//for(int i=0;i<n;++i)
//cout<<s1[i]<<endl;
//printf("%d\n",f(0,n,0));
    puts(f(0,n,0)&&(k&1)?"First":"Second");
}


#include<cstdio>
//#include<cstring>
#include<algorithm>
//#include<cmath>
#include<string>
#include<iostream>
using namespace std;
//#define ll long long
string s1[100000];
bool f(int a,int b,int i)
{
//printf("%d %d %d\n",a,b,i);
    if(a+1==b)return (s1[a].length()-i)&1;
    while(a<b&&s1[a].length()==i)++a;
    if(a==b)return 0;
    int c=a,d;bool bl=0;
    while(1)
    {
        for(d=c+1;d<b&&s1[c][i]==s1[d][i];++d);
//printf("~~~~~%d %d\n",c,d));
        bl|=!f(c,d,i+1);c=d;
        if(bl)return 1;
        if(c==b)break;
    }
    return 0;
}
bool f1(int a,int b,int i)
{
//printf("%d %d %d\n",a,b,i);
    if(a+1==b)return (s1[a].length()-i+1)&1;
    while(a<b&&s1[a].length()==i)++a;
    if(a==b)return 1;
    int c=a,d;bool bl=0;
    while(1)
    {
        for(d=c+1;d<b&&s1[c][i]==s1[d][i];++d);
//printf("~~~~~%d %d\n",c,d));
        bl|=!f(c,d,i+1);c=d;
        if(bl)return 1;
        if(c==b)break;
    }
    return 0;
}
int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;++i)
        cin>>s1[i];
    sort(s1,s1+n);
//for(int i=0;i<n;++i)
//cout<<s1[i]<<endl;
//printf("%d\n",f(0,n,0));
    puts(f(0,n,0)&&(f1(0,n,0)||(k&1))?"First":"Second");
}


#include<cstdio>
//#include<cstring>
#include<algorithm>
//#include<cmath>
#include<string>
#include<iostream>
using namespace std;
//#define ll long long
string s1[100000];
bool f(int a,int b,int i)
{
//printf("%d %d %d\n",a,b,i);
    if(a+1==b)return (s1[a].length()-i)&1;
    bool bl=0;
    while(a<b&&s1[a].length()==i)++a;
    if(a==b)return 0;
    int c=a,d;
    while(1)
    {
        for(d=c+1;d<b&&s1[c][i]==s1[d][i];++d);
//printf("~~~~~%d %d\n",c,d));
        bl|=!f(c,d,i+1);c=d;
        if(bl)return 1;
        if(c==b)break;
    }
    return 0;
}
int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;++i)
        cin>>s1[i];
    sort(s1,s1+n);
//for(int i=0;i<n;++i)
//cout<<s1[i]<<endl;
//printf("%d\n",f(0,n,0));
    puts(f(0,n,0)&&(k&1)?"First":"Second");
}


#include<cstdio>
#include<algorithm>
#include<string>
#include<iostream>
using namespace std;
string s1[100000];
int f(int a,int b,int i)
{

    if(a+1==b)return (s1[a].length()-i&1)+1;
    while(a<b&&s1[a].length()==i)++a;
    if(a==b)return 1;
    int c=a,d,x;bool bl1=0,bl2=0;
    while(1)
    {
        for(d=c+1;d<b&&s1[c][i]==s1[d][i];++d);
        x=f(c,d,i+1);c=d;
        bl1|=!(x>1);bl2|=!(x&1);
        if(c==b)break;
    }
    return bl1*2+bl2;
}
int main()
{
    int n,k,x;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;++i)
        cin>>s1[i];
    sort(s1,s1+n);
    x=f(0,n,0);
    puts(x==3||x>1&&(k&1)?"First":"Second");
}


#include <algorithm>
#include <iostream>
#include <sstream>
#include <utility>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <ctime>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define pb push_back
#define ppb pop_back
#define mp make_pair
#define fs first
#define sc second
#define abs(a) ((a)<0?-(a):(a))
#define sqr(a) ((a)*(a))

const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.0);

typedef struct stbor* bor;
struct stbor {
	bor s[256];
	void init() {
		for(int i = 0; i < 256; i++) {
			s[i] = 0;
		}
	}
};

pair<bool, bool> dfs(bor b, int c = 0) {
	bool wp = c % 2, lp = 1 - c % 2;
	for(int i = 0; i < 256; i++) {
		if(b -> s[i]) {
			pair<bool, bool> win = dfs(b -> s[i], c + 1);
			if(c % 2 == 0 && win.fs == 1) {
				wp = 1;
			}
			if(c % 2 == 1 && win.fs == 0){
				wp = 0;
			}
			if(c % 2 == 0 && win.sc == 1) {
				lp = 1;
			}
			if(c % 2 == 1 && win.sc == 0){
				lp = 0;
			}
		}
	}
	return(mp(wp, lp));
}

int main() {

//	freopen("*.in","r",stdin);
//	freopen("*.out","w",stdout);

	bor b = new stbor; b -> init();
	int n, k;
	scanf("%d%d\n", &n, &k);
	for(int i = 0; i < n; i++) {
		string s; getline(cin, s); int ls = s.length();
		bor h = b;
		for(int i = 0; i < ls; i++) {
			if(!h -> s[s[i]]) {
				bor c = new stbor; c -> init();
				h -> s[s[i]] = c;
			}
			h = h -> s[s[i]];
		}
	}

	pair<bool, bool> win = dfs(b);

	if(win.fs && win.sc) {
		printf("First");
	} else
	if(win.fs && !win.sc) {
		if(k % 2 == 1) {printf("First");} else {printf("Second");}
	} else
	if(!win.fs && !win.sc) {
		if(k % 2 == 1) {printf("Second");} else {printf("First");}
//		printf("Second");
	} else
	if(!win.fs && win.sc) {
		printf("Second");
	}

	return(0);
}

// by Kim Andrey


#include <algorithm>
#include <iostream>
#include <sstream>
#include <utility>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <ctime>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define pb push_back
#define ppb pop_back
#define mp make_pair
#define fs first
#define sc second
#define abs(a) ((a)<0?-(a):(a))
#define sqr(a) ((a)*(a))

const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.0);

typedef struct stbor* bor;
struct stbor {
	bor s[256];
	void init() {
		for(int i = 0; i < 256; i++) {
			s[i] = 0;
		}
	}
};

pair<bool, bool> dfs(bor b, int c = 0) {
	bool wp = c % 2, lp = c % 2, ok = 0;
	for(int i = 0; i < 256; i++) {
		if(b -> s[i]) {
			pair<bool, bool> win = dfs(b -> s[i], c + 1);
			ok = 1;
			if(c % 2 == 0 && win.fs == 1) {
				wp = 1;
			}
			if(c % 2 == 1 && win.fs == 0){
				wp = 0;
			}
			if(c % 2 == 0 && win.sc == 1) {
				lp = 1;
			}
			if(c % 2 == 1 && win.sc == 0){
				lp = 0;
			}
		}
	}
	if(!ok) {wp = c % 2; lp = 1 - c % 2;}
	return(mp(wp, lp));
}

int main() {

//	freopen("*.in","r",stdin);
//	freopen("*.out","w",stdout);

	bor b = new stbor; b -> init();
	int n, k;
	scanf("%d%d\n", &n, &k);
	for(int i = 0; i < n; i++) {
		string s; getline(cin, s); int ls = s.length();
		bor h = b;
		for(int i = 0; i < ls; i++) {
			if(!h -> s[s[i]]) {
				bor c = new stbor; c -> init();
				h -> s[s[i]] = c;
			}
			h = h -> s[s[i]];
		}
	}

	pair<bool, bool> win = dfs(b);

//	printf("%d %d", win.fs, win.sc);

	if(win.fs && win.sc) {
		printf("First");
	} else
	if(win.fs && !win.sc) {
		if(k % 2 == 1) {printf("First");} else {printf("Second");}
	} else
	if(!win.fs && !win.sc) {
//		if(k % 2 == 1) {printf("Second");} else {printf("First");}
		printf("Second");
	} else
	if(!win.fs && win.sc) {
		printf("Second");
	}

	return(0);
}

// by Kim Andrey


#include <algorithm>
#include <iostream>
#include <sstream>
#include <utility>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <ctime>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define pb push_back
#define ppb pop_back
#define mp make_pair
#define fs first
#define sc second
#define abs(a) ((a)<0?-(a):(a))
#define sqr(a) ((a)*(a))

const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.0);

typedef struct stbor* bor;
struct stbor {
	bor s[256];
	void init() {
		for(int i = 0; i < 256; i++) {
			s[i] = 0;
		}
	}
};

pair<bool, bool> dfs(bor b, int c = 0) {
	bool wp = c % 2, lp = 1 - c % 2;
	for(int i = 0; i < 256; i++) {
		if(b -> s[i]) {
			pair<bool, bool> win = dfs(b -> s[i], c + 1);
			if(c % 2 == 0 && win.fs == 1) {
				wp = 1;
			}
			if(c % 2 == 1 && win.fs == 0){
				wp = 0;
			}
			if(c % 2 == 0 && win.sc == 1) {
				lp = 1;
			}
			if(c % 2 == 1 && win.sc == 0){
				lp = 0;
			}
		}
	}
	return(mp(wp, lp));
}

int main() {

//	freopen("*.in","r",stdin);
//	freopen("*.out","w",stdout);

	bor b = new stbor; b -> init();
	int n, k;
	scanf("%d%d\n", &n, &k);
	for(int i = 0; i < n; i++) {
		string s; getline(cin, s); int ls = s.length();
		bor h = b;
		for(int i = 0; i < ls; i++) {
			if(!h -> s[s[i]]) {
				bor c = new stbor; c -> init();
				h -> s[s[i]] = c;
			}
			h = h -> s[s[i]];
		}
	}

	pair<bool, bool> win = dfs(b);

	if(win.fs && win.sc) {
		printf("First");
	} else
	if(win.fs && !win.sc) {
		if(k % 2 == 1) {printf("First");} else {printf("Second");}
	} else
	if(!win.fs && !win.sc) {
//		if(k % 2 == 1) {printf("Second");} else {printf("First");}
		printf("Second");
	} else
	if(!win.fs && win.sc) {
		printf("Second");
	}

	return(0);
}

// by Kim Andrey


#include <algorithm>
#include <iostream>
#include <sstream>
#include <utility>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <ctime>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define pb push_back
#define ppb pop_back
#define mp make_pair
#define fs first
#define sc second
#define abs(a) ((a)<0?-(a):(a))
#define sqr(a) ((a)*(a))

const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.0);

typedef struct stbor* bor;
struct stbor {
	bor s[256];
	void init() {
		for(int i = 0; i < 256; i++) {
			s[i] = 0;
		}
	}
};

bool dfs(bor b, int c = 0) {
	bool wp = c % 2, fh = 0;
	for(int i = 0; i < 256; i++) {
		if(b -> s[i]) {
			bool win = dfs(b -> s[i], c + 1);
			if(c % 2 == 0 && win) {
				wp = 1;
			}
			if(c % 2 == 1 && !win){
				wp = 0;
			}
		}
	}
	return(wp);
}

int main() {

//	freopen("*.in","r",stdin);
//	freopen("*.out","w",stdout);

	bor b = new stbor; b -> init();
	int n, k;
	scanf("%d%d\n", &n, &k);
	for(int i = 0; i < n; i++) {
		string s; getline(cin, s); int ls = s.length();
		bor h = b;
		for(int i = 0; i < ls; i++) {
			if(!h -> s[s[i]]) {
				bor c = new stbor; c -> init();
				h -> s[s[i]] = c;
			}
			h = h -> s[s[i]];
		}
	}

	bool win = dfs(b);

	if(win) {
		if(k % 2 == 1) {printf("First");} else {printf("Second");}
	} else {
		printf("Second");
	}

	return(0);
}

// by Kim Andrey


#include <algorithm>
#include <iostream>
#include <sstream>
#include <utility>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <ctime>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define pb push_back
#define ppb pop_back
#define mp make_pair
#define fs first
#define sc second
#define abs(a) ((a)<0?-(a):(a))
#define sqr(a) ((a)*(a))

const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.0);

typedef struct stbor* bor;
struct stbor {
	bor s[256];
	void init() {
		for(int i = 0; i < 256; i++) {
			s[i] = 0;
		}
	}
};

bool dfs(bor b, int c = 0) {
	bool son = 1, wp = 0, fh = 0;
	for(int i = 0; i < 256; i++) {
		if(b -> s[i]) {
			son = 0;
			bool win = dfs(b -> s[i], c + 1);
			if(c != 0 && win == (bool)(c & 1)) {wp = 1;}
			if(c == 0 && win == 1) {wp = 1;}
		}
	}
//	printf("%d %d %d\n", c, wp, son);
	if(son) {return(c & 1);}
	if(wp) {return(c & 1);} else {return(1 - (c & 1));}
}

int main() {

//	freopen("*.in","r",stdin);
//	freopen("*.out","w",stdout);

	bor b = new stbor; b -> init();
	int n, k;
	scanf("%d%d\n", &n, &k);
	for(int i = 0; i < n; i++) {
		string s; getline(cin, s); int ls = s.length();
		bor h = b;
		for(int i = 0; i < ls; i++) {
			if(!h -> s[s[i]]) {
				bor c = new stbor; c -> init();
				h -> s[s[i]] = c;
			}
			h = h -> s[s[i]];
		}
	}

	bool win = !dfs(b);

	if(win) {
		if(k & 1) {printf("First");} else {printf("Second");}
	} else {
		printf("Second");
	}

	return(0);
}

// by Kim Andrey


#include <algorithm>
#include <iostream>
#include <sstream>
#include <utility>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <ctime>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define pb push_back
#define ppb pop_back
#define mp make_pair
#define fs first
#define sc second
#define abs(a) ((a)<0?-(a):(a))
#define sqr(a) ((a)*(a))

const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.0);

typedef struct stbor* bor;
struct stbor {
	bor s[256];
	void init() {
		for(int i = 0; i < 256; i++) {
			s[i] = 0;
		}
	}
};

pair<bool, bool> dfs(bor b, int c = 0) {
	bool wp = c % 2, lp = 1 - c % 2;
	for(int i = 0; i < 256; i++) {
		if(b -> s[i]) {
			pair<bool, bool> win = dfs(b -> s[i], c + 1);
			if(c % 2 == 0 && win.fs == 1) {
				wp = 1;
			}
			if(c % 2 == 1 && win.fs == 0){
				wp = 0;
			}
			if(c % 2 == 0 && win.sc == 1) {
				lp = 1;
			}
			if(c % 2 == 1 && win.sc == 0){
				lp = 0;
			}
		}
	}
	return(mp(wp, lp));
}

int main() {

//	freopen("*.in","r",stdin);
//	freopen("*.out","w",stdout);

	bor b = new stbor; b -> init();
	int n, k;
	scanf("%d%d\n", &n, &k);
	for(int i = 0; i < n; i++) {
		string s; getline(cin, s); int ls = s.length();
		bor h = b;
		for(int i = 0; i < ls; i++) {
			if(!h -> s[s[i]]) {
				bor c = new stbor; c -> init();
				h -> s[s[i]] = c;
			}
			h = h -> s[s[i]];
		}
	}

	pair<bool, bool> win = dfs(b);

	if(win.fs && win.sc) {
		printf("First");
	} else
	if(win.fs && !win.sc) {
		if(k % 2 == 1) {printf("First");} else {printf("Second");}
	} else
	if(!win.fs && !win.sc) {
		if(k % 2 == 1) {printf("Seconf");} else {printf("First");}
	} else
	if(!win.fs && win.sc) {
		printf("Second");
	}

/*	if(win) {
		if(k % 2 == 1) {printf("First");} else {printf("Second");}
	} else {
		printf("Second");
	}*/

	return(0);
}

// by Kim Andrey


#include <algorithm>
#include <iostream>
#include <sstream>
#include <utility>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <ctime>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define pb push_back
#define ppb pop_back
#define mp make_pair
#define fs first
#define sc second
#define abs(a) ((a)<0?-(a):(a))
#define sqr(a) ((a)*(a))

const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.0);

typedef struct stbor* bor;
struct stbor {
	bor s[256];
	void init() {
		for(int i = 0; i < 256; i++) {
			s[i] = 0;
		}
	}
};

pair<bool, bool> dfs(bor b, int c = 0) {
	bool wp = c % 2, lp = 1 - c % 2;
	for(int i = 0; i < 256; i++) {
		if(b -> s[i]) {
			pair<bool, bool> win = dfs(b -> s[i], c + 1);
			if(c % 2 == 0 && win.fs == 1) {
				wp = 1;
			}
			if(c % 2 == 1 && win.fs == 0){
				wp = 0;
			}
			if(c % 2 == 0 && win.sc == 1) {
				lp = 1;
			}
			if(c % 2 == 1 && win.sc == 0){
				lp = 0;
			}
		}
	}
	return(mp(wp, lp));
}

int main() {

//	freopen("*.in","r",stdin);
//	freopen("*.out","w",stdout);

	bor b = new stbor; b -> init();
	int n, k;
	scanf("%d%d\n", &n, &k);
	for(int i = 0; i < n; i++) {
		string s; getline(cin, s); int ls = s.length();
		bor h = b;
		for(int i = 0; i < ls; i++) {
			if(!h -> s[s[i]]) {
				bor c = new stbor; c -> init();
				h -> s[s[i]] = c;
			}
			h = h -> s[s[i]];
		}
	}

	pair<bool, bool> win = dfs(b);

	if(win.fs && win.sc) {
		printf("First");
	} else
	if(win.fs && !win.sc) {
		if(k % 2 == 1) {printf("First");} else {printf("Second");}
	} else
	if(!win.fs && win.sc) {
		printf("Second");
	}

/*	if(win) {
		if(k % 2 == 1) {printf("First");} else {printf("Second");}
	} else {
		printf("Second");
	}*/

	return(0);
}

// by Kim Andrey


#include <algorithm>
#include <iostream>
#include <sstream>
#include <utility>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <ctime>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define pb push_back
#define ppb pop_back
#define mp make_pair
#define fs first
#define sc second
#define abs(a) ((a)<0?-(a):(a))
#define sqr(a) ((a)*(a))

const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.0);

typedef struct stbor* bor;
struct stbor {
	bor s[256];
	void init() {
		for(int i = 0; i < 256; i++) {
			s[i] = 0;
		}
	}
};

bool dfs(bor b, int c = 0) {
	bool son = 0, wp = 0;
	for(int i = 0; i < 256; i++) {
		if(b -> s[i]) {
			son = 1;
			bool win = dfs(b -> s[i], c + 1);
			if(win == (c & 1)) {wp = 1;}
		}
	}
	if(!son) {return(c & 1);}
	if(wp) {return(c & 1);} else {return(1 - (c & 1));}
}

int main() {

//	freopen("*.in","r",stdin);
//	freopen("*.out","w",stdout);

	bor b = new stbor; b -> init();
	int n, k;
	scanf("%d%d\n", &n, &k);
	for(int i = 0; i < n; i++) {
		string s; getline(cin, s); int ls = s.length();
		bor h = b;
		for(int i = 0; i < ls; i++) {
			if(!h -> s[s[i]]) {
				bor c = new stbor; c -> init();
				h -> s[s[i]] = c;
			}
			h = h -> s[s[i]];
		}
	}

	bool win = dfs(b);

	if(win) {
		if(k & 1) {printf("First");} else {printf("Second");}
	} else {
		printf("Second");
	}

	return(0);
}

// by Kim Andrey


#include <algorithm>
#include <iostream>
#include <sstream>
#include <utility>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <cmath>
#include <ctime>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define pb push_back
#define ppb pop_back
#define mp make_pair
#define fs first
#define sc second
#define abs(a) ((a)<0?-(a):(a))
#define sqr(a) ((a)*(a))

const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.0);

typedef struct stbor* bor;
struct stbor {
	bor s[256];
	void init() {
		for(int i = 0; i < 256; i++) {
			s[i] = 0;
		}
	}
};

bool dfs(bor b, int c = 0) {
	bool son = 0, wp = 0;
	for(int i = 0; i < 256; i++) {
		if(b -> s[i]) {
			son = 1;
			bool win = dfs(b -> s[i], c++);
			if(win == (c & 1)) {wp = 1;}
		}
	}
	if(!son) {return(c & 1);}
	if(wp) {return(c & 1);}
}

int main() {

//	freopen("*.in","r",stdin);
//	freopen("*.out","w",stdout);

	bor b = new stbor; b -> init();
	int n, k;
	scanf("%d%d\n", &n, &k);
	for(int i = 0; i < n; i++) {
		string s; getline(cin, s); int ls = s.length();
		bor h = b;
		for(int i = 0; i < ls; i++) {
			if(!h -> s[s[i]]) {
				bor c = new stbor; c -> init();
				h -> s[s[i]] = c;
			}
			h = h -> s[s[i]];
		}
	}

	bool win = dfs(b);

	if(win) {
		if(k & 1) {printf("First");} else {printf("Second");}
	} else {
		if(!(k & 1)) {printf("First");} else {printf("Second");}
	}

	return(0);
}

// by Kim Andrey


/*********************************************************************\
   |--\        ---       /\        |-----------| -----   /-------|    |
   |   \        |       /  \       |               |    /             |
   |    \       |      /    \      |               |   |              |
   |     \      |     /      \     |               |   |----|         |
   |      \     |    / ------ \    |-------|       |        |-----|   |
   |       \    |   /          \   |               |              |   |
   |        \   |  /            \  |               |              /   |
  ---        -------            ------           ----- |---------/    |
                                                                      |
    codeforces = nfssdq  ||  topcoder = nafis007                      |
    mail = nafis_sadique@yahoo.com || nfssdq@gmail.com                |
    IIT,Jahangirnagar University(41)                                  |
                                                                      |
**********************************************************************/

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

#define xx         first
#define yy         second
#define pb         push_back
#define mp         make_pair
#define LL         long long
#define inf        INT_MAX/3
#define mod        1000000007ll
#define PI         2.0*acos(0.0)
#define linf       (1ll<<60)-1
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define REP(I,N)   FOR(I,0,N)
#define ALL(A)     ((A).begin(), (A).end())
#define set0(ar)   memset(ar,0,sizeof ar)
#define vsort(v)   sort(v.begin(),v.end())
#define setinf(ar) memset(ar,126,sizeof ar)

//cout << fixed << setprecision(20) << p << endl;

template <class T> inline T bigmod(T p,T e,T M){
    LL ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return (T)ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

struct trie{
    trie *nxt[26];
    trie(){
        memset(nxt, NULL, sizeof nxt);
    }
};
void insert(trie *ob, char *s){
    if(s[0] == '\0') return;
    int a = s[0] - 'a';
    if(ob->nxt[a] == NULL) ob->nxt[a] = new trie();
    insert(ob->nxt[a], s+1);
}
int go(trie *ob){
    set < int > s;
    REP(i, 26){
        if(ob->nxt[i] != NULL) s.insert(go(ob->nxt[i]));
    }
    for(int i = 0; ; i++){
        if(s.count(i) == 0) return i;
    }
}
int lgo(trie *ob){
    set < int > s;
    REP(i, 26){
        if(ob->nxt[i] != NULL) s.insert(go(ob->nxt[i]));
        else s.insert(0);
    }
    for(int i = 0; ; i++){
        if(s.count(i) == 0) return i;
    }
}
char pp[100011];
trie *tr = new trie();
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    LL a,b,c,d = 0,e,f = 0,g,h = 0,x,y,z;
    cin >> a >> b;
    REP(i, a){
        cin >> pp;
        insert(tr, pp);
    }
    c = go(tr);
    if(c > 0){
        d = lgo(tr);
        if(b % 2 == 0 && d > 0) cout << "Second" << endl;
        else cout << "First" << endl;
    } else {
        cout << "Second" << endl;
    }
}


/*********************************************************************\
   |--\        ---       /\        |-----------| -----   /-------|    |
   |   \        |       /  \       |               |    /             |
   |    \       |      /    \      |               |   |              |
   |     \      |     /      \     |               |   |----|         |
   |      \     |    / ------ \    |-------|       |        |-----|   |
   |       \    |   /          \   |               |              |   |
   |        \   |  /            \  |               |              /   |
  ---        -------            ------           ----- |---------/    |
                                                                      |
    codeforces = nfssdq  ||  topcoder = nafis007                      |
    mail = nafis_sadique@yahoo.com || nfssdq@gmail.com                |
    IIT,Jahangirnagar University(41)                                  |
                                                                      |
**********************************************************************/

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

#define xx         first
#define yy         second
#define pb         push_back
#define mp         make_pair
#define LL         long long
#define inf        INT_MAX/3
#define mod        1000000007ll
#define PI         2.0*acos(0.0)
#define linf       (1ll<<60)-1
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define REP(I,N)   FOR(I,0,N)
#define ALL(A)     ((A).begin(), (A).end())
#define set0(ar)   memset(ar,0,sizeof ar)
#define vsort(v)   sort(v.begin(),v.end())
#define setinf(ar) memset(ar,126,sizeof ar)

//cout << fixed << setprecision(20) << p << endl;

template <class T> inline T bigmod(T p,T e,T M){
    LL ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return (T)ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

struct trie{
    trie *nxt[26];
    trie(){
        memset(nxt, NULL, sizeof nxt);
    }
};
void insert(trie *ob, char *s){
    if(s[0] == '\0') return;
    int a = s[0] - 'a';
    if(ob->nxt[a] == NULL) ob->nxt[a] = new trie();
    insert(ob->nxt[a], s+1);
}
int goW(trie *ob){
    REP(i, 26){
        if(ob->nxt[i] != NULL){
            int a = goW(ob->nxt[i]);
            if(a == 0) return 1;
        }
    }
    return 0;
}
int goL(trie *ob){
    REP(i, 26){
        if(ob->nxt[i] != NULL){
            int a = goL(ob->nxt[i]);
            if(a == 1) return 0;
        }
    }
    return 1;
}
char pp[100011];
trie *tr = new trie();
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    LL a,b,c,d = 0,e,f = 0,g,h = 0,x,y,z;
    cin >> a >> b;
    REP(i, a){
        cin >> pp;
        insert(tr, pp);
    }
    c = goW(tr);
    d = goL(tr);
    if(c == 1 && d == 1) cout << "First" << endl;
    else if(c == 1 && d == 0) {
        if(b % 2 == 0) cout << "Second" << endl;
        else cout << "First" << endl;
    } else if(c == 0) cout << "Second" << endl;
}


/*********************************************************************\
   |--\        ---       /\        |-----------| -----   /-------|    |
   |   \        |       /  \       |               |    /             |
   |    \       |      /    \      |               |   |              |
   |     \      |     /      \     |               |   |----|         |
   |      \     |    / ------ \    |-------|       |        |-----|   |
   |       \    |   /          \   |               |              |   |
   |        \   |  /            \  |               |              /   |
  ---        -------            ------           ----- |---------/    |
                                                                      |
    codeforces = nfssdq  ||  topcoder = nafis007                      |
    mail = nafis_sadique@yahoo.com || nfssdq@gmail.com                |
    IIT,Jahangirnagar University(41)                                  |
                                                                      |
**********************************************************************/

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

#define xx         first
#define yy         second
#define pb         push_back
#define mp         make_pair
#define LL         long long
#define inf        INT_MAX/3
#define mod        1000000007ll
#define PI         2.0*acos(0.0)
#define linf       (1ll<<60)-1
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define REP(I,N)   FOR(I,0,N)
#define ALL(A)     ((A).begin(), (A).end())
#define set0(ar)   memset(ar,0,sizeof ar)
#define vsort(v)   sort(v.begin(),v.end())
#define setinf(ar) memset(ar,126,sizeof ar)

//cout << fixed << setprecision(20) << p << endl;

template <class T> inline T bigmod(T p,T e,T M){
    LL ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return (T)ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

struct trie{
    trie *nxt[26];
    trie(){
        memset(nxt, NULL, sizeof nxt);
    }
};
void insert(trie *ob, char *s){
    if(s[0] == '\0') return;
    int a = s[0] - 'a';
    if(ob->nxt[a] == NULL) ob->nxt[a] = new trie();
    insert(ob->nxt[a], s+1);
}
int go(trie *ob){
    set < int > s;
    REP(i, 26){
        if(ob->nxt[i] != NULL) s.insert(go(ob->nxt[i]));
        else s.insert(1);
    }
    for(int i = 0; ; i++){
        if(s.count(i) == 0) return i;
    }
}
char pp[100011];
trie *tr = new trie();
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    LL a,b,c,d = 0,e,f = 0,g,h = 0,x,y,z;
    cin >> a >> b;
    REP(i, a){
        cin >> pp;
        insert(tr, pp);
    }
    c = go(tr);
    if(c > 0){
        if(b % 2 == 0) cout << "Second" << endl;
        else cout << "First" << endl;
    } else {
        cout << "Second" << endl;
    }
}


/*********************************************************************\
   |--\        ---       /\        |-----------| -----   /-------|    |
   |   \        |       /  \       |               |    /             |
   |    \       |      /    \      |               |   |              |
   |     \      |     /      \     |               |   |----|         |
   |      \     |    / ------ \    |-------|       |        |-----|   |
   |       \    |   /          \   |               |              |   |
   |        \   |  /            \  |               |              /   |
  ---        -------            ------           ----- |---------/    |
                                                                      |
    codeforces = nfssdq  ||  topcoder = nafis007                      |
    mail = nafis_sadique@yahoo.com || nfssdq@gmail.com                |
    IIT,Jahangirnagar University(41)                                  |
                                                                      |
**********************************************************************/

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

#define xx         first
#define yy         second
#define pb         push_back
#define mp         make_pair
#define LL         long long
#define inf        INT_MAX/3
#define mod        1000000007ll
#define PI         2.0*acos(0.0)
#define linf       (1ll<<60)-1
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define REP(I,N)   FOR(I,0,N)
#define ALL(A)     ((A).begin(), (A).end())
#define set0(ar)   memset(ar,0,sizeof ar)
#define vsort(v)   sort(v.begin(),v.end())
#define setinf(ar) memset(ar,126,sizeof ar)

//cout << fixed << setprecision(20) << p << endl;

template <class T> inline T bigmod(T p,T e,T M){
    LL ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return (T)ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

struct trie{
    trie *nxt[26];
    trie(){
        memset(nxt, NULL, sizeof nxt);
    }
};
void insert(trie *ob, char *s){
    if(s[0] == '\0') return;
    int a = s[0] - 'a';
    if(ob->nxt[a] == NULL) ob->nxt[a] = new trie();
    insert(ob->nxt[a], s+1);
}
int goW(trie *ob){
    REP(i, 26){
        if(ob->nxt[i] != NULL){
            int a = goW(ob->nxt[i]);
            if(a == 0) return 1;
        }
    }
    return 0;
}
int goL(trie *ob){
    int cnt = 0;
    REP(i, 26){
        if(ob->nxt[i] != NULL){
            int a = goL(ob->nxt[i]);
            if(a == 0) return 1;
            cnt++;
        }
    }
    if(cnt == 0) return 1;
    return 0;
}
char pp[100011];
trie *tr = new trie();
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    LL a,b,c,d = 0,e,f = 0,g,h = 0,x,y,z;
    cin >> a >> b;
    REP(i, a){
        cin >> pp;
        insert(tr, pp);
    }
    c = goW(tr);
    d = goL(tr);
    if(c == 1 && d == 1) cout << "First" << endl;
    else if(c == 1 && d == 0) {
        if(b % 2 == 0) cout << "Second" << endl;
        else cout << "First" << endl;
    } else if(c == 0) cout << "Second" << endl;
}


/*********************************************************************\
   |--\        ---       /\        |-----------| -----   /-------|    |
   |   \        |       /  \       |               |    /             |
   |    \       |      /    \      |               |   |              |
   |     \      |     /      \     |               |   |----|         |
   |      \     |    / ------ \    |-------|       |        |-----|   |
   |       \    |   /          \   |               |              |   |
   |        \   |  /            \  |               |              /   |
  ---        -------            ------           ----- |---------/    |
                                                                      |
    codeforces = nfssdq  ||  topcoder = nafis007                      |
    mail = nafis_sadique@yahoo.com || nfssdq@gmail.com                |
    IIT,Jahangirnagar University(41)                                  |
                                                                      |
**********************************************************************/

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

#define xx         first
#define yy         second
#define pb         push_back
#define mp         make_pair
#define LL         long long
#define inf        INT_MAX/3
#define mod        1000000007ll
#define PI         2.0*acos(0.0)
#define linf       (1ll<<60)-1
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define REP(I,N)   FOR(I,0,N)
#define ALL(A)     ((A).begin(), (A).end())
#define set0(ar)   memset(ar,0,sizeof ar)
#define vsort(v)   sort(v.begin(),v.end())
#define setinf(ar) memset(ar,126,sizeof ar)

//cout << fixed << setprecision(20) << p << endl;

template <class T> inline T bigmod(T p,T e,T M){
    LL ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return (T)ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

struct trie{
    trie *nxt[26];
    trie(){
        memset(nxt, NULL, sizeof nxt);
    }
};
void insert(trie *ob, char *s){
    if(s[0] == '\0') return;
    int a = s[0] - 'a';
    if(ob->nxt[a] == NULL) ob->nxt[a] = new trie();
    insert(ob->nxt[a], s+1);
}
int go(trie *ob){
    set < int > s;
    REP(i, 26){
        if(ob->nxt[i] != NULL) s.insert(go(ob->nxt[i]));
    }
    for(int i = 0; ; i++){
        if(s.count(i) == 0) return i;
    }
}
char pp[100001];
trie *tr = new trie();
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    LL a,b,c,d = 0,e,f = 0,g,h = 0,x,y,z;
    cin >> a >> b;
    REP(i, a){
        cin >> pp;
        insert(tr, pp);
    }
    c = go(tr);
    if(c > 0){
        if(b % 2 == 0) cout << "Second" << endl;
        else cout << "First" << endl;
    } else {
        cout << "Second" << endl;
    }
}