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 ≤ 105; 1 ≤ k ≤ 109).

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 105. 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
//package round260;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class R260B1 {
	public static void main(String[] args) {
		B1 b1 = new B1();
		b1.input();
		b1.run();
		b1.output();
	}
}

class B1 {
	DictionaryTree1 tree = new DictionaryTree1();
	int n;
	int k;
	int result;
	
	@SuppressWarnings("resource")
	public void input() {
		Scanner sin = new Scanner(System.in);
		n = sin.nextInt();
		k = sin.nextInt();
		for (int i = 0; i< n; i++) {
			tree.add(sin.next());
		}
		//tree.printByBfs();
	}
	
	public void run() {
		runNode(tree.head);
		// 如果先手玩家有必赢和必输的选择，那么最后就是先手赢
		if (tree.head.isCertainlyWin && tree.head.isCertainlyLose) {
			result = 1;
		// 如果先手玩家只有必赢的选择，那么看K是否是基数
		} else if (tree.head.isCertainlyWin){
			if ((k&1) == 1) {
				result = 1;
			} else {
				result = 2;
			}
		// 其他情况，就是必输，和不确定，那先手就必输了
		} else {
			result = 2;
		}
	}
	
	private void runNode(TreeNode1 node) {
		// 轮到该玩家选择，结果发现没得选，就是必输了
		if (node.nexts == null) {
			node.isCertainlyLose = true;
			return;
		}
		
		for (TreeNode1 e: node.nexts) {
			runNode(e);
		}
		
		int winCount = 0;
		int loseCount = 0;
		
		for (TreeNode1 e: node.nexts) {
			if (e.isCertainlyWin) {
				winCount ++;
			}
			if (e.isCertainlyLose) {
				loseCount ++;
			}
		}
		
		// 下一次行动的玩家如果不能保证每种选择都必胜，那么这次行动的玩家就有必胜的选择
		if (winCount < node.nexts.size()) {
			node.isCertainlyWin = true;
		}
		// 同理
		if (loseCount < node.nexts.size()) {
			node.isCertainlyLose = true;
		}
	}
	
	public void output() {
		if (result == 1) {
			System.out.println("First");
		} else {			
			System.out.println("Second");
		}
	}
}

class DictionaryTree1 {
	TreeNode1 head;
	
	public DictionaryTree1() {
		head = new TreeNode1();
		head.value = 0;
	}
	
	public void add(String str) {
		TreeNode1 tree = head;
		for (int i = 0; i < str.length(); i++) {
			char tmpChar = str.charAt(i);
			TreeNode1 tmpNode = tree.getNodeByChar(tmpChar);
			if (tmpNode == null) {
				tree = tree.addChar(tmpChar);
			} else {
				tree = tmpNode;
			}
		}
	}
}

// 字典树节点
class TreeNode1 {
	char value;
	
	// 轮到A行动，A将从nexts里面选一个，nexts的所有结果将决定A在这次行动的结果 
	boolean isCertainlyWin = false; // 有必胜的选择
	boolean isCertainlyLose = false; // 有必输的选择
	
	List<TreeNode1> nexts;
	
	
	public TreeNode1 getNodeByChar(char c) {
		if (nexts == null) {
			return null;
		}
		
		for (TreeNode1 tn: nexts) {
			if (tn.value == c) {
				return tn;
			}
		}
		
		return null;
	}
	
	public TreeNode1 addChar(char c) {
		if (nexts == null) {
			nexts = new ArrayList<>();
		}
		
		TreeNode1 node = new TreeNode1();
		node.value = c;
		nexts.add(node);
		return node;
	}
}