Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-

import sys

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN = LIST()

# メモ[山の残数] = 今の手番がこの局面から勝てるか
memo = [None] * (K+1)

def dfs(k):
    # 既に見た局面ならメモの内容を返す
    if memo[k] is not None:
        return memo[k]
    for i in range(N):
        # 山の残数より多くは取れない
        if k-aN[i] < 0:
            break
        # 1つでも負けを押し付ける手があれば勝てる
        if not dfs(k-aN[i]):
            memo[k] = True
            return True
    # 負けを押し付ける手がなかったので自分が負ける
    memo[k] = False
    return False

if dfs(K):
    print('First')
else:
    print('Second')


Fixed submission:
# -*- coding: utf-8 -*-

"""
参考：https://kyopro-friends.hatenablog.com/entry/2019/01/12/231000
・ゲームDP
・負け状態を押し付けられるかどうか
"""

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN = LIST()

# メモ[山の残数] = 今の手番が勝てるか
dp = [False] * (K+1)
# 残数0は負け確定
dp[0] = False

for i in range(1, K+1):
    for j in range(N):
        # j枚取った時、負け状態に出来るなら、それを取ればいいので今の手番は勝てる
        if i-aN[j] >= 0 and dp[i-aN[j]] == 0:
            dp[i] = True
            break
if dp[K]:
    print('First')
else:
    print('Second')

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-

"""
参考：https://kyopro-friends.hatenablog.com/entry/2019/01/12/231000
・メモ化再帰
・手番はメモしなくていい
・負け状態を押し付けられるかどうか
"""

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN = LIST()

# メモ[山の残数] = 今の手番がこの局面から勝てるか
memo = [None] * (K+1)

def dfs(k):
    # 既に見た局面ならメモの内容を返す
    if memo[k] != None:
        return memo[k]
    for i in range(N):
        # 山の残数より多くは取れない
        if k-aN[i] < 0:
            break
        # 1つでも負けを押し付ける手があれば勝てる
        if not dfs(k-aN[i]):
            memo[k] = True
            return True
    # 負けを押し付ける手がなかったので自分が負ける
    memo[k] = False
    return False

if dfs(K):
    print('First')
else:
    print('Second')


Fixed submission:
# -*- coding: utf-8 -*-

"""
参考：https://kyopro-friends.hatenablog.com/entry/2019/01/12/231000
・ゲームDP
・負け状態を押し付けられるかどうか
"""

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN = LIST()

# メモ[山の残数] = 今の手番が勝てるか
dp = [False] * (K+1)
# 残数0は負け確定
dp[0] = False

for i in range(1, K+1):
    for j in range(N):
        # j枚取った時、負け状態に出来るなら、それを取ればいいので今の手番は勝てる
        if i-aN[j] >= 0 and dp[i-aN[j]] == 0:
            dp[i] = True
            break
if dp[K]:
    print('First')
else:
    print('Second')

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN = LIST()

# メモ[手番]][山の残数] = この局面から勝てるか
memo = [[None] * (K+1) for i in range(2)]

def dfs(turn, k):
    # 山がもう足りないので決着
    if k < 0:
        if turn == 0:
            return True
        else:
            return False
    # 先手番
    if turn == 0:
        # 既に見た局面ならメモの内容を返す
        if memo[turn][k] != None:
            return memo[turn][k]
        mx = -1
        for i in range(N):
            mx = max(mx, dfs(turn+1, k-aN[i]))
            # この先はやっても同じ
            if k-aN[i] < 0:
                break
        # ここより深い所を探し終わったので結果をメモする
        memo[turn][k] = mx
        return mx
    # 後手番
    else:
        if memo[turn][k] != None:
            return memo[turn][k]
        mn = float('inf')
        for i in range(N):
            mn = min(mn, dfs(turn-1, k-aN[i]))
            if k-aN[i] < 0:
                break
        memo[turn][k] = mn
        return mn

if dfs(0, K):
    print('First')
else:
    print('Second')


Fixed submission:
# -*- coding: utf-8 -*-

"""
参考：https://kyopro-friends.hatenablog.com/entry/2019/01/12/231000
・ゲームDP
・負け状態を押し付けられるかどうか
"""

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN = LIST()

# メモ[山の残数] = 今の手番が勝てるか
dp = [False] * (K+1)
# 残数0は負け確定
dp[0] = False

for i in range(1, K+1):
    for j in range(N):
        # j枚取った時、負け状態に出来るなら、それを取ればいいので今の手番は勝てる
        if i-aN[j] >= 0 and dp[i-aN[j]] == 0:
            dp[i] = True
            break
if dp[K]:
    print('First')
else:
    print('Second')

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN = LIST()

# メモ[手番]][山の残数] = この局面から勝てるか
memo = [[None] * (K+1) for i in range(2)]

def dfs(turn, k):
    # 山がもう足りないので決着
    if k < 0:
        if turn == 0:
            return True
        else:
            return False
    # 先手番
    if turn == 0:
        # 既に見た局面ならメモの内容を返す
        if memo[turn][k] != None:
            return memo[turn][k]
        mx = -1
        for i in range(N):
            mx = max(mx, dfs(turn+1, k-aN[i]))
            # この先はやっても同じ
            if k-aN[i] < 0:
                break
        # ここより深い所を探し終わったので結果をメモする
        memo[turn][k] = mx
        return mx
    # 後手番
    else:
        if memo[turn][k] != None:
            return memo[turn][k]
        mn = float('inf')
        for i in range(N):
            mn = min(mn, dfs(turn-1, k-aN[i]))
            if k-aN[i] < 0:
                break
        memo[turn][k] = mn
        return mn

if dfs(0, K):
    print('First')
else:
    print('Second')


Fixed submission:
# -*- coding: utf-8 -*-

"""
参考：https://kyopro-friends.hatenablog.com/entry/2019/01/12/231000
・ゲームDP
・負け状態を押し付けられるかどうか
"""

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN = LIST()

# メモ[山の残数] = 今の手番が勝てるか
dp = [False] * (K+1)
# 残数0は負け確定
dp[0] = False

for i in range(1, K+1):
    for j in range(N):
        # j枚取った時、負け状態に出来るなら、それを取ればいいので今の手番は勝てる
        if i-aN[j] >= 0 and dp[i-aN[j]] == 0:
            dp[i] = True
            break
if dp[K]:
    print('First')
else:
    print('Second')

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN = sorted(LIST())

# メモ[手番]][山の残数] = この局面から勝てるか
memo = [[None] * (K+1) for i in range(2)]

def dfs(turn, k):
    # 山がもう足りないので決着
    if k < 0:
        if turn == 0:
            return True
        else:
            return False
    # 先手番
    if turn == 0:
        # 既に見た局面ならメモの内容を返す
        if memo[turn][k] != None:
            return memo[turn][k]
        mx = -1
        for i in range(N):
            mx = max(mx, dfs(turn+1, k-aN[i]))
        # ここより深い所を探し終わったので結果をメモする
        memo[turn][k] = mx
        return mx
    # 後手番
    else:
        if memo[turn][k] != None:
            return memo[turn][k]
        mn = float('inf')
        for i in range(N):
            mn = min(mn, dfs(turn-1, k-aN[i]))
        memo[turn][k] = mn
        return mn

if dfs(0, K):   
    print('First')
else:
    print('Second')


Fixed submission:
# -*- coding: utf-8 -*-

"""
参考：https://kyopro-friends.hatenablog.com/entry/2019/01/12/231000
・ゲームDP
・負け状態を押し付けられるかどうか
"""

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN = LIST()

# メモ[山の残数] = 今の手番が勝てるか
dp = [False] * (K+1)
# 残数0は負け確定
dp[0] = False

for i in range(1, K+1):
    for j in range(N):
        # j枚取った時、負け状態に出来るなら、それを取ればいいので今の手番は勝てる
        if i-aN[j] >= 0 and dp[i-aN[j]] == 0:
            dp[i] = True
            break
if dp[K]:
    print('First')
else:
    print('Second')