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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class ProblemD {

    public static void go() throws IOException{
	
	BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
	String[] temp = r.readLine().split(" ");
	int n = Integer.parseInt(temp[0]);
	int k = Integer.parseInt(temp[1]);
	Trie trie = new Trie();
	for(int i = 0; i< n; i++){
	    trie.addString(r.readLine());
	}
	
	trie.calcWinners();
	boolean canFirstWin = trie.CanFirstWin();
	boolean canFirstLose = trie.CanFirstLose();
	
//	System.out.println(canFirstLose);
//	System.out.println(canFirstWin);
	
	if(canFirstLose && canFirstWin){
	    System.out.println("First");
	} else if(canFirstLose && !canFirstWin){
	    System.out.println("Second");
	} else if(!canFirstLose && canFirstWin){
	    if(k%2==0){
		    System.out.println("Second");
	    } else{	    
		System.out.println("First");
	    }	 
	} else{
	    System.out.println("Second");
	}
	
    }
    
    public static void main(String[] args) throws IOException {

	ProblemD.go();
    }
    
    
    private static class Trie {
	
	private Node root;
	private boolean canFirstWin;
	private boolean canFirstLose;
	
	public Trie(){
	    this.root = new Node('Q');
	}
	
	public boolean CanFirstLose() {
	    return canFirstLose;
	}

	public boolean CanFirstWin() {
	    return canFirstWin;
	}

	public void addString(String string){
	    root.addChild(string, 0);
	}
	
	public void printTrie(){
	    root.printNode(0);
	}
	
	public void calcWinners(){
	    this.canFirstLose = false;
	    this.canFirstWin = false;
	    root.traverseNode(0);
	    Node node;
	    for(int i = 0; i< root.children.size();i++){
		node = root.children.get(i);
//		System.out.println(node.w);
//		node.printNode(1);
		if(node.w==Winner.FirstDecides){
		    this.canFirstLose = true;
		    this.canFirstWin = true;
		    break;
		} else{
		    if(node.w==Winner.First){
			this.canFirstWin = true;
		    } 
		    if(node.w==Winner.Second){
			this.canFirstLose = true;
		    }
		}
	    }
	}
	
    }
    
    
    private static class Node {
	
	private char letter;
	Winner w;
	int depth;
	
	private ArrayList<Node> children;
	
	public Node(char letter){
	    this.letter = letter;
	    children = null;
	    w = Winner.Undecided;
	}
	
	public void addChild(String string, int i) {
	    if(i>=string.length()){
		return;
	    }
	    if(children==null){
		children = new ArrayList<Node>(26);
	    }
	    char currLetter = string.charAt(i);
	    Node node = getChild(currLetter);
	    if(node==null){
		node = new Node(currLetter);
		this.addChild(node);
	    }
	    node.addChild(string, i+1);
	    
	}
	
	public Node getChild(char letter){
	    for(int i = 0; i< children.size(); i++){
		if(children.get(i).getLetter()==letter){
		    return children.get(i);
		}
	    }
	    return null;
	}

	public void addChild(Node child){
	    if(children==null){
		children = new ArrayList<Node>(100);
	    }
	    children.add(child);
	}
	
	public boolean isLeaf(){
	    if(children==null){
		return true;
	    } else{
		return false;
	    }
	}
	
	public char getLetter(){
	    return this.letter;
	}
	
	public void setWinner(Winner win){
	    
	    switch(w){
	    case Undecided:
		w = win;
		break;
	    case First:
		if(win==Winner.Second){
		    if(depth%2==0){
			w = Winner.FirstDecides;
		    } else{
			w = Winner.SecondDecides;
		    }
		} else if(win==Winner.First){
		    w = Winner.First;
		} else if(win==Winner.SecondDecides){
		    if(depth%2==0){
			w = Winner.First;
		    } else{
			w = Winner.SecondDecides;
		    }
		} else if(win==Winner.FirstDecides){
		    if(depth%2==0){
			w = Winner.FirstDecides;
		    } else{

		    }
		    
		}
		break;
	    case Second:
		if(win==Winner.Second){
		    w = Winner.Second;
		} else if(win==Winner.First){
		    if(depth%2==0){
			w = Winner.FirstDecides;
		    } else{
			w = Winner.SecondDecides;
		    }
		    
		} else if(win==Winner.SecondDecides){
		    if(depth%2==0){
			w = Winner.Second;
		    } else{
			w = Winner.SecondDecides;
		    }
		} else if(win==Winner.FirstDecides){
		    if(depth%2==0){
			w = Winner.FirstDecides;
		    } else{
			w = Winner.Second;
		    }
		    
		}
		break;
	    case FirstDecides:
		if(win==Winner.Second){
		    if(depth%2==0){
			
		    } else{
			w = Winner.Second;
		    }
		} else if(win==Winner.First){
		    if(depth%2==0){
			w = Winner.FirstDecides;
		    } else{
			w = Winner.First;
		    }
		    
		} else if(win==Winner.SecondDecides){
		    if(depth%2==0){
			w = Winner.FirstDecides;
		    } else{
			w = Winner.SecondDecides;
		    }
		} else if(win==Winner.FirstDecides){
			w = Winner.FirstDecides;
		}
		break;
	    case SecondDecides:
		if(win==Winner.Second){
		    if(depth%2==0){
			w = Winner.Second;
		    } else{
			w = Winner.SecondDecides;
		    }
		} else if(win==Winner.First){
		    if(depth%2==0){
			w = Winner.First;
		    } else{
			w = Winner.SecondDecides;
		    }
		    
		} else if(win==Winner.SecondDecides){
			w = Winner.SecondDecides;
		} else if(win==Winner.FirstDecides){
		    if(depth%2==0){
			w = Winner.FirstDecides;
		    } else{
			w = Winner.SecondDecides;
		    }
		    
		}
		break;
	    }
	}

	public Winner traverseNode(int depth){
	    this.depth = depth;
	    if(isLeaf()){
		if(depth%2==0){
		    this.w = Winner.Second;		    
		} else{
		    this.w = Winner.First;		    
		}
		return this.w;
	    }
	    for(int i = 0; i< children.size(); i++){
		setWinner(children.get(i).traverseNode(depth+1));
	    }
	    return this.w;
	}
	
	public void printNode(int depth){
	    System.out.println(this.letter + " " + depth + " " + this.w);
	    if(isLeaf()){
		return;
	    }
	    for(int i = 0; i< children.size(); i++){
		children.get(i).printNode(depth+1);
		
	    }
	}
	
    }
    
    private enum Winner{
	First,Second,FirstDecides,SecondDecides,Undecided;
    }
    

}
