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



#define Fast cin.tie(0), ios::sync_with_stdio(0)

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

#define louisfghbvc int t; cin >> t; while(t--)

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

using namespace std;

typedef long long LL;

typedef pair<LL, LL> ii;

typedef vector<LL> vi;



template<typename T> ostream& operator<<(ostream &os, const vector<T> &v) { os << '{'; string sep = ""; for(const auto &x : v) os << sep << x, sep = ", "; return os << '}'; }

template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << '(' << p.first << ", " << p.second << ')'; }



void dbg_out() { cerr << "\n"; }

template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }



const int K = 1e5+5;

int arr[105];

int dp[K];

int n, k;



int dfs(int remain){

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

    bool res = 0;

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

        if(remain >= arr[i]) res |= (dfs(remain-arr[i]) == 0);

    }

    return dp[remain] = res;

}



void solve(){

    cin >> n >> k;

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

    memset(dp, -1, sizeof dp);



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

}



int main()

{

    Fast;

    //louisfghbvc{

        solve();

    //}

    return 0;

}


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

using namespace std;

const int maxk = 1e5+5;

const int maxn = 100+5;

int A[maxn];

bool dp[maxk];

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

{

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

	memset(dp, false, sizeof dp);

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

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

		dp[A[i]] = true;

	}



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

		if(!dp[i]){

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

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

					dp[i] = true;

					break;

				}

			}

		}

	}



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

	else printf("Second\n");

	return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 4.946370149657397x):
#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;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 1.285686702706122x):
#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;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 1.7074242731945735x):
#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;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 1.4102762040658898x):
#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;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 2.6187227574211835x):
#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;

}
// Slower C++ solution:
#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;

	

}

// Faster C++ solution for the same problem (measured speedup: 1.2732783175403906x):
#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();

}
// Slower C++ solution:
/**************************************************************************

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";

}

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

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";

}
// Slower C++ solution:
/*

* @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();

}

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

* @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 ;

}
// Slower C++ solution:
#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");

}

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

using namespace std;

#define int long long

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

#define fi first

#define se second

#define pii pair<int, int>



const int N = 110, K = 100100;

int a[N], dp[K] = {0};

signed main() {

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

    int n, k;

    cin >> n >> k;

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

        cin >> a[i];

    }

    for (int x = a[1]; x <= k; x++) {

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

            if (a[i] > x) {

                break;

            }

            if (dp[x - a[i]] == 0) {

                dp[x] = 1;

                break;

            }

        }

    }

    if (dp[k]) {

        cout << "First\n";

    }  else {

        cout << "Second\n";

    }

}
// Slower C++ solution:
#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");

}

// Faster C++ solution for the same problem (measured speedup: 2.063963080260013x):
//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";

	}

}
// Slower C++ solution:
#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;

}




// Faster C++ solution for the same problem (measured speedup: 1.0936529601171272x):
#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;

}