stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include <iostream>

#include <cstdio>

#include <cstring>

using namespace std;



const int MaxN = 100 + 5, MaxK = 100000 + 5;



int N, K;

int A[MaxN];

bool dp[MaxK];



void init() {

  scanf("%d %d", &N, &K);

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

    scanf("%d", &A[i]);

}



void solve() {

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

    for (int j = 1; j <= N; ++j)

      if (i - A[j] >= 0) if (dp[i - A[j]] == false) dp[i] = true;

  }



  if (dp[K] == true) puts("First");

  else puts("Second");

}



int main() {

  init();

  solve();

  return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>



const int MaxN = 100 + 5, MaxK = 100000 + 5;



int N, K;

int A[MaxN];

bool Dp[MaxK];



void init() {

  scanf("%d %d", &N, &K);

  for (int i = 1; i <= N; ++i) scanf("%d", &A[i]);

}



void solve() {

  Dp[0] = false;

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

    Dp[i] = false;

    for (int j = 1; j <= N; ++j)

      if (i >= A[j] && Dp[i - A[j]] == false)

        Dp[i] = true;

  }

  puts(Dp[K] == true ? "First" : "Second");

}



int main() {

  init();

  solve();

  return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include<bits/stdc++.h>

#define MAX 100005

using namespace std;



int dp[MAX][2];



bool playgame(int currentplayer,int n,int k,int steps[])

{

 

  if(dp[k][currentplayer]!=-1 )  

  {

      return  (dp[k][currentplayer]==0? false:true);

  }

    

    

  int nextplayer = (currentplayer==0 ? 1 : 0);

  

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

  {

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

      {

          bool cannextplayerwin=playgame(nextplayer,n,k-steps[i],steps);

          

          if(cannextplayerwin==false)

          

          {

              dp[k][currentplayer]=true;

              return true;

          }

          

      }

     

  }

  dp[k][currentplayer]=0;

  return false;

  

    

}





void findit(int n,int k,int steps[])

{

    //1 denotes Taro

    //2 denotes Jiro

    

    //map<pair<int,int>,int> v;

    

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

    {

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

        {

         dp[i][j]=-1;   

        }

    }

    int answer=playgame(0,n,k,steps);

    

    if(answer)

    {

        cout<<"First";

    }

    

    else cout<<"Second";

    

  

}





int main()

{



    int n;

    cin>>n;

    

    int k;

    cin>>k;

    

    int steps[n];

    

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

    {

        cin>>steps[i];

    }

    

    findit(n,k,steps);



	return 0;

}


// Optimized solution to the same problem (faster):
#include <iostream>

#include<bits/stdc++.h>

#define MAX 100005

using namespace std;



bool dp[MAX];



bool playgame(int currentplayer,int n,int k,int steps[])

{

   

   for(int i=0;i<steps[0];i++)

   {

       dp[i]=false;

   }

   

   for(int i=steps[0];i<=k;i++)

    

    {

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

        {

           

            

            if(i-steps[j]>=0 && dp[i-steps[j]]==false)

            {

                dp[i]=true;

                break;

            }

        }

    

    }

   



  

   return dp[k]; 

}





void findit(int n,int k,int steps[])

{

    //1 denotes Taro

    //2 denotes Jiro

    

    //map<pair<int,int>,int> v;

    

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

    {

        

         dp[i]=false;   

        

    }

    

    int answer=playgame(0,n,k,steps);

    

    if(answer)

    {

        cout<<"First";

    }

    

    else cout<<"Second";

    

  

}





int main()

{



    int n;

    cin>>n;

    

    int k;

    cin>>k;

    

    int steps[n];

    

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

    {

        cin>>steps[i];

    }

    

    findit(n,k,steps);



	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include<bits/stdc++.h>

#define MAX 100005

using namespace std;



int dp[MAX];



bool playgame(int currentplayer,int n,int k,int steps[])

{

 

  if(dp[k]!=-1 )  

  {

      return  (dp[k]==0? false:true);

  }

    

    

  int nextplayer = (currentplayer==0 ? 1 : 0);

  

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

  {

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

      {

          bool cannextplayerwin=playgame(nextplayer,n,k-steps[i],steps);

          

          if(cannextplayerwin==false)

          

          {

              dp[k]=true;

              return true;

          }

          

      }

     

  }

  dp[k]=0;

  return false;

  

    

}





void findit(int n,int k,int steps[])

{

    //1 denotes Taro

    //2 denotes Jiro

    

    //map<pair<int,int>,int> v;

    

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

    {

        

         dp[i]=-1;   

        

    }

    int answer=playgame(0,n,k,steps);

    

    if(answer)

    {

        cout<<"First";

    }

    

    else cout<<"Second";

    

  

}





int main()

{



    int n;

    cin>>n;

    

    int k;

    cin>>k;

    

    int steps[n];

    

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

    {

        cin>>steps[i];

    }

    

    findit(n,k,steps);



	return 0;

}


// Optimized solution to the same problem (faster):
#include <iostream>

#include<bits/stdc++.h>

#define MAX 100005

using namespace std;



bool dp[MAX];



bool playgame(int currentplayer,int n,int k,int steps[])

{

   

   for(int i=0;i<steps[0];i++)

   {

       dp[i]=false;

   }

   

   for(int i=steps[0];i<=k;i++)

    

    {

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

        {

           

            

            if(i-steps[j]>=0 && dp[i-steps[j]]==false)

            {

                dp[i]=true;

                break;

            }

        }

    

    }

   



  

   return dp[k]; 

}





void findit(int n,int k,int steps[])

{

    //1 denotes Taro

    //2 denotes Jiro

    

    //map<pair<int,int>,int> v;

    

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

    {

        

         dp[i]=false;   

        

    }

    

    int answer=playgame(0,n,k,steps);

    

    if(answer)

    {

        cout<<"First";

    }

    

    else cout<<"Second";

    

  

}





int main()

{



    int n;

    cin>>n;

    

    int k;

    cin>>k;

    

    int steps[n];

    

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

    {

        cin>>steps[i];

    }

    

    findit(n,k,steps);



	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



#define int long long



int n, k;



vector<int> v(109);



int memo[100009][2];



int dp(int left, int pl){

    if(left == 0){

        return 0;

    }

    if(memo[left][pl] != -1) return memo[left][pl];

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

        if(left - v[i] >= 0){

            if(!dp(left-v[i], !pl)){

                return memo[left][pl] = 1;

            }

        }

    }

    return memo[left][pl] = 0;

}



signed main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cin >> n >> k;

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

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

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

            memo[i][j] = -1;

        }

    }

    if(dp(k,1) == 1){

        cout << "First" << endl;

    }else cout << "Second" << endl;

}


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;



#define int long long



int n, k;



vector<int> v(109);



bool memo[100009][2];



signed main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cin >> n >> k;

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

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

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

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

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

                    if(!memo[i-v[k]][!j]){

                        memo[i][j] = true;

                        break;

                    }

                }

            }

        }

    }

    if(memo[k][1]) cout << "First" << endl;

    else cout << "Second" << endl;

}




// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

ll a[100005];

ll dp[100005];

ll n;

ll solve(ll k){

	if(dp[k])

		return dp[k];

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

		if(k>=a[i]){

			if(solve(k-a[i])==2){

				dp[k]=1;

				return dp[k];

			}

			

		}

	}

	dp[k]=2;

	return dp[k];

}

int main(){

	ll k;

	cin>>n>>k;

	

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

		cin>>a[i];

	}

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

	dp[0]=2;

	(solve(k)==2)?cout<<"Second":cout<<"First";

	cout<<endl;

	

	

	return 0;

	

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

#define ll long long

using namespace std;

int dp[100005];

int n;

int a[100005];

int cal(int k){

    if(dp[k]!=-1)

        return dp[k];



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

        if(a[i]<=k){

            if(cal(k-a[i])==2) {

                dp[k] = 1;

                return dp[k];

            }

        }



    }

    dp[k]=2;

    return dp[k];

}

void solve(){

    int k;

    cin>>n>>k;



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

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

        cin>>a[i];

    }

    dp[0]=2;

    dp[k]=cal(k);

    if(dp[k]==1)

        cout<<"First"<<endl;

    else cout<<"Second"<<endl;



}

int main(){



    solve();

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
/**************************************************************************

Coded by: Saba Karimi(_VINTAGE)

Institution: AIT PUNE

***************************************************************************/

#include<bits/stdc++.h>

using namespace std;

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

#define pb push_back 

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

#define lb lower_bound

#define ub upper_bound

#define pii pair<int,int>

#define ld long double

#define int long long int 

#define F first 

#define S second

/**************************************************************************/

const int N = 1e5+2;

int n,k;

int a[101];

int dp[N];

int solve(int rem)

{

    if(dp[rem]!=-1)

        return dp[rem];

    int res = 0;

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

    {

        if(rem-a[i]<0)

            break;

        res = res|(solve(rem-a[i])==0);

    }

    dp[rem] = res;

    return res;

}

signed main()

{

    fast;

    cin>>n>>k;

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

        cin>>a[i];

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

    int res = solve(k);

    if(res)

        cout<<"First";

    else cout<<"Second";

}

// Optimized solution to the same problem (faster):
/**************************************************************************

Coded by: Saba Karimi(_VINTAGE)

Institution: AIT PUNE

***************************************************************************/

#include<bits/stdc++.h>

using namespace std;

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

#define pb push_back 

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

#define lb lower_bound

#define ub upper_bound

#define pii pair<int,int>

#define ld long double

#define int long long int 

#define F first 

#define S second

/**************************************************************************/

const int N = 1e5+2;

bool dp[N];

signed main()

{

    fast;

    int n,k;

    cin>>n>>k;

    int a[n+1];

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

        cin>>a[i];

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

    {

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

        {

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

                dp[stones] = true;

        }

    }

    if(dp[k])

        cout<<"First";

    else cout<<"Second";

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
/*

* @Author: _dp95

* @Date:   2019-12-10 11:15:26

*/

#include "bits/stdc++.h"

using namespace std ;

 

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

 

typedef long long ll ;

typedef long double ldb ;

 

#define mp make_pair

#define pb push_back

#define F first

#define S second

#define nl '\n'

 

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

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

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

#define deci( x ) cout<<fixed<<setprecision( x );

#define bitcount( x ) __builtin_popcountll( x )

 

const int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};

const int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};

 

const int MAX = 2*1000*100 + 10 ;

const ll INF = 1e18 ;

const int MOD = 1e9 + 7 ;

 

int n, m, s[MAX], dp[ MAX ][ 2 ] ;

 

int sol( int val, int flag ){

  if( val < 0 )

    return flag == 0 ;

  if( val == 0 )

    return flag == 1 ;

  if( dp[val][flag] != -1 )

    return dp[val][flag] ;

  int f = 0 ;

  if(flag){

    f = 1 ;

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

      f &= sol(val-s[i],flag^1);

    }

  }

  else{

    f = 0 ;

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

      f |= sol(val-s[i],flag^1);

    }

  }

  return dp[val][flag] = f ;

}

 

void sol( ){

  cin >> n >> m ;

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

    cin >> s[i] ;

  mem(dp,-1);

  if(sol(m,0))

    cout << "First" << nl ;

  else

    cout << "Second" << nl ;

}

 

int main( ){

  timesaver ;

  int t(1);

  while( t-- )

    sol();

}

// Optimized solution to the same problem (faster):
/*

* @Author: _dp95

* @Date:   2019-12-10 11:48:03

*/

#include "bits/stdc++.h"

using namespace std ;



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



typedef long long ll ;

typedef long double ldb ;



#define mp make_pair

#define pb push_back

#define F first

#define S second

#define nl '\n'



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

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

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

#define deci( x ) cout<<fixed<<setprecision( x );

#define bitcount( x ) __builtin_popcountll( x )



const int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};

const int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};



const int MAX = 2*1000*1000 + 10 ;

const ll INF = 1e18 ;

const int MOD = 1e9 + 7 ;



int n, m, s[ MAX ], dp[ MAX ] ;



int main( ){

  timesaver ;

  cin >> n >> m ;

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

    cin >> s[i] ;

  }

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

    if(dp[i])

      continue ;

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

      dp[i+s[j]] |= 1 ;

  }

  if(dp[m])

    cout << "First" << nl ;

  else

    cout << "Second" << nl ;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;



#define int long long

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

const int N = 300, K = 123456;

int dp[K], a[N];

int n;

bool solve(int k){

    if(k == 0){

        return 0;

    }

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

        return dp[k];

    }

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

        if(k >= a[i]){

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

                return dp[k] = 1;

            }

        }

    }

    return dp[k] = 0;

}

signed main(){

    ios::sync_with_stdio(false);

    int k;

    cin >> n >> k;

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

        cin >> a[i];

    }

    fill(dp, dp + K, -1);

    cout << (solve(k) ? "First\n" : "Second\n");

}

// Optimized solution to the same problem (faster):
//In The Name Of Allah

#include<bits/stdc++.h>

using namespace std;

#define int long long

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

#define double long double 

#define x real()

#define y imag()

#define fi first

#define se second

#define pii pair<int, int>



const int K = 2e5 + 10;

bool dp[K];

signed main() {

    ios::sync_with_stdio(false); cin.tie(nullptr);

	int n, k;

	cin >> n >> k;

	int a[n];

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

		cin >> a[i];

	}

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

		if (!dp[i]) {

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

				dp[i + a[j]] = true;

			}

		}

	}

	if (dp[k]) {

		cout << "First\n";

	} else {

		cout << "Second\n";

	}

}




// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<cstdio>

#include<cstdlib>

#include<algorithm>

#include<iostream>

#include<queue>

#include<vector>

#include <bitset>

#include <cmath>

#include <limits>

#include <iostream>

#include<stack>

#include<tuple>

using namespace std;

#define INF 1100000000000

#define MaX 100000

#define MOD 1000000007

typedef long long ll;

typedef pair<int,int> P;

typedef pair<pair<int,int>,int> p;

typedef pair< pair<int,int>, int> p; 

#define bit(n,k) ((n>>k)&1) /*nのk bit目*/

#define rad_to_deg(rad) (((rad)/2/M_PI)*360)



//https://kyopro-friends.hatenablog.com/entry/2019/01/12/231000



bool dp[110000];



int main(){

    int N,a[110],K; cin>>N>>K;

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

    for(int i=0;i<110000;i++) dp[i]=false;

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

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

            if(i-a[j]>=0 && dp[i-a[j]]==false) dp[i]=true;

        }

    }

    if(dp[K]) cout<<"First"<<endl;

    else cout<<"Second"<<endl;

}




// Optimized solution to the same problem (faster):
#pragma GCC optimize("Ofast")

#include<cstdio>

#include<cstdlib>

#include<algorithm>

#include<iostream>

#include<queue>

#include<vector>

#include <bitset>

#include <cmath>

#include <limits>

#include <iostream>

#include <map>

#include<tuple>

using namespace std;

#define INF 1LL<<62

#define MAX 100000

#define MOD 1000000007

typedef long long ll;

typedef pair<int,int> P;

//typedef pair<pair<int,int>,int> p;

#define bit(n,k) ((n>>k)&1) /*nのk bit目*/

#define rad_to_deg(rad) (((rad)/2/M_PI)*360)

struct edge{ll to,cost,val;};

template<class T,class U>bool chmin(T&a,const U&b){if(a<=b)return false;a=b;return true;}

template<class T,class U>bool chmax(T&a,const U&b){if(a>=b)return false;a=b;return true;}

//__builtin_popcount(S);

//C.erase(unique(C.begin(),C.end()),C.end());



bool dp[110000];



int main(){

    int N,K;

    cin>>N>>K;

    vector<int> a(N);

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

    dp[0]=false;

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

        bool flag=false;

        for(auto j:a){

            if(i-j<0) continue;

            if(dp[i-j]==false) flag=true;

        }

        if(flag) dp[i]=true;

    }

    if(dp[K]) cout<<"First"<<endl;

    else cout<<"Second"<<endl;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem: