Andrew, Fedor and Alex are inventive guys. Now they invent the game with strings for two players.

Given a group of n non-empty strings. During the game two players build the word together, initially the word is empty. The players move in turns. On his step player must add a single letter in the end of the word, the resulting word must be prefix of at least one string from the group. A player loses if he cannot move.

Andrew and Alex decided to play this game k times. The player who is the loser of the i-th game makes the first move in the (i + 1)-th game. Guys decided that the winner of all games is the player who wins the last (k-th) game. Andrew and Alex already started the game. Fedor wants to know who wins the game if both players will play optimally. Help him.


-----Input-----

The first line contains two integers, n and k (1 ≤ n ≤ 10^5; 1 ≤ k ≤ 10^9).

Each of the next n lines contains a single non-empty string from the given group. The total length of all strings from the group doesn't exceed 10^5. Each string of the group consists only of lowercase English letters.


-----Output-----

If the player who moves first wins, print "First", otherwise print "Second" (without the quotes).


-----Examples-----
Input
2 3
a
b

Output
First

Input
3 1
a
b
c

Output
First

Input
1 2
ab

Output
Second

Difficulty: competition

Starter code:

Solutions:
"""
Codeforces Contest 260 Div 1 Problem B

Author  : chaotic_iak
Language: Python 3.3.4
"""

def main():
    n,k = read()
    s = set()
    for i in range(n): s.add(read(0))
    s = list(s)
    s.sort()
    s = treeify(s)
    res = solve(s)
    if res == 0: # neither: second player win
        print("Second")
    if res == 1: # odd: first player win if k is odd
        print("First" if k % 2 else "Second")
    if res == 2: # even: second player win
        print("Second")
    if res == 3: # both: first player win
        print("First")

def treeify(s):
    res = [[] for _ in range(26)]
    for i in s:
        if i: res[ord(i[0]) - 97].append(i[1:])
    fin = []
    for i in range(26):
        if res[i]: fin.append(treeify(res[i]))
    return fin

def solve(s, parity=2):
    for i in range(len(s)):
        if isinstance(s[i], list): s[i] = solve(s[i], 3-parity)
    if not s: return parity # no possible move: current parity
    if 0 in s: return 3 # any neither: both
    if 1 in s and 2 in s: return 3 # any odd and any even: both
    if 1 in s: return 1 # any odd: odd
    if 2 in s: return 2 # any even: even
    return 0 # all both: neither

################################### NON-SOLUTION STUFF BELOW

def read(mode=2):
    # 0: String
    # 1: List of strings
    # 2: List of integers
    inputs = input().strip()
    if mode == 0: return inputs
    if mode == 1: return inputs.split()
    if mode == 2: return map(int, inputs.split())

def write(s="\n"):
    if isinstance(s, list): s = " ".join(map(str, s))
    s = str(s)
    print(s, end="")

main()

N = 100000
Z = 26

#别用这玩意儿: trie = [[0] * Z] * N 巨坑！https://www.cnblogs.com/PyLearn/p/7795552.html

trie = [[0 for i in range(Z)] for j in range(N)]
n = 0
k = 0
nodeNum = 0

def insertNode():
	u = 0
	string = input()
	nonlocal nodeNum
	
	for i in range(len(string)):
		c = ord(string[i]) - ord('a')
		if trie[u][c] == 0:
			nodeNum += 1
			trie[u][c] = nodeNum	
		u = trie[u][c]
		# print(u)
	
stateWin = [False for i in range(N)]	
stateLose = [False for i in range(N)]	
	
def dfs(u):
	leaf = True
	for c in range(Z):
		if (trie[u][c]) != 0:
			leaf = False
			dfs(trie[u][c])
			stateWin[u] |= (not(stateWin[trie[u][c]]))
			stateLose[u] |= (not(stateLose[trie[u][c]]))
	if leaf == True:
		stateWin[u] = False
		stateLose[u] = True

n,k = map(int,input().split())

for i in range(n):
	insertNode()

dfs(0)


# print(stateWin[0])
# print(stateLose[0])

if (stateWin[0] and (stateLose[0] or (k % 2 == 1) )):
	print("First")
else:
	print("Second")

# -*- coding:utf-8 -*-

"""

created by shuangquan.huang at 2/11/20

"""

import collections
import time
import os
import sys
import bisect
import heapq
from typing import List


def make_trie(A):
    trie = {}
    for word in A:
        t = trie
        for w in word:
            if w not in t:
                t[w] = {}
            t = t[w]
        # t['#'] = True
    
    return trie


def game(trie):
    if not trie:
        return False
    
    return not all([game(t) for k, t in trie.items()])


def can_lose(trie):
    if not trie:
        return True
    
    return any([not can_lose(t) for k, t in trie.items()])


def solve(N, K, A):
    trie = make_trie(A)
    win = game(trie)
    
    if not win:
        return False
    
    if K == 1:
        return True
    
    if can_lose(trie):
        return True
    
    return K % 2 == 1
    
    
N, K = map(int, input().split())
A = []
for i in range(N):
    s = input()
    A.append(s)
    
print('First' if solve(N, K, A) else 'Second')

# https://codeforces.com/contest/455/problem/B
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__


class Trie:

    def __init__(self):
        self.arr = {}

    def insert(self, word):
        root = self
        for x in word:
            if x not in root.arr:
                root.arr[x] = Trie()
            root = root.arr[x]

    def dfs(self):
        if not len(self.arr):
            return False, True
        win, lose = False, False
        for x in self.arr:
            w, l = self.arr[x].dfs()
            win = win or not w
            lose = lose or not l
        return win, lose

def answer(flag):
    print("First" if flag else "Second")

T = Trie()
n, k = list(map(int, input().split()))
for _ in range(n):
    T.insert(input())
win, lose = T.dfs()

if k == 1:
    answer(win)
elif not win:
    answer(win)
elif lose:
    answer(win)
elif k&1:
    answer(win)
else:
    answer(not win)


# https://codeforces.com/contest/455/problem/B
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__


class Trie:

    def __init__(self):
        self.arr = {}

    def insert(self, word):
        for x in word:
            if x not in self.arr:
                self.arr[x] = Trie()
            self = self.arr[x]

    def dfs(self):
        if not len(self.arr):
            return False, True
        win, lose = False, False
        for x in self.arr:
            w, l = self.arr[x].dfs()
            win = win or not w
            lose = lose or not l
        return win, lose

def answer(flag):
    print("First" if flag else "Second")

T = Trie()
n, k = list(map(int, input().split()))
for _ in range(n):
    T.insert(input())
win, lose = T.dfs()

if k == 1 or (not win) or lose or k&1:
    answer(win)
else:
    answer(not win)


import math
import sys
from itertools import permutations
input = sys.stdin.readline


class Node:

    def __init__(self):
        self.children = [None]*26
        self.isEnd = False
        self.win = False
        self.lose = False

class Trie:

    def __init__(self):
        self.root = Node()

    def insert(self, key):
        cur = self.root
        for i in range(len(key)):
            if cur.children[ord(key[i])-ord('a')]==None:
                cur.children[ord(key[i])-ord('a')]=Node()
            cur = cur.children[ord(key[i])-ord('a')]
        
        cur.isEnd = True
    
    def search(self, key):
        cur = self.root
        for i in range(len(key)):
            if cur.children[ord(key[i])-ord('a')]==None:
                return False
            cur = cur.children[ord(key[i])-ord('a')]
        
        if cur!=None and cur.isEnd:
            return True

        return False
    
    def assignWin(self, cur):
        
        flag = True
        for i in range(26):
            if cur.children[i]!=None:
                flag=False
                self.assignWin(cur.children[i])
        
        if flag:
            cur.win=False
            cur.lose=True
        else:
            for i in range(26):
                if cur.children[i]!=None:
                    cur.win = cur.win or (not cur.children[i].win)
                    cur.lose = cur.lose or (not cur.children[i].lose)
       

def __starting_point():
    
    t=Trie()

    n,k=list(map(int,input().split()))
    for i in range(n):
        s=input()
        if s[-1]=="\n":
            s= s[:-1]
        t.insert(s)
    
    t.assignWin(t.root)
    
    if not t.root.win:
        print("Second")
    else:
        if t.root.lose:
            print("First")
        else:
            if k%2==1:
                print("First")
            else:
                print("Second")

__starting_point()

from sys import stdin, setrecursionlimit

setrecursionlimit(200000)

n,k = [int(x) for x in stdin.readline().split()]

tree = {}

for x in range(n):
  s = stdin.readline().strip()

  cur = tree
  
  for x in s:
    if not x in cur:
      cur[x] = {}

    cur = cur[x]

def forced(tree):
  if not tree:
    return (False,True)
  else:
    win = False
    lose = False
    for x in tree:
      a,b = forced(tree[x])
      if not a:
        win = True
      if not b:
        lose = True
    return (win,lose)

a,b = forced(tree)

if a == 0:
  print('Second')
elif a == 1 and b == 1:
  print('First')
else:
  if k%2 == 0:
    print('Second')
  else:
    print('First')