stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int main() {

  int N, K; cin >> N >> K;

  vector<int> A(N);

  for (int i = 0; i < N; i++) cin >> A.at(i);

  vector<int> dp(100001, 0);

  for (int i = 1; i <= K; i++) {

    for (int j = 0; j < N; j++) {

      if (i - A.at(j) >= 0 && dp.at(i-A.at(j)) == 0) dp.at(i) = 1;

    }

  }

  if (dp.at(K)) cout << "First" << endl;

  else cout << "Second" << endl;

}

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

using namespace std;



int main() {

  int N, K; cin >> N >> K;

  vector<int> A(N);

  for (int i = 0; i < N; i++) cin >> A.at(i);

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

  for (int i = 0; i <= K; i++) {

    if (dp.at(i)) continue;

    for (int j = 0; j < N; j++) {

      if (i + A.at(j) > K) continue;

      dp.at(i + A.at(j)) = true; 

    }

  }

  if (dp.at(K)) cout << "First" << endl;

  else cout << "Second" << endl;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



vector<int> grundy(100005, -1);



int getMax(set<int> s)

{

	int max = 0;

	while(s.find(max) != s.end())

		max++;

	return max;

}



int getGrundy(int pos, int *a, int n)

{

	if(grundy[pos] != -1)

		return grundy[pos];

	set<int> s;

	for(int i = 0; i < n; i++)

	{

		if(a[i] > pos)

		break;

		int res = getGrundy(pos - a[i], a, n);

		s.insert(res);

	}

	return grundy[pos] = getMax(s);

}



int main() {

	int n, k;

	cin >> n >> k;

	int a[n];

	for(int i = 0; i < n; i++)

		cin >> a[i];

	sort(a, a + n);

	grundy[0] = 0;

	grundy[k] = getGrundy(k, a, n);

	if(grundy[k])

	cout << "First\n";

	else

	cout << "Second\n";

	

	return 0;

}

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

using namespace std;



int main()

{

  int n, k;

  scanf("%d%d", &n, &k);

  vector<int> a(n);

  for(int &i : a)

  {

    scanf("%d", &i);

  }

  vector<bool> dp(k + 1);

  for(int i = 1; i <= k; i++)

  {

    for(int j = 0; j < n; j++)

    {

      if(i - a[j] >= 0 and !dp[i - a[j]])

      {

        dp[i] = true;

      }

    }

  }

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

  

  return 0;

}
// Slower C++ solution:
#include <iostream>

#include <iomanip>

#include <vector>

#include <cmath>

#include <algorithm>

#include <iomanip>

#include <cstring>

#define rep(i, N) for (int i = 0; i < (int)N; i++)

using namespace std;

typedef long long ll;

const ll INF = 9223372036854775807/2;

const int MOD = 1000000007;

const int N_MAX = 100 + 10;

const int K_MAX = pow(10,5)+10;



int N, K;

vector<int> dp(K_MAX, -1);

vector<int> a(N_MAX, -1);



bool dfs(int k) {

  if (k==0) return dp[0] = 0;

  if (dp[k]!=-1) return dp[k];

  int result = 0;

  rep(i, N) if (k>=a[i] && dfs(k-a[i]) == 0 ) result = 1;

  return dp[k] = result;

}



int main() {

  cin >> N >> K;

  rep(i, N) cin >> a[i];



  dfs(K);

  // rep(i, K+1) cout << dp[i] << endl;

  string result;

  if (dp[K]==1) result = "First";

  else result = "Second";

  cout << result << endl;

  return 0;

}

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



using namespace std;

typedef long long ll;

typedef pair<ll, ll> p_ll;



template<class T>

void debug(T itr1, T itr2) { auto now = itr1; while(now<itr2) { cout << *now << " "; now++; } cout << endl; }

#define repr(i,from,to) for (int i=(int)from; i<(int)to; i++)

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

#define rep(i,N) repr(i,0,N)

#define per(i,N) for (int i=(int)N-1; i>=0; i--)



const ll MOD = pow(10,9)+7;

const ll LLINF = pow(2,61)-1;

const int INF = pow(2,30)-1;



vector<ll> fac;

void c_fac(int x=pow(10,6)+10) { fac.resize(x,true); rep(i,x) fac[i] = i ? (fac[i-1]*i)%MOD : 1; }

ll inv(ll a, ll m=MOD) { ll b = m, x = 1, y = 0; while (b!=0) { int d = a/b; a -= b*d; swap(a,b); x -= y*d; swap(x,y); } return (x+m)%m; }

ll nck(ll n, ll k) { return fac[n]*inv(fac[k]*fac[n-k]%MOD)%MOD; }

ll gcd(ll a, ll b) { if (a<b) swap(a,b); return b==0 ? a : gcd(b, a%b); }

ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }





int main() {

  int N, K; cin >> N >> K;

  int a[N]; rep(i,N) cin >> a[i];

  bool dp[K+1] = {};

  rep(i,K+1) rep(j,N) if (i>=a[j]) dp[i] |= !dp[i-a[j]];

  // debug(dp,dp+(K+1));



  string result = dp[K] ? "First" : "Second";

  cout << result << endl;

  return 0;

}
// Slower C++ solution:
#include <iostream>

#include <cstring>

#include <vector>

#include <set>

#include <map>

#include <sstream>

#include <cstdio>

#include <algorithm>

#include <stack>

#include <queue>

#include <cmath>

#include <iomanip>

#include <fstream>

//#include <bits/stdc++.h>

using namespace std;

typedef unsigned long long ll;

const ll INF = (1 << 30);

const ll inf = (1LL << 50LL);

const int  maxn = 1e5 + 5;

const int MOD = 1e9 + 7;

int n, k;

int arr[maxn];

int dp[maxn];

int rek(int left){

    if(dp[left] != -1){

        return dp[left];

    }

    int ret = 1;

    for(int i = 0; i <n; i ++){

        if(left >= arr[i]){

            ret &= rek(left - arr[i]);

        }

    }

    return dp[left] = !ret;

}

int main(int argc, const char * argv[]) {

    ios_base::sync_with_stdio(false);

//    ifstream cin("in.txt");

    cin >> n >> k;

    for(int i = 0; i < n; i ++){

        cin >> arr[i];

    }

    memset(dp, -1, sizeof dp);

    if(rek(k)) {

        cout << "First\n";

    }

    else{

        cout << "Second\n";

    }

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.4749433822784899x):
#include <iostream>

#include <cstring>

#include <vector>

#include <set>

#include <map>

#include <sstream>

#include <cstdio>

#include <algorithm>

#include <stack>

#include <queue>

#include <cmath>

#include <iomanip>

#include <fstream>

//#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll INF = (1 << 30);

const ll inf = (1LL << 60LL);

const int  maxn = 1e5 + 5;

int n, k;

int arr[105];

bool dp[maxn];

int main(int argc, const char * argv[]) {

    ios_base::sync_with_stdio(false);

    cin >> n >> k;

    for(int i = 0; i < n; i ++){

        cin >> arr[i];

    }

    for(int stones = 0; stones <= k; stones ++){

        for(int i = 0; i < n; i ++){

            if(stones >= arr[i] and !dp[stones - arr[i]]){

                dp[stones] = true;

            }

        }

    }

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

    else cout << "Second\n";

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h> 

using namespace std;

typedef long long int ll;

typedef vector<ll> vi;

typedef pair<ll,ll> pii;

#define fo(i,s,e_ex) for(i=s;i<e_ex;i++)

#define Fo(i,k,n) for(i=k;k<n?i<=n:i>=n;k<n?i+=1:i-=1)

#define endl '\n'

#define MOD 1000000007//998244353

#define pbb push_back

#define mpp make_pair

#define ff first

#define ss second

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

#define mset(arr,val) memset(arr,val,sizeof(arr))

ll n;

ll arr[105];

int dp[100005][2];

bool play(ll k,int pl){//biased for pl=0

	if(dp[k][pl]!=-1) return dp[k][pl];

	bool ans=pl;

	ll i;

	fo(i,0,n){

		if(k>=arr[i]){

			bool myans=play(k-arr[i],1-pl);

			if(pl==0&&myans) ans=true;

			else if(pl==1&&!myans) ans=false;

		}

	}

	return dp[k][pl]=ans;

}

void solve(ll caseno){

	ll i,j,k;

	cin>>n>>k;

	fo(i,0,n) cin>>arr[i];

	mset(dp,-1);

	cout<<(play(k,0)?"First":"Second")<<endl;

}

int main(){

	ios_base::sync_with_stdio(false);

	cin.tie(0);cout.tie(0);

	ll t=1;

	//cin>>t;

	for(ll i=1;i<=t;i++){

		solve(i);

	}

	return 0;

}


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

using namespace std;

typedef long long int ll;

typedef vector<ll> vi;

typedef pair<ll,ll> pii;

#define fo(i,s,e_ex) for(i=s;i<e_ex;i++)

#define Fo(i,k,n) for(i=k;k<n?i<=n:i>=n;k<n?i+=1:i-=1)

#define endl '\n'

#define MOD 1000000007//998244353

#define pbb push_back

#define mpp make_pair

#define ff first

#define ss second

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

#define mset(arr,val) memset(arr,val,sizeof(arr))

ll n;

ll arr[105];

int dp[100005];

bool play(ll k){

	if(dp[k]!=-1) return dp[k];

	bool ans=false;

	ll i;

	fo(i,0,n){

		if(k>=arr[i]){

			bool myans=play(k-arr[i]);

			if(myans==false) ans=true;

		}

	}

	return dp[k]=ans;

}

void solve(ll caseno){

	ll i,j,k;

	cin>>n>>k;

	fo(i,0,n) cin>>arr[i];

	mset(dp,-1);

	cout<<(play(k)?"First":"Second")<<endl;

}

int main(){

	ios_base::sync_with_stdio(false);

	cin.tie(0);cout.tie(0);

	ll t=1;

	//cin>>t;

	for(ll i=1;i<=t;i++){

		solve(i);

	}

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h> 

using namespace std;

typedef long long int ll;

typedef vector<ll> vi;

typedef pair<ll,ll> pii;

#define fo(i,s,e_ex) for(i=s;i<e_ex;i++)

#define Fo(i,k,n) for(i=k;k<n?i<=n:i>=n;k<n?i+=1:i-=1)

#define endl '\n'

#define MOD 1000000007//998244353

#define pbb push_back

#define mpp make_pair

#define ff first

#define ss second

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

#define mset(arr,val) memset(arr,val,sizeof(arr))

ll n;

ll arr[105];

int dp[100005][2];

bool play(ll k,int pl){//biased for pl=0

	if(dp[k][pl]!=-1) return dp[k][pl];

	bool ans=pl;

	ll i;

	fo(i,0,n){

		if(k>=arr[i]){

			bool myans=play(k-arr[i],1-pl);

			if(pl==0&&myans) ans=true;

			else if(pl==1&&!myans) ans=false;

		}

	}

	return dp[k][pl]=ans;

}

void solve(ll caseno){

	ll i,j,k;

	cin>>n>>k;

	fo(i,0,n) cin>>arr[i];

	mset(dp,-1);

	cout<<(play(k,0)?"First":"Second")<<endl;

}

int main(){

	ios_base::sync_with_stdio(false);

	cin.tie(0);cout.tie(0);

	ll t=1;

	//cin>>t;

	for(ll i=1;i<=t;i++){

		solve(i);

	}

	return 0;

}


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

using namespace std;

typedef long long int ll;

typedef vector<ll> vi;

typedef pair<ll,ll> pii;

#define fo(i,s,e_ex) for(i=s;i<e_ex;i++)

#define Fo(i,k,n) for(i=k;k<n?i<=n:i>=n;k<n?i+=1:i-=1)

#define endl '\n'

#define MOD 1000000007//998244353

#define pbb push_back

#define mpp make_pair

#define ff first

#define ss second

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

#define mset(arr,val) memset(arr,val,sizeof(arr))

ll n;

ll arr[105];

int dp[100005];

bool play(ll k){

	if(dp[k]!=-1) return dp[k];

	bool ans=false;

	ll i;

	fo(i,0,n){

		if(k>=arr[i]){

			bool myans=play(k-arr[i]);

			if(myans==false) ans=true;

		}

	}

	return dp[k]=ans;

}

void solve(ll caseno){

	ll i,j,k;

	cin>>n>>k;

	fo(i,0,n) cin>>arr[i];

	// mset(dp,-1);

	// cout<<(play(k)?"First":"Second")<<endl;

	mset(dp,false);

	fo(i,0,k+1){

		fo(j,0,n){

			if(i>=arr[j]){

				bool myans=dp[i-arr[j]];

				if(myans==false) dp[i]=true;

			}

		}

	}

	cout<<(dp[k]?"First":"Second")<<endl;

}

int main(){

	ios_base::sync_with_stdio(false);

	cin.tie(0);cout.tie(0);

	ll t=1;

	//cin>>t;

	for(ll i=1;i<=t;i++){

		solve(i);

	}

	return 0;

}
// Slower C++ solution:
/*

tarun360

IIT Indore

*/

#include <bits/stdc++.h>

using namespace std;

#define ll long long

#define ll_s long

#define mod 1000000007

#define forn(i,start,lim) for(ll i=start;i<lim;i++)

#define forn_d(i,start,lim) for(ll i=start;i>=lim;i--)

#define forn_s(i,start,lim) for(ll_s i=start;i<lim;i++)

#define forn_d_s(i,start,lim) for(ll_s i=start;i>=lim;i--)

#define f first

#define s second

#define pb push_back

#define mp make_pair

#define debug1(a) cout<<a<<endl

#define debug2(a,b) cout<<a<<" "<<b<<endl

#define debug3(a,b,c) cout<<a<<" "<<b<<" "<<c<<endl

#define debug4(a) cout<<"chu "<<a<<endl



ll a[105],amin=1e18,n;

ll memo[100005][2];



bool f(ll k, bool x){

  if(k<amin)

    return !x;

  if(memo[k][x]==0)

    return 0;

  else if(memo[k][x]==1)

    return 1;

  bool ans;

  if(x==1)

    ans=0;

  else

    ans=1;

  forn(i,0,n){

    if(x==1){

      if(k-a[i]>=0)

        ans=(ans||f(k-a[i],!x));

    }else{

      if(k-a[i]>=0)

        ans=(ans&&f(k-a[i],!x));

    }

  }

  if(ans==0) memo[k][x]=0;

  else memo[k][x]=1;

  return ans;

}



int main()

{

  ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);

  forn(i,0,1e5+5) memo[i][0]=memo[i][1]=-1;

  ll k;

  cin>>n>>k;

  forn(i,0,n) {

    cin>>a[i];

    amin=min(amin,a[i]);

  }

  bool ans=f(k,0);

  if(ans==0) cout<<"First"<<endl;

  else cout<<"Second"<<endl;

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.65412265328063x):
/*

tarun360

IIT Indore

*/

#include <bits/stdc++.h>

using namespace std;

#define ll long long

#define ll_s long

#define mod 1000000007

#define forn(i,start,lim) for(ll i=start;i<lim;i++)

#define forn_d(i,start,lim) for(ll i=start;i>=lim;i--)

#define forn_s(i,start,lim) for(ll_s i=start;i<lim;i++)

#define forn_d_s(i,start,lim) for(ll_s i=start;i>=lim;i--)

#define f first

#define s second

#define pb push_back

#define mp make_pair

#define debug1(a) cout<<a<<endl

#define debug2(a,b) cout<<a<<" "<<b<<endl

#define debug3(a,b,c) cout<<a<<" "<<b<<" "<<c<<endl

#define debug4(a) cout<<"chu "<<a<<endl



ll a[105];

ll dp[100005];



int main()

{

  ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);

  ll n,k;

  cin>>n>>k;

  forn(i,0,n) {

    cin>>a[i];

  }

  forn(i,1,k+1){

    forn(j,0,n){

      if(i-a[j]>=0)

        dp[i]=dp[i]||(1^dp[i-a[j]]);

    }

  }

  if(dp[k])

    cout<<"First";

  else

    cout<<"Second";

  cout<<endl;

  return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

#include<string.h>

using namespace std;

#define li long long int

#define mod 1000000000+7

li n,k;

li a[105];

li dp[100000+5];

void f()

{

    li i,j;

    dp[0]=0;





    for(i=1;i<=k;i++)

    {

        for(j=0;j<n;j++)

        {

            if(i<a[j])

            {

                continue;

            }

            if(dp[i-a[j]]==0)

            {

                dp[i]=1;



            }

        }

    }





}



int main()

{

    cin>>n>>k;



    memset(dp,0,sizeof(dp));

    li i;

    for(i=0;i<n;i++)

    {

        cin>>a[i];

    }



    f();



    if(dp[k])

    {

        cout<<"First";

    }

    else

    {

        cout<<"Second";

    }

    return 0;

}


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

using namespace std;

#define li long long int

#define prDouble(x) cout<<fixed<<setprecision(10)<<x;



int main()

{

    li j,i,n,k;

    cin>>n>>k;

    li a[n];

    for(i=0;i<n;i++)

    {

        cin>>a[i];

    }

    li dp[k+1];

    dp[0]=0;

    sort(a,a+n);

    for(i=1;i<=k;i++)

    {

        dp[i]=0;



        for(j=0;j<n;j++)

        {

            if(!dp[i-a[j]] && (i-a[j])>=0)

            {

                dp[i]=1;

                break;

            }

        }

    }

    if(dp[k])

    {

        cout<<"First";

    }

    else

    {

        cout<<"Second";

    }



    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int n,k,arr[109];

int dp[100009][3];

int bt(int sum,int x){

	int &ret = dp[sum][x];

	if(ret != -1) return ret;

	if(x == 1) ret = 0;

	else ret = 1;

	for(int i=0;i<n&&arr[i]<=sum;i++){

		if(x == 1) ret = max(ret,bt(sum-arr[i],2));

		else ret = min(ret,bt(sum-arr[i],1));

	}

	return ret;

}

int main(){

	memset(dp,-1,sizeof(dp));

	cin>>n>>k;

	for(int i=0;i<n;i++) cin>>arr[i];

	sort(arr,arr+n);

	int ans = bt(k,1);

	if(ans == 0) cout<<"Second"<<endl;

	else cout<<"First"<<endl;

}


// Faster C++ solution for the same problem (measured speedup: 1.5426672655406413x):
#define fast ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)

#include <bits/stdc++.h>

using namespace std;

int n,k;

int a[109];

int dp[100009];

int bt(int sum){

    if(sum < 0) return 1;

    int &ret = dp[sum];

    if(ret != -1) return ret;

    ret = 0;

    for(int i=0;i<n;i++){

        ret = max(ret,1-bt(sum-a[i]));

    }

    return ret;

}

int main(){

    fast,cin>>n>>k;

    memset(dp,-1,sizeof(dp));

    for(int i=0;i<n;i++) cin>>a[i];

    if(bt(k)) cout<<"First"<<endl;

    else cout<<"Second"<<endl;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



vector<int> grundy(100005, -1);



int getMax(set<int> s)

{

	int max = 0;

	while(s.find(max) != s.end())

		max++;

	return max;

}



int getGrundy(int pos, int *a, int n)

{

	if(grundy[pos] != -1)

		return grundy[pos];

	set<int> s;

	for(int i = 0; i < n; i++)

	{

		if(a[i] > pos)

		break;

		int res = getGrundy(pos - a[i], a, n);

		s.insert(res);

	}

	return grundy[pos] = getMax(s);

}



int main() {

	int n, k;

	cin >> n >> k;

	int a[n];

	for(int i = 0; i < n; i++)

		cin >> a[i];

	sort(a, a + n);

	grundy[0] = 0;

	grundy[k] = getGrundy(k, a, n);

	if(grundy[k])

	cout << "First\n";

	else

	cout << "Second\n";

	

	return 0;

}

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

#define int  long long

#define ll long long

#define ld long double

#define mod ((ll)1e9+7)

#define maxx ((ll)1e6+5)

#define pb push_back

#define ins insert

#define usefile freopen("input.txt","r",stdin); freopen("output.txt","w",stdout);

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

#define test ll t; cin>>t; while(t--)

ll exp(ll x,ll y,ll p){ ll res=1; while(y) {if(y%2) res=(res*x%p)%p; x=(x*x)%p; y/=2; } return res;}

ll expo(ll x,ll y){ ll res=1; while(y) {if(y%2) res=(res*x%mod)%mod; x=(x*x)%mod; y/=2; } return res;}

/*int sv[1000000]={0};

ll fact[1000007]={0};

void facto() {fact[0]=1;fact[1]=1;for(int i=2;i<100007;i++)fact[i]=(fact[i-1]*i)%mod;}

void sve() {sv[0]=1;sv[1]=1;for(int i=2;i*i<=maxx;i++){if(!sv[i]){for(int j=2*i;j<=maxx;j+=i)sv[j]=1;}}}//0 hai to prime

ll ncr(ll n,ll r) {ll res=1; res=fact[n]; res=(res*(expo(fact[r],mod-2)))%mod; res=(res*(expo(fact[n-r],mod-2)))%mod; return res;}

ll npr(ll n,ll r) {ll res=1; res=fact[n]; res=(res*(expo(fact[n-r],mod-2)))%mod; return res;}*/

using namespace std;

signed main()

{

    //test

    {

    	int n,k,i,j;

    	cin >> n >> k;

    	int a[n+1];

    	for(i=1 ; i<=n ; i++)

    		cin >> a[i];

    	int s[n+1][k+1],f[k+1]={0};

    	for(i=0 ; i<=n ; i++)

    		for(j=0 ; j<=k ; j++)

    			s[i][j] = 0;

    	for(j=1 ; j<=k ; j++)

    	{

    		for(i=1 ; i<=n; i++)

    		{

    			if(a[i] >  j)

    				s[i][j] = 0;

    			else

    			{

    				s[i][j] = 1-f[j-a[i]];

    			}

    			f[j] = max(f[j] , s[i][j]);

    		}

    	}

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

    	else cout << "Second\n";

    }

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



vector<int> grundy(100005, -1);



int getMax(set<int> s)

{

	int max = 0;

	while(s.find(max) != s.end())

		max++;

	return max;

}



int getGrundy(int pos, int *a, int n)

{

	if(grundy[pos] != -1)

		return grundy[pos];

	set<int> s;

	for(int i = 0; i < n; i++)

	{

		if(a[i] > pos)

		break;

		int res = getGrundy(pos - a[i], a, n);

		s.insert(res);

	}

	return grundy[pos] = getMax(s);

}



int main() {

	int n, k;

	cin >> n >> k;

	int a[n];

	for(int i = 0; i < n; i++)

		cin >> a[i];

	sort(a, a + n);

	grundy[0] = 0;

	grundy[k] = getGrundy(k, a, n);

	if(grundy[k])

	cout << "First\n";

	else

	cout << "Second\n";

	

	return 0;

}

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



using namespace std;



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





int main() {

    ZERO_IQ

    int n,k;

    cin>>n>>k;

    vector<int>v(n);

    for (int i = 0; i < n; ++i) {

        cin>>v[i];

    }

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

    for (int j = 0; j <=k; ++j) {

        for (auto i:v) {

            if(j>=i&&!dp[j-i]){

                dp[j]=true;

            }

        }

    }

    if(dp[k]){

        cout<<"First\n";

    }

    else cout<<"Second\n";

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>



using namespace std;



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

#define allr(v)				((v).rbegin()), ((v).rend())

#define sz(v)				((int)((v).size()))

#define ll long long

#define pb					push_back

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



const ll oo = 1e8;

const double pi = 3.1415926535897;





const double EPS = (1e-7);

int dcmp(double x, double y) {	return fabs(x-y) <= EPS ? 0 : x < y ? -1 : 1;	}





typedef vector<int>                vi;

typedef vector<pair<int,int>>      vii;

typedef vector<ll>                 vll;

typedef vector<double>             vd;

typedef vector< vi >               vvi;

typedef vector< vd >               vvd;

typedef vector<string>             vs;

typedef pair<int, int>             pii;



/**

    * PLEASEEE READDD PROBLEEEM CARFULLY ****

    * Always check for OVERFLOW ll vs int

    * Always check for array bounds

    * Check for function return

    * READ OUTPUT SECTION AGAIN!!!

**/



struct edge{

    int from, to, w;



    edge(){}

    edge(int x, int y, int we): from(x), to(y), w(we){}



    bool operator < (const edge &rhs) const{

        return w > rhs.w;

    }



};



const int N = 100 + 5, K = 1e5 + 5;



int dp[K][3];

int a[N];

int n, ans = 0;



int sol(int k, int turn) {

    int f = 1;



    int &ret = dp[k][turn];

    if(ret != -1) return ret;



    ret = !turn;

    for(int i = 0; i < n; i++) {

        if(k - a[i] >= 0) {

            int ch = sol(k - a[i], turn ^ 1);

            if(turn) ret = max(ret, ch);

            else ret = min(ret, ch);

            f = 0;

        }

        else break;

    }



    if(f) {

        if(turn == 0) return 1;

        return 0;

    }



    return ret;

}



int main(){

//    fIO



//    freopen("", "r", stdin);

//    freopen("", "w", stdout);



    memset(dp, -1, sizeof(dp));

    int k;

    cin >> n >> k;



    for(int i = 0; i < n; i++) cin >> a[i];



    cout << (sol(k, 1) == 1 ? "First" : "Second") << "\n";

}














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



using namespace std;



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





int main() {

    ZERO_IQ

    int n,k;

    cin>>n>>k;

    vector<int>v(n);

    for (int i = 0; i < n; ++i) {

        cin>>v[i];

    }

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

    for (int j = 0; j <=k; ++j) {

        for (auto i:v) {

            if(j>=i&&!dp[j-i]){

                dp[j]=true;

            }

        }

    }

    if(dp[k]){

        cout<<"First\n";

    }

    else cout<<"Second\n";

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



vector<int> grundy(100005, -1);



int getMax(set<int> s)

{

	int max = 0;

	while(s.find(max) != s.end())

		max++;

	return max;

}



int getGrundy(int pos, int *a, int n)

{

	if(grundy[pos] != -1)

		return grundy[pos];

	set<int> s;

	for(int i = 0; i < n; i++)

	{

		if(a[i] > pos)

		break;

		int res = getGrundy(pos - a[i], a, n);

		s.insert(res);

	}

	return grundy[pos] = getMax(s);

}



int main() {

	int n, k;

	cin >> n >> k;

	int a[n];

	for(int i = 0; i < n; i++)

		cin >> a[i];

	sort(a, a + n);

	grundy[0] = 0;

	grundy[k] = getGrundy(k, a, n);

	if(grundy[k])

	cout << "First\n";

	else

	cout << "Second\n";

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.4921293809175895x):
#include <iostream>

#include <set>

#include <string>

#include <algorithm>

#define ll long long

#define mod 998244353



using namespace std;



int n, k, arr[110], dp[100005];



string solve()

{

	for (int i = 1; i <= k; i++)

		for (int j = 0; j < n; j++)

			if (i >= arr[j] && !dp[i - arr[j]])

				dp[i] = 1;

	if (dp[k] == 1)return "First";

	return "Second";

}



int main()

{

	cin >> n >> k;

	for (int i = 0; i < n; i++)

		cin >> arr[i];

	cout << solve() << '\n';

	return 0;

}