// Slower C++ solution:
#include<set>

#include<map>

#include<cmath>

#include<ctime>

#include<queue>

#include<stack>

#include<cstdio>

#include<string>

#include<vector>

#include<random>

#include<cstdlib>

#include<cstring>

#include<iomanip>

#include<iostream>

#include<algorithm>

#include<unordered_map>

#define endl "\n"

#define fi first

#define se second

#define db double

#define gcd __gcd

#define pb push_back

#define mp make_pair

#define lowbit(x) (x & (-x))

#define PII  pair<int, int> 

#define all(x) x.begin(), x.end()

#define debug(x) cout << #x << " = " << x << endl

#define rep(i, a, b) for(__typeof(b) i = a; i <= (b); i++)

#define Rep(i, a, b) for(__typeof(a) i = a; i >= (b); i--)

#define FAST ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)

template<class T> inline T qmin(T a, T b) { return a < b ? a : b; }

template<class T> inline T qmax(T a, T b) { return a > b ? a : b; }

typedef long long ll;

typedef unsigned long long ull;

const db eps = 1e-9;

const db PI = acos(-1);

const int inf = 0x3f3f3f3f;

const int mod = (int)1e9 + 7;

const int maxn = (int)1e5 + 5;//remember to modify it, No RE or MLE

const ll INF = 0x3f3f3f3f3f3f3f3f;

using namespace std;



ll qpow(ll x, ll y) { ll ret = 1; for( ; y; y >>= 1, x = (x * x) % mod) if(y & 1) ret = (ret * x) % mod; return ret; }



inline int read(){

	char ch = getchar();

	int x = 0, f = 1;

	while(ch < '0' || ch > '9'){

		if(ch == '-') f = -1;

		ch = getchar();

	}

	while('0' <= ch && ch <= '9'){

		x = x * 10 + ch - '0';

		ch = getchar();

	}

	return x * f;

}



int dp[maxn];//0 必败态; 1必胜态; -1尚未确定;

int a[105];

int n, k;

int cnt = 0;



bool dfs(int now){

	if(~dp[now]) return dp[now];

	bool ret = 0;

	rep(i, 1, n){

		if(a[i] > now) break;

		if(!dfs(now - a[i])) ret = 1;

	}

	return dp[now] = ret;

}



int main()

{

	n = read(), k = read();

	rep(i, 1, n) a[i] = read();

	memset(dp, -1, sizeof dp);

	sort(a + 1, a + n + 1);

	dp[0] = 0;

	dfs(k);

	puts(dp[k] ? "First" : "Second");

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.4676343411109136x):
#include<bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;

using namespace std;

using ll=long long;

using db=double;



///***************************************************** CONSTANTS ******************************************************///



int const N=1e6+3;

ll MOD=1e9+7,fact[N];

const long long inf=(long long)1e18;

const long double PI=3.14159265358979;



///************************************************ CONTAINER DEFINITIONS ***********************************************///



typedef vector<int> vi;

typedef vector<ll> vl;

typedef pair<int,int> pii;

typedef pair<ll, ll> pll;

typedef vector<pii> vii;

typedef vector<pll> vll;

typedef set<int> si;

typedef set<ll> sl;

typedef map<int,int> mii;

typedef map<ll,ll> mll;



///************************************************ SHORT FORM KEYWORDS *************************************************///



#define PB push_back

#define F first

#define S second

#define MP make_pair

#define I insert

#define lb lower_bound

#define ub upper_bound

#define endl '\n'



///************************************************ SHORT FORM FUNCTIONS ************************************************///



#define loop(i,a,b) for(ll i=a;i<b;i++)

#define loopr(i,a,b) for(ll i=a-1;i>=b;i--)

#define afor(x, y) for (auto x : y)

#define mem(a,b) memset(a, b, sizeof(a) )

#define gcd(a,b) __gcd(a,b)

#define lcm(a,b) (a*(b/gcd(a,b)))

#define sa(v) sort(v.begin(),v.end())

#define sd(v) sort(v.begin(),v.end(),greater<>())

#define rev(s) reverse(s.begin(),s.end())

#define stll(x) stoll(x, nullptr, 10);

#define yes cout<<"YES"<<endl;

#define no cout<<"NO"<<endl;

#define mx(a) *max_element(all(a))

#define mn(a) *min_element(all(a))

#define all(a) a.begin(),a.end()

#define mxa(a,N) *max_element(a,a+N)

#define mna(a,N) *min_element(a,a+N)

#define print(a) {for(auto x:a)cout<<x<<" ";cout<<endl;}



///******************************************** FAST IO $ FILE INPUT ****************************************************///



#define io() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

#define fraction() cout.unsetf(ios::floatfield); cout.precision(10); cout.setf(ios::fixed,ios::floatfield);

#define fio() freopen("input_file_name","r",stdin);freopen("output_file_name","w",stdout);



///********************************************* REQUIRED FUNCTIONS *****************************************************///



ll powmod(ll a,ll b){ll p=MOD;a%=p;if(!a) return 0;ll pr=1;while(b>0){if(b&1){pr*=a;pr%=p;--b;}a*=a;a%=p;b/=2;}return pr;}

ll inv(ll a,ll p){return powmod(a,p-2);}

ll nCr(ll n,ll k,ll p){fact[0]=1;loop(i,1,n+1) fact[i]=fact[i-1]*i;return ((fact[n]*inv(fact[k],p)%p)*inv(fact[n-k],p))%p;}

bool isPrime(ll n){ if(n<=1)return false;if(n<=3)return true;if(n%2==0 or n%3==0)return false;for(ll i=5;i*i<=n;i+=6){if(n%i==0|n%(i+2)==0)return false;}return true;}



///######################################################################################################################///



typedef tree<pair<ll,ll>, null_type, less<pair<ll,ll>>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;



///************************************************ SOLUTION STARTS HERE ************************************************///

///======================================================================================================================///





void solve()

{

    ll  n,k;

    cin>>n>>k;

    vl a(n);

    loop(i,0,n) cin>>a[i];

    vector<bool> dp(k+1,false);

    loop(i,0,k+1)

    {

        for(auto x: a)

        {

            if(i>=x&&!dp[i-x]) dp[i]=true;

        }

    }

    if(dp[k]) cout<<"First\n";

    else cout<<"Second\n";

}



int main()

{

    io();

    int $=1;//cin>>$;

    while($--) solve();

    return 0;

}