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


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

public class R260B {
	public static void main(String[] args) {
		B b = new B();
		b.input();
		b.run();
		b.output();
	}
}

class B {
	// 先手结果
	final static int win_only = 0;
	final static int lose_only = 1;
	final static int win_and_lose = 2;
	final static int notsure = 3;
	
	DictionaryTree tree = new DictionaryTree();
	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() {
		int singleResult = find();
		switch (singleResult) {
		case win_and_lose:
			result = 1;
			break;
		case lose_only:
		case notsure:
			result = 2;
			break;
		case win_only:
			if (k%2 == 0) {
				result = 2;
			} else {
				result = 1;
			}
		default:
			break;
		}
	}
	
	private int find() {
		return find(tree.head, false);
	}
	
	private int find(TreeNode node, boolean isFirstTurn) {
		//
		if (node.nexts == null) {
			return isFirstTurn ? win_only: lose_only;
		}
		
		boolean [] resultArray = new boolean[4];
		for (int i = 0; i < 4; i++) {
			resultArray[i] = false;
		}
		
		for (TreeNode suNode: node.nexts) {
			int result = find(suNode, !isFirstTurn);
			resultArray[result] = true;
		}
		
		if (isFirstTurn) {
			// 接下来由第二人出手，
			if (resultArray[notsure]) {
				return notsure;
			}
			
			if (resultArray[win_only] && resultArray[lose_only]) {
				return notsure;
			}
			
			if (resultArray[win_only] && resultArray[win_and_lose]) {
				return win_only;
			}
			
			if (resultArray[lose_only] && resultArray[win_and_lose]) {
				return lose_only;
			}
			
			if (resultArray[win_only]) {
				return win_only;
			}
			
			if (resultArray[lose_only]) {
				return lose_only;
			}
			
			if (resultArray[win_and_lose]) {
				return win_and_lose;
			}
			
		} else {
			// 接下来由第一人出手，
			if (resultArray[win_and_lose]) {
				return win_and_lose;
			}
			
			if (resultArray[win_only] && resultArray[lose_only]) {
				return win_and_lose;
			}
			
			if (resultArray[win_only]) {
				return win_only;
			}
			
			if (resultArray[lose_only]) {
				return lose_only;
			}
			
			if (resultArray[notsure]) {
				return notsure;
			}
		}
		return notsure;
	}
	
	public void output() {
		if (result == 1) {
			System.out.println("First");
		} else {			
			System.out.println("Second");
		}
	}
}

// 字典树
class DictionaryTree {
	TreeNode head;
	
	public DictionaryTree() {
		head = new TreeNode();
		head.value = 0;
	}
	
	public void add(String str) {
		TreeNode tree = head;
		for (int i = 0; i < str.length(); i++) {
			char tmpChar = str.charAt(i);
			TreeNode tmpNode = tree.getNodeByChar(tmpChar);
			if (tmpNode == null) {
				tree = tree.addChar(tmpChar);
			} else {
				tree = tmpNode;
			}
		}
	}
	
	public void printByBfs() {
		Queue<TreeNode> queue = new LinkedList<>();
		System.out.println(head.toString());
		queue.addAll(head.nexts);
		while (!queue.isEmpty()) {
			TreeNode node = queue.poll();
			System.out.println(node.toString());
			if (node.nexts != null) {				
				queue.addAll(node.nexts);
			}
		}
	}
	
}

// 字典树节点
class TreeNode {
	char value;
	List<TreeNode> nexts;
	
	public TreeNode getNodeByChar(char c) {
		if (nexts == null) {
			return null;
		}
		
		for (TreeNode tn: nexts) {
			if (tn.value == c) {
				return tn;
			}
		}
		
		return null;
	}
	
	public TreeNode addChar(char c) {
		if (nexts == null) {
			nexts = new ArrayList<>();
		}
		
		TreeNode node = new TreeNode();
		node.value = c;
		nexts.add(node);
		return node;
	}
	
	public String toString() {
		if (nexts == null) {
			return "";
		}
		StringBuilder str = new StringBuilder();
		for (TreeNode node: nexts) {
			str.append(node.value);
		}
		return str.toString();
	}
}


