CodeEff/ECCO huggingface dataset:
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
sorted(A)
DP = [-1] * (K+1)
for i in range(K+1):
    if i < A[0]:
        DP[i] = False
    else:
        for j in A:
            if i - j <= 0:
                DP[i] = False
            if not DP[i-j]:
                DP[i] = True
                break
            DP[i] = False
if DP[K]:
    print('First')
else:
    print('Second')


# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
m = min(A)
DP = [False] * (K+1)

for i in range(m, K+1):
    for a in A:
        if i - a >= 0 and DP[i-a] == False:
            DP[i] = True
            break
if DP[-1]:
    print('First')
else:
    print('Second')
# Original solution
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [False]*(K+1)

for i in range(K+1):
    for ai in a:
        if i-ai>=0:
            dp[i] |= not dp[i-ai]

if dp[K]:
    print('First')
else:
    print('Second')

# Optimized solution
import sys
input = sys.stdin.readline

N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [False]*(K+1)

for i in range(K+1):
    for ai in a:
        if i-ai>=0:
            dp[i] |= not dp[i-ai]

if dp[K]:
    print('First')
else:
    print('Second')
# Original solution
# K - Stones
def main():
    N, K, *A = list(map(int, open(0).read().split()))
    dp = [0] * (K + 1)
    for i in range(1, K + 1):
        for a in A:
            if i - a >= 0:
                dp[i] |= dp[i - a] ^ 1
            if dp[i]:
                break
    print(("First" if dp[-1] else "Second"))


if __name__ == "__main__":
    main()


# Optimized solution
# K - Stones
def main():
    N, K, *A = list(map(int, open(0).read().split()))
    dp = [False] * (K + 1)
    for i in range(K):
        if dp[i]:
            continue
        for a in A:
            if i + a > K:
                break
            dp[i + a] = True
    print(("First" if dp[-1] else "Second"))


if __name__ == "__main__":
    main()
# Original solution
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

from operator import xor
from functools import reduce

N,K,*A = list(map(int,read().split()))

a = reduce(xor,(1<<a for a in A))

dp = 0 # bitset
for n in range(K):
    if not(dp&(1<<n)):
        dp |= (a<<n)

answer = 'First' if dp&(1<<K) else 'Second'
print(answer)

# Optimized solution
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N,K,*A = list(map(int,read().split()))

dp = [0]*(K+1) # bitset
for n in range(K):
    if not dp[n]:
        for a in A:
            if n+a>K:
                break
            dp[n+a]=1

answer = 'First' if dp[-1] else 'Second'
print(answer)
# Original solution
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N,K,*A = list(map(int,read().split()))

dp = [0]*(K+1) # bitset
for n in range(K):
    if not dp[n]:
        for a in A:
            if n+a>K:
                break
            dp[n+a]=1

answer = 'First' if dp[-1] else 'Second'
print(answer)

# Optimized solution
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N,K,*A = list(map(int,read().split()))

dp = [0]*(K+K+1) # bitset
for n in range(K):
    if not dp[n]:
        for a in A:
            dp[n+a]=1

answer = 'First' if dp[K] else 'Second'
print(answer)
# Original solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

dp = [0] * (k+1)

for i in range(1, k+1):
    for j in range(n):
        if i - a[j] < 0:
            break
        if dp[i-a[j]] == 0:
            dp[i] = 1

if dp[k] == 1:
    print("First")
else:
    print("Second")

# Optimized solution
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))

dp = [0] * (k+1)

for i in range(1, k+1):
    for a in A:
        if i - a < 0:
            break
        if dp[i-a] == 0:
            dp[i] = 1

if dp[k] == 1:
    print("First")
else:
    print("Second")
# Original solution
# coding: utf-8

import sys
input = sys.stdin.readline

def f(N, A, K):
    dp = [0] * (K + 1)
    for i in range(K + 1):
        for x in A:
            if i < x:
                break
            if not dp[i - x]:
                dp[i] = 1
                break
    return(dp[K])

ans = [ "Second", "First" ]
n, k = list(map(int, input().split())) # 1 <= n <= 100, 1 <= k <= 10^5
a = list(map(int, input().split()))
print((ans[f(n, a, k)]))


# Optimized solution
# coding: utf-8

import sys
input = sys.stdin.readline

def f2(N, A, K):
    dp = [0] * (K + 1)
    for i in range(K + 1):
        if dp[i] == 0:
            # 残りi個で負けなので、ai個足した状況は勝ちになる。
            for x in A:
                if i + x <= K:
                    dp[i + x] = 1
    return(dp[K])

ans = [ "Second", "First" ]
n, k = list(map(int, input().split())) # 1 <= n <= 100, 1 <= k <= 10^5
a = list(map(int, input().split()))
print((ans[f2(n, a, k)]))
# Original solution
def judge(i):
    for a in a_s:
        di = i - a
        if di < 0:
            return "Second"
        if dp[di] == "Second":
            return "First"
    return "Second"


n, k = list(map(int, input().split()))
a_s = list(map(int, input().split()))
dp = [""] * (k + 1)
dp[0] = "Second"
for i in range(1, k + 1):
    dp[i] = judge(i)
print((dp[-1]))


# Optimized solution
n, k = list(map(int, input().split()))
a_s = list(map(int, input().split()))
dp = ["Second"] * (k + 1)
for i in range(k + 1):
    if dp[i] == "Second":
        for a in a_s:
            ii = i + a
            if ii <= k:
                dp[ii] = "First"
print((dp[-1]))
# Original solution
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
ans=[-1]*(k+1)
ans[0]=False # lose

for i in range(k+1):
    iswin = False
    for num in a:
        if (i-num >=0) and (not ans[i-num]):
            iswin=True
    ans[i]=iswin

if ans[-1]:
    print("First")
else:
    print("Second")

# Optimized solution
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
ans=[False]*(k+1)
ans[0]=False

for i in range(k+1):
    for num in a:
        if (i-num >=0) and (not ans[i-num]):
            ans[i]=True

if ans[-1]:
    print("First")
else:
    print("Second")
# Original solution
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))

dp = [False]*(K+1)

for i in range(K+1):
    for j in range(N):
        if i-A[j]>=0 and dp[i-A[j]] == False:
            dp[i] = True

        
if dp[K]:
    print("First")
else:
    print("Second")

# Optimized solution
n,k = list(map(int,input().split()))
arr = list(map(int,input().split()))

dp = [False]*(k+1)

for stones in range(k+1):
    for x in arr:
        if stones >= x and dp[stones-x] == False:
            dp[stones] = True

if dp[k]:
    print("First")
else:
    print("Second")
# Original solution
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
    n,k=list(map(int,input().split()))
    A=list(map(int,input().split()))
    dp=[0]*(k+1)
    for i in range(k):
        if dp[i]: continue
        for j in range(n):
            if i+A[j]<=k: dp[i+A[j]]=1
    print(("First" if dp[k] else "Second"))
resolve()

# Optimized solution
import sys
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
def resolve():
    n, k = list(map(int, input().split()))
    A = list(map(int, input().split()))
    dp = [False] * (k + 1)

    for i in range(k + 1):
        if dp[i]:
            continue
        for a in A:
            if i + a <= k:
                dp[i + a] = True

    print(("First" if dp[k] else "Second"))
resolve()
# Original solution
def solve(N, K, cards):
  min_elem = cards[0]

  TARO, JIRO = 0, 1
  dp = [[-1 for _ in range(K + 1)] for _ in range(2)]

  dp[TARO][0] = TARO
  dp[JIRO][0] = JIRO

  for i in range(min_elem):
    dp[JIRO][i] = TARO
    dp[TARO][i] = JIRO

  for k in range(1, K + 1):
    for turn in [TARO, JIRO]:
      opp = JIRO if turn == TARO else TARO
      dp[turn][k] = opp
      for c in cards:
        if c > k:
          break
        if k - c == 0:
          dp[turn][k] = turn
          break
        if k - c > 0 and dp[opp][k - c] == turn:
          dp[turn][k] = turn

  print(("First" if dp[TARO][K] == TARO else "Second"))

  
def iln(): return list(map(int, input().split()))


N, K = iln()
cards = iln()
solve(N, K, cards)

# Optimized solution
def solve(N, K, cards):
  min_elem = cards[0]

  # dp[i] == True: Current player will win if i stones left
  dp = [False for _ in range(K + 1)]
  for i in range(min_elem):
    dp[i] = False

  for k in range(1, K + 1):
    for c in cards:
      if c > k:
        break
      if k - c >= 0 and dp[k - c] == False:
        dp[k] = True

  print(("First" if dp[K] else "Second"))

  
def iln(): return list(map(int, input().split()))


N, K = iln()
cards = iln()
solve(N, K, cards)
# Original solution
n, k = list(map(int, input().split( )))

a = list(map(int, input().split( )))

dp = [0]*(k+1)

for i in range(k+1):
    win = 0
    for j in a:
        if i>=j and dp[i-j] == 0:
            win = 1
            break
    dp[i] = win
#print(*dp)            
if dp[k] == 1:
    print("First")
else:
    print("Second")

# Optimized solution
n, k = list(map(int, input().split()))

a = list(map(int, input().split( )))

dp = [0]*(k+1)
#0は先手負け、1が先手勝ち

for i in range(a[0],k+1):
    for p in a:#負かす手があれば勝ち
        if i-p >= 0 and dp[i-p] == 0:
            dp[i] = 1
            break
if dp[k] == 1:
    print("First")
else:
    print("Second")
# Original solution
n, k = list(map(int, input().split()))
a = tuple(map(int, input().split()))

dp = [None] * (k + 1)
# dp[手番の石の数] := 手番の勝敗
# True(勝ち) / None(負け)

for my_remains in range(k + 1):
    for my_take in a:
        opponent_remains = my_remains - my_take  # 相手が操作を行う石の数
        if opponent_remains >= 0 and dp[opponent_remains] is None:
            dp[my_remains] = True

ans = dp[k]
print(('First' if ans else 'Second'))


# Optimized solution
n, k = list(map(int, input().split()))
a = tuple(map(int, input().split()))

dp = [None] * (k + k + 1)
# dp[手番の石の数] := 手番の勝敗
# True(勝ち) / None(負け)

for opponent_remains in range(k):  # 自分が石を取った残りなので、k未満
    if dp[opponent_remains] is None:  # 相手が負ける場合
        for my_take in a:  # 自分が取る石の数
            my_remains = opponent_remains + my_take  # 相手が負けるようにできる、自分の手番の石の数
            dp[my_remains] = True

ans = dp[k]
print(('First' if ans else 'Second'))
# Original solution
n, k = list(map(int, input().split()))
a = tuple(map(int, input().split()))

dp = [None] * (k + k + 1)
# dp[手番の石の数] := 手番の勝敗
# True(勝ち) / None(負け)

for opponent_remains in range(k):  # 自分が石を取った残りなので、k未満
    if dp[opponent_remains] is None:  # 相手が負ける場合
        for my_take in a:  # 自分が取る石の数
            my_remains = opponent_remains + my_take  # 相手が負けるようにできる、自分の手番の石の数
            dp[my_remains] = True

ans = dp[k]
print(('First' if ans else 'Second'))


# Optimized solution
import sys

input = sys.stdin.readline

n, k = list(map(int, input().split()))
a = tuple(map(int, input().split()))

dp = [None] * (k + k + 1)
# dp[手番の石の数] := 手番の勝敗
# True(勝ち) / None(負け)

for opponent_remains in range(k):  # 自分が石を取った残りなので、k未満
    if dp[opponent_remains] is None:  # 相手が負ける場合
        for my_take in a:  # 自分が取る石の数
            my_remains = opponent_remains + my_take  # 相手が負けるようにできる、自分の手番の石の数
            dp[my_remains] = True

ans = dp[k]
print(('First' if ans else 'Second'))

# 内側のループに入る前に枝刈りしているので、速い
# Original solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
ans = [False]*(k+1)
for i in range(1,k+1):
    ok = False
    for j in a:
        if i-j<0:
            continue
        if ans[i-j] == False:
            ans[i] = True

print(('First' if ans[k] else 'Second'))

# Optimized solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
ans = [False]*(k+1)
for i in range(1,k+1):
    ok = False
    for j in a:
        if i-j<0:
            continue
        if ans[i-j] == False:
            ans[i] = True
            break

print(('First' if ans[k] else 'Second'))
# Original solution

def resolve():
    N, K = list(map(int, input().split()))
    A = list(map(int, input().split()))

    dp = [False]*(K+1)

    for i in range(K+1):
        for j in range(N):
            if i - A[j] >= 0:
                dp[i] |= ~dp[i-A[j]]
    if dp[K]:
        print("First")
    else:
        print("Second")


if __name__ == "__main__":
    resolve()

# Optimized solution

def resolve():
    N, K = list(map(int, input().split()))
    A = list(map(int, input().split()))

    dp = [False]*(K+1)
        
    for i in range(K+1):
        for j in range(N):
            if i - A[j] >= 0:
                dp[i] |= not dp[i-A[j]]
    if dp[K]:
        print("First")
    else:
        print("Second")


if __name__ == "__main__":
    resolve()
# Original solution
"""
AtCoder Educational DP Contest
https://atcoder.jp/contests/dp/tasks/dp_k

K - Stones
"""
import collections

def solve(xs):
    dp = collections.defaultdict(bool)
    dp[0] = False

    for j in range(1, K + 1):
        iterable = ((j >= x) and (not dp[j - x]) for x in xs)
        dp[j] = any(iterable)
    return dp[K]

N, K = list(map(int, input().split()))
choices = collections.Counter([float(s) for s in input().split()])
assert len(choices) == N
res = solve(choices)
print(("First" if res else "Second"))


# Optimized solution
"""
AtCoder Educational DP Contest
https://atcoder.jp/contests/dp/tasks/dp_k

K - Stones
"""
import collections

def solve(xs):
    dp = collections.defaultdict(bool)
    dp[0] = False
    for j in range(1, K + 1):
        dp[j] = any((j >= x) and (not dp[j - x]) for x in xs)
    return dp[K]

N, K = list(map(int, input().split()))
choices = [int(s) for s in input().split()]
assert len(choices) == N
res = solve(choices)
print(("First" if res else "Second"))
# Original solution
N, K, *A = list(map(int, open(0).read().split()))

dp = [False] * (K + 1)
for i in range(1, K + 1):
    if dp[i]:
        continue

    for a in A:
        if i - a >= 0:
            dp[i] |= not dp[i - a]

if dp[K]:
    print("First")
else:
    print("Second")

# Optimized solution
N, K, *A = list(map(int, open(0).read().split()))

dp = [False] * (2 * K + 1)
for i in range(K):
    if not dp[i]:
        for a in A:
            dp[i + a] = True

if dp[K]:
    print("First")
else:
    print("Second")
# Original solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
tf = ["" for _ in range(k+1)]
tf[0] = False
for i in range(1,k+1):
  j = 0
  flag = 0
  while j < n and i - a[j] >= 0:
    if tf[i-a[j]] == False:
      tf[i] = True
      flag = 1
      break
    j += 1
  if flag ==0:
    tf[i] = False
if tf[k]:
  print("First")
else:
  print("Second")
      
    
  


# Optimized solution
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
s = [False]*(k+1)
for i in range(k+1):
  for aj in a:
    if i - aj >=0:
      if s[i-aj] == False:
        s[i] = True
        break
if s[k]==True:
  print("First")
else:
  print("Second")
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

dp = ['First']*(K+1)
dp[0] = 'Second'
def solve(dp):
    for i in range(1,K+1):
        for j in range(N):
            dp[i] = 'Second'
            if dp[i-A[j]]=='Second':
                dp[i] = 'First'
                break
    ans = dp[K]
    return ans
print((solve(dp)))

# Optimized solution
def solve():
  N, K = list(map(int, input().split()))
  A = list(map(int, input().split()))
  dp = ['Second']*(K*2)
  for i in range(K):
    if dp[i]!='Second':
      continue
    for j in range(N):
      dp[i+A[j]]='First'
  ans = dp[K]
  return ans
print((solve()))
# Original solution
import sys,queue,math,copy,itertools,bisect,collections,heapq
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N,K = LI()
a = LI()
dp = [0 for _ in range(K+1)]

for i in range(K,-1,-1):
    if dp[i]: continue
    for x in a: dp[i-x] = 1
if dp[0] == 1:
    print('First')
else:
    print('Second')

# Optimized solution
import sys
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
N,K = LI()
a = LI()
dp = [0 for _ in range(K+1)]

for i in range(K,-1,-1):
    if dp[i]: continue
    for x in a:
        if i-x >= 0: dp[i-x] = 1
if dp[0] == 1:
    print('First')
else:
    print('Second')
# Original solution
def solve():
    k, a = read()
    result = think(k, a)
    write(result)


def read():
    n, k = read_int(2)
    a = read_int(n)
    return k, a


def read_int(n):
    return list([int(x) for x in read_line().split(' ')])[:n]


def read_float(n):
    return list([float(x) for x in read_line().split(' ')])[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(k, a):
    max_n = 100
    max_k = 10 ** 5

    # dp[i] = True/False; True means First player win if num of stone is i
    dp = [False] * (max_n * max_k + 1)

    for i in range(len(dp)):
        for elem in a:
            if i >= elem:
                dp[i] |= not dp[i - elem]

    return dp[k]


def write(result):
    if result:
        print('First')
    else:
        print('Second')


if __name__ == '__main__':
    solve()

# Optimized solution
def solve():
    k, a = read()
    result = think(k, a)
    write(result)


def read():
    n, k = read_int(2)
    a = read_int(n)
    return k, a


def read_int(n):
    return list([int(x) for x in read_line().split(' ')])[:n]


def read_float(n):
    return list([float(x) for x in read_line().split(' ')])[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(k, a):
    max_n = 100

    # dp[i] = True/False; True means First player win if num of stone is i
    dp = [False] * (k + max_n + 1)

    for i in range(len(dp)):
        for elem in a:
            if i >= elem:
                dp[i] |= not dp[i - elem]

    return dp[k]


def write(result):
    if result:
        print('First')
    else:
        print('Second')


if __name__ == '__main__':
    solve()
# Original solution
import sys
input = sys.stdin.readline

n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
dp = [0]*(k+1)
for i in range(k+1):
  for a in A:
    if i-a >= 0:
      dp[i] |= ~dp[i-a]
result = dp[k]
if result:
  print("First")
else:
  print("Second")

# Optimized solution
import sys
input = sys.stdin.readline

n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
dp = [0]*(k+1)
for i in range(k+1):
  for a in A:
    if i-a >= 0 and not dp[i-a]:
      dp[i] = 1
      break
result = dp[k]
if result:
  print("First")
else:
  print("Second")
# Original solution
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
# dp[i] i個の石で手番の時の勝ち負け
dp = [0]*(k+1)
# 貰う
for i in range(1, k+1):
    for j in range(n):
        if i-A[j] < 0:
            continue
        dp[i] = max(dp[i], 1 if dp[i-A[j]] == 0 else 0)
print(('First' if dp[k] else 'Second'))


# Optimized solution
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
dp = [0]*(k+1)
for i in range(1, k+1):
    for j in range(n):
        if i-A[j] < 0:
            continue
        dp[i] |= not dp[i-A[j]]
print(('First' if dp[k] else 'Second'))
# Original solution
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    n,k=list(map(int,input().split()))
    A=list(map(int,input().split()))
    dp=[0]*(k+1) #0:i個だったら必ず負ける，正:勝つ
    for i in range(min(A),k+1):
        for a in A:
            if i-a>=0 and dp[i-a]==0:
                dp[i]=1
                break
        else:
            dp[i]=0
    if dp[k]==0:
        print("Second")
    else:
        print("First")

if __name__=='__main__':
    main()

# Optimized solution
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    n,k=list(map(int,input().split()))
    A=list(map(int,input().split()))
    dp=[False]*(k+1) #0:i個だったら必ず負ける，正:勝つ
    for i in range(min(A),k+1):
        for a in A:
            if i-a>=0 and not dp[i-a]:
                dp[i]=True
                break
        else:
            dp[i]=False
    if dp[k]:
        print("First")
    else:
        print("Second")

if __name__=='__main__':
    main()
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

dp = [False] * (10 ** 5 + 10)
for i in range(1, K+1):
    dp[i] = not all(dp[i-a] if i-a >= 0 else True for a in A)

print(("First" if dp[K] else "Second"))



# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

dp = [False] * (10 ** 5 + 10)
for i in range(1, K+1):
    # dp[i-a]の中でどこか一つでもFalseになるdp[i]があればTrueを設定する
    # dp[i-a]がFalseということは、次の手番の相手を負かす取り方が存在するということになるので、この手番でa個取って相手の順番に回してしまえば勝ちが確定する
    # お互いが交互に数字を言っていって、最後に30を言ったほうの負け（最大+3）まで
    # みたいなゲームと同じ構造だと考えていい。上記のゲームで勝つには最後の数から逆算していけば、勝てる数字がわかるのと似ている
    dp[i] = not all(dp[i-a] if i-a >= 0 else True for a in A)

print(("First" if dp[K] else "Second"))
# Original solution


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

dp = [False] * (k + 1)

for i in range(1, k+1):
    for a in arr:
        if i - a >= 0 and not dp[i - a]:
            dp[i] = True

print(("First" if dp[k] else "Second"))


# Optimized solution
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
dp = [False] * (k + 1)

for i in range(k + 1):
    if not dp[i]:
        for a in arr:
            if i + a > k:
                break
            dp[i + a] = True

print(("First" if dp[k] else "Second"))
# Original solution
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10000000)
    from collections import Counter, deque
    #from collections import defaultdict
    from itertools import combinations, permutations, accumulate
    #from itertools import product
    from bisect import bisect_left,bisect_right
    import heapq
    from math import floor, ceil
    #from operator import itemgetter

    #inf = 10**17
    #mod = 10**9 + 7

    N,K = list(map(int, input().split()))
    a = list(map(int, input().split()))
    dp = [0]*(K+1)
    for i in range(1, K+1):
        for j in a:
            if i-j < 0:
                continue
            if dp[i-j] == 0:
                dp[i] = 1
                break
    if dp[K]:
        print('First')
    else:
        print('Second')

if __name__ == '__main__':
    main()

# Optimized solution
def main():
    N, K, *A = list(map(int, open(0).read().split()))
    dp = [0] * (K + 1)
    for i in range(K):
        if dp[i]:
            continue
        for a in A:
            if i + a > K:
                break
            dp[i + a] = 1
    print(("First" if dp[-1] else "Second"))
if __name__ == "__main__":
    main()
# Original solution
import sys
sys.setrecursionlimit(10**7)

N, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]
    
def func():
    for i in range(1, K+1):
        for j in range(N):
            if i - A[j] >= 0:
                dp[i] |= ~dp[i - A[j]]
                
dp = [0 for i in range(K+1)]
func()
if dp[K]: print("First")
else: print("Second")

# Optimized solution
import sys
input = sys.stdin.readline

N, K = list(map(int, input().split()))
A = [int(i) for i in input().split()]

dp = [0 for i in range(K+1)]
for i in range(K+1):
    if not dp[i]:
        for j in range(N):
            if i + A[j] < K + 1:
                dp[i+A[j]] = 1

if dp[K]: print("First")
else: print("Second")