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

#include <algorithm>

#include <vector>

#include <set>

#include <cmath>

#include <deque>

#include <iterator>

#include <map>

#include <queue>

#include <string>

#include <tuple>

#include <utility>

#include <limits>

#include <iomanip>

using namespace std;



using ll=long long;

template<class T> using V = vector<T>;

template<class T, class U> using P = pair<T, U>;

using vll = V<ll>;

using vvll = V<vll>;

#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)

#define REP(i, n) rep(i, 0, n)

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

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



int main() {

  ll n, k; cin >> n >> k;

  vll a(n); REP(i, n) cin >> a.at(i);

  vll dp(100005, 0);

  rep(i, 1, k+1) {

    rep(j, 0, n) {

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

    }

  }

  if (dp.at(k) == 1) cout << "First" << endl;

  else cout << "Second" << endl;

  return 0;

}


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

#include <array>

#include <algorithm>

#include <vector>

#include <bitset>

#include <set>

#include <unordered_set>

#include <cmath>

#include <complex>

#include <deque>

#include <iterator>

#include <numeric>

#include <map>

#include <unordered_map>

#include <queue>

#include <stack>

#include <string>

#include <tuple>

#include <utility>

#include <limits>

#include <iomanip>

#include <functional>

#include <cassert>

using namespace std;



using ll=long long;

template<class T> using V = vector<T>;

template<class T, class U> using P = pair<T, U>;

using vll = V<ll>;

using vvll = V<vll>;

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

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

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

#define DEBUG_VLL(vec) for(int sz=0;sz<int(vec.size());sz++) std::cerr<<vec[sz]<<(sz==vec.size()-1?'\n':' ');



const long long MOD = 1000000007;

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

const int INF = (int)1e9;



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);

    int n, k; cin >> n >> k;

    V<int> a(n);

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

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

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

        if (dp[i]) continue;

        for (auto &ta: a) {

            if (i + ta > k) continue;

            dp[i + ta] = true;

        }

    }

    

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

    else cout << "Second\n";

    return 0;

}


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

using namespace std;

#define ll long long 

#define pb push_back 

const int mod=1e9+7;\

int dp[100005];

 int solve(int b[],int k,int n){

          if(k<0)

          return 1;

          

          if(k==0)

          return dp[k]=0;

         if(dp[k]!=-1)

          return dp[k];  

          

        int sum=1;

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

		 int t=solve(b,k-b[i],n);

		   sum=sum && t;

		}

		if(sum)

		return  dp[k]=0;

		return dp[k]=1;

        

}

int main(){

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

       int n,k;

         cin>>n>>k;

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

        int b[n];

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

          cin>>b[i]; 

           

           if(solve(b,k,n))

             cout<<"First\n";

          else

             cout<<"Second\n";

             

    }


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

using namespace std;

#define ll long long 

#define pb push_back 

const int mod=1e9+7;

 /*int solve(int b[],int k,int n){

          if(k<0)

          return 1;

          

          if(k==0)

          return dp[k]=0;

         if(dp[k]!=-1)

          return dp[k];  

          

        int sum=1;

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

		 int t=solve(b,k-b[i],n);

		   sum=sum && t;

		}

		if(sum)

		return  dp[k]=0;

		return dp[k]=1;

        

}*/

int main(){

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

       int n,k;

         cin>>n>>k;

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

        int b[n];

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

          cin>>b[i]; 

           

            vector<int>dp(k+1);

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

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

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

				    dp[i]=1;

				 }

			}

           if(dp[k])

             cout<<"First\n";

          else

             cout<<"Second\n";

             

    }


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

using namespace std;



int N, K, a[110];

bool dp[100100], cek[100100];



bool f(int k) {

	if (k==0) return 0;

	if (cek[k]) return dp[k];

	dp[k] = 0;

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

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

			dp[k] |= !f(k - a[i]);

		}

	}

	cek[k] = 1;

	return dp[k];

}



int main () {

	cin >> N >> K;

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

		cin >> a[i];

	memset(cek, 0, sizeof(cek));

	if (f(K))

		cout << "First" << endl;

	else

		cout << "Second" << endl;

}

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

#include <iostream>



using namespace std;



const int MAXN = 110;

const int MAXK = 100010;



int n, k, a[MAXN];

bool sg[MAXK];



int main()

{

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

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

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

	sg[0] = 0;

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

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

			if(i >= a[j]) sg[i] |= !sg[i-a[j]];

		}

	}

	if(sg[k]) puts("First");

	else puts("Second");

	return 0;

}

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

using namespace std;



int const N=1e2+5, M=1e5+5, OO = 0x3f3f3f3f;





int n,k;

int arr[N];

int mem[M][2];

int solve(int rem, bool last)

{

    if(rem<0)

        return !last;

    if(mem[rem][last]!=-1)

        return mem[rem][last];

    int ret;

    bool f;

    if(last)

    {

        ret=0;

        f=0;

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

        {

            if(rem-arr[i]>=0)

            {

                ret=max(ret,solve(rem-arr[i],0));

                f=1;

            }

            else

                break;

        }

        if(!f)

            ret=0;

    }

    else

    {

        f=0;

        ret=1;

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

        {

            if(rem-arr[i]>=0)

            {

                ret=min(ret,solve(rem-arr[i],1));

                f=1;

            }

            else

                break;

        }

        if(!f)

            ret=1;

    }

    return mem[rem][last]=ret;

}





int main()

{

//    freopen("input.txt","rt",stdin);

//    freopen("output.txt","wt",stdout);

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

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

        scanf("%d",arr+i);

    memset(mem, -1, sizeof mem);

    if(solve(k,1))

        puts("First");

    else

        puts("Second");



}


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

#include <bits/stdc++.h>

using namespace std;



// VJUDGE



const int N = 100 * 1001, M = 110;

int n, a[N], k;

bool dp[N];



int main() {

	cin >> n >> k;

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

		cin >> a[i];

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

		bool win = false;

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

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

				win = true;

		}

		if (win)

			dp[i] = true;

	}

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

}


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

using namespace std;



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

#define fp(i,a,b) for(int i=a ; i<b ; i++)

#define fn(i,a,b) for(int i=a ; i>=b ; i--)

#define pb push_back

#define mk make_pair

#define ff first

#define ss second

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



typedef long long ll;

typedef pair<int,int> ii;

typedef vector<ii> vii;

typedef vector<int> vi;

typedef vector<ll> vll;



const int M=1e5+5;

const ll INF=1e15;

const int MOD=1e9+7;



int n,k;

int dp[M],val[105];



int DP(int x){

	if (x < 0) return 1;

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

	dp[x] = 1;

	fp(i,0,n) dp[x] = dp[x]&DP(x-val[i]);

	dp[x] = dp[x]^1;

	return dp[x];

}



int main(){



	fastio;

	cin >> n >> k;

	fp(i,0,M) dp[i] = -1;

	fp(i,0,n) cin >> val[i];

	if (DP(k) == 1) cout << "First\n";

	else cout << "Second\n";



	return 0;

}


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

using namespace std;

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



const int MAXN = 100 + 5;

const int MAXK = 1e5 + 5;



int n, k, a[MAXN];

bool dp[MAXK];



int main() {

    IOS

    

    cin >> n >> k;

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

        cin >> a[i];

        dp[a[i]] = 1;

    }

    sort(a, a + n);

    

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

        if (!dp[i]) {

            for (int j = 0; j < n && i + a[j] <= k; j++) {

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

            }

        }

    }



    if (dp[k]) {

        cout << "First\n";

    } else {

        cout << "Second\n";

    }

}

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

#include<algorithm>

#include<climits>

#include<vector>

#include<utility>//pair

#include<cmath>//abs,sqrt

#include<cstring>

#include<map>

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

#define rep1(i,n) for(int i=1;i<=n;i++)

#define prin(arg) cout<<arg<<"\n"

#define prin2(arg1,arg2) cout<<arg1<<" "<<arg2<<"\n"

#define fill(arg,n) memset(arg,n,sizeof(arg))

using namespace std;

typedef long long ll;

typedef pair<int,int> pi;

const int INF=1e+9;

const ll INFLL=1e+17;

int main(){

  int n,k;

  cin>>n>>k;

  int a[110];

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

  int dp[100010];

  fill(dp,0);

  rep1(i,k){

    bool f=false;

    rep(j,n){

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

	if(!dp[i-a[j]]){

	  f=true;

	}

      }

    }

    if(f) dp[i]=1;

    else dp[i]=0;

  }

  if(dp[k]) prin("First");

  else prin("Second");

    

	



  return 0;

}


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

#include <algorithm>

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

#define rep1(i,n) for(int i = 1 ; i <= n ; ++i)

using namespace std;

int n,k;

int a[110];

bool dp[100010];

int main()

{

  cin >> n >> k;

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

  

  dp[0] = false;



  rep1(i,k){

    bool f = false;

    rep(j,n){

      if( i-a[j] < 0) break;

      else if( !dp[i-a[j]] ){

	f = true;

	break;

      }

    }

    dp[i] = f;

  }



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

  

  return 0;

}


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

using namespace std;

#define ll long long

int n , k , a[100]; short dp[200001][2];

bool f( bool p = 0 , int k = k )

{

    if( k == 0 )

        return 0;

    if( k < 0 )

        return 1;

    short &d = dp[k][p];

    if( d != -1 )

        return d;

    bool mn = 1;

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

        mn = min( mn , f( !p , k-a[i] ) );

    return d = !mn;

}

int main()

{

    memset(dp,-1,sizeof dp);

    cin >> n >> k;

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

        cin >> a[i];

    cout <<( f() == 1 ? "First" : "Second" );

    

    return 0;

}


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

using namespace std;

#define ll long long

#define f(i, x, n) for (int i = x; i < (int)(n); ++i)

const int N = 1e5, M = 7 + 1e9;

int n, k, a[100], dp[N+1];

int main()

{

	cin >> n >> k;

	f(i, 0, n)

		cin >> a[i];

	f(i, 0, a[0])

		dp[i] = 0;

	f(i, a[0], k+1){

		dp[i];

		f(j, 0, n)

			if(i >= a[j])

				dp[i] |= !dp[i-a[j]];

	}

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



}

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

using namespace std;

typedef long long ll;

const int N = 1e5+1;

int n, k, a[100], dp[N];

bool f(int cnt)

{

	if( cnt == 0 ){

		return 0;

	}

	int &dp = ::dp[cnt];

	if( dp != -1 )

		return dp;

	dp = 0;

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

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

			dp |= !f(cnt - a[i]);

	}

	return dp;

}

int main()

{

	memset(dp, -1, sizeof dp);

	cin >> n >> k;

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

		cin >> a[i];

	bool yes = f(k);

	cout << ( yes ? "First" : "Second" );

}

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

using namespace std;

#define ll long long

#define f(i, x, n) for (int i = x; i < (int)(n); ++i)

const int N = 1e5, M = 7 + 1e9;

int n, k, a[100], dp[N+1];

int main()

{

	cin >> n >> k;

	f(i, 0, n)

		cin >> a[i];

	f(i, 0, a[0])

		dp[i] = 0;

	f(i, a[0], k+1){

		dp[i];

		f(j, 0, n)

			if(i >= a[j])

				dp[i] |= !dp[i-a[j]];

	}

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



}

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

using namespace std;

#define ll long long

#define f(i, x, n) for (int i = x; i < (int)(n); ++i)

const int N = 1e5, M = 7 + 1e9;

int n, k, a[100], dp[N+1][2];

bool cal(int sum, bool player){

	if(sum < a[0])

		return 0;

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

	if(~ret)

		return ret;

	ret = 0;

	f(i, 0, n)

		if(sum >= a[i])

			ret |= !cal(sum-a[i], !player);

	return ret;

}

int main()

{

	memset(dp, -1, sizeof dp);

	cin >> n >> k;

	f(i, 0, n)

		cin >> a[i];

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



}

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

using namespace std;

#define ll long long

#define f(i, x, n) for (int i = x; i < (int)(n); ++i)

const int N = 1e5, M = 7 + 1e9;

int n, k, a[100], dp[N+1];

int main()

{

	cin >> n >> k;

	f(i, 0, n)

		cin >> a[i];

	f(i, 0, a[0])

		dp[i] = 0;

	f(i, a[0], k+1){

		dp[i];

		f(j, 0, n)

			if(i >= a[j])

				dp[i] |= !dp[i-a[j]];

	}

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



}

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

using namespace std;;

int dp[100002];

bool solve(int k,int a[],int n){

    if(k==0)

        return 0;

        if(dp[k]!=-1)

        return dp[k];

        int ans =0 ;

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

        {

            if(k >= a[i] && solve(k - a[i] ,a ,n) == 0){

                

            ans =1;

                break;

            }

        }

        dp[k]=ans ;

        return dp[k];

}

int main(){

    int n , k;



    cin >> n >> k;

    int a[n];

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

        cin >> a[i];

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

  if(solve(k,a,n))

  cout<<"First";

  else

  cout<<"Second";

    

}

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

using namespace std;

;

int main()

{

    int n, k;

    cin >> n >> k;

    int a[n];

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

        cin >> a[i];

    bool dp[k + 1];

    memset(dp, false, sizeof(dp));

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

    {

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

        {

            if (i >= a[j])

            {

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

                {

                    dp[i] = true;

                }

            }

        }

    }

    if(dp[k]) 

     cout << "First" ;

    else 

    cout << "Second";

}

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

#define ll long long int

#define ld long double

#define pb push_back

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

#define ff first

#define ss second

#define mod 1000000007

using namespace std;



int dp[100002];

int n;

vector<int> a;



int fun(int k){

	if(dp[k]!=-1)

		return dp[k];

	int mx = 0;

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

		if(k-a[i]<0)

			continue;

		mx = max(mx,(1+fun(k-a[i]))%2);

	}

	return dp[k]=mx;

}



int main(){

	ios_base::sync_with_stdio(false); 

	cin.tie(NULL);cout.tie(NULL);

	int k;

	cin>>n>>k;

	a.resize(n);

	memset(dp,-1,sizeof dp);

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

	{

		cin>>a[i];

	}

	if(fun(k))

		cout<<"First";

	else

		cout<<"Second";

	// cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;

	return 0;

}

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

#define ll long long int

#define ld long double

#define pb push_back

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

#define ff first

#define ss second

#define mod 1000000007

using namespace std;



int main(){

	ios_base::sync_with_stdio(false); 

	cin.tie(NULL);cout.tie(NULL);

	int n,k;

	cin>>n>>k;

	vector<int>a(n),dp(k+1,0);

	

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

	{

		cin>>a[i];

	}

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

		for(auto j: a){

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

				dp[i] = 1;

		}

	}

	if(dp[k])

		cout<<"First";

	else

		cout<<"Second";

	// cerr<< '\n' << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n" ;

	return 0;

}

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

#include <vector>

#include <algorithm>

#include <cmath>

#include <queue>

#include <string>

#include <map>

#include <set>

#include <stack>

#include <tuple>

#include <deque>

#include <numeric>

#include <bitset>

#include <iomanip>

#include <cassert>

#include <chrono>

#include <random>

#include <limits>

#include <iterator>

#include <functional>

#include <sstream>

#include <complex>

using namespace std;



typedef long long ll;

typedef uint64_t ull;

typedef pair<int, int> P;

constexpr double PI = 3.1415926535897932;   // acos(-1)

constexpr double EPS = 1e-9;

constexpr int INF = 1001001001;

constexpr int mod = 1000000007;

// constexpr int mod = 998244353;



#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)



int n, k;

vector<int> a;

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



int memo_rec(int rest = k){

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

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



    int is_win = 1;

    bool is_possible = false;

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

        if(a[i] > rest) continue;

        is_possible = true;

        is_win &= memo_rec(rest - a[i]);

    }

    cerr << is_win << endl;

    if(!is_possible)    return dp[rest] = 0;

    return dp[rest] = is_win ^ 1;

}



int main(){

    ios::sync_with_stdio(false);

    cin.tie(nullptr);



    cin >> n >> k;

    a.resize(n);

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



    if(memo_rec())  cout << "First\n";

    else    cout << "Second\n";

}

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

#include <vector>

#include <algorithm>

#include <cmath>

#include <queue>

#include <string>

#include <map>

#include <set>

#include <stack>

#include <tuple>

#include <deque>

#include <numeric>

#include <bitset>

#include <iomanip>

#include <cassert>

#include <chrono>

#include <random>

#include <limits>

#include <iterator>

#include <functional>

#include <sstream>

#include <complex>

using namespace std;



using ll = long long;

using ull = uint64_t;

using P = pair<int, int>;

constexpr double EPS = 1e-9;

constexpr int INF = 1001001001;

constexpr int mod = 1777777777;

// constexpr int mod = 1000000007;

// constexpr int mod = 998244353;



template<class T>

inline bool chmax(T& x, T y){

    if(x < y){

        x = y;

        return true;

    }

    return false;

}

template<class T>

inline bool chmin(T& x, T y){

    if(x > y){

        x = y;

        return true;

    }

    return false;

}



int main(){

    ios::sync_with_stdio(false);

    cin.tie(nullptr);



    int N, K;

    cin >> N >> K;

    vector<int> a(N);

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



    vector<int> dp(K + 1);

    dp[0] = 0;

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

        int c = 0;

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

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

        }

        dp[i] = c > 0;

    }



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

    else    cout << "Second\n";

}

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

#include <vector>

#include <algorithm>

#include <cmath>

#include <queue>

#include <string>

#include <map>

#include <set>

#include <stack>

#include <tuple>

#include <deque>

#include <numeric>

#include <bitset>

#include <iomanip>

#include <cassert>

#include <chrono>

#include <random>

#include <limits>

#include <iterator>

#include <functional>

#include <sstream>

#include <complex>

using namespace std;



typedef long long ll;

typedef uint64_t ull;

typedef pair<int, int> P;

constexpr double PI = 3.1415926535897932;   // acos(-1)

constexpr double EPS = 1e-9;

constexpr int INF = 1001001001;

constexpr int mod = 1000000007;

// constexpr int mod = 998244353;



#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)



int n, k;

vector<int> a;

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



int memo_rec(int rest = k){

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

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



    int is_win = 1;

    bool is_possible = false;

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

        if(a[i] > rest) continue;

        is_possible = true;

        is_win &= memo_rec(rest - a[i]);

    }

    if(!is_possible)    return dp[rest] = 0;

    return dp[rest] = is_win ^ 1;

}



int main(){

    ios::sync_with_stdio(false);

    cin.tie(nullptr);



    cin >> n >> k;

    a.resize(n);

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



    if(memo_rec())  cout << "First\n";

    else    cout << "Second\n";

}

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

#include <vector>

#include <algorithm>

#include <cmath>

#include <queue>

#include <string>

#include <map>

#include <set>

#include <stack>

#include <tuple>

#include <deque>

#include <numeric>

#include <bitset>

#include <iomanip>

#include <cassert>

#include <chrono>

#include <random>

#include <limits>

#include <iterator>

#include <functional>

#include <sstream>

#include <complex>

using namespace std;



using ll = long long;

using ull = uint64_t;

using P = pair<int, int>;

constexpr double EPS = 1e-9;

constexpr int INF = 1001001001;

constexpr int mod = 1777777777;

// constexpr int mod = 1000000007;

// constexpr int mod = 998244353;



template<class T>

inline bool chmax(T& x, T y){

    if(x < y){

        x = y;

        return true;

    }

    return false;

}

template<class T>

inline bool chmin(T& x, T y){

    if(x > y){

        x = y;

        return true;

    }

    return false;

}



int main(){

    ios::sync_with_stdio(false);

    cin.tie(nullptr);



    int N, K;

    cin >> N >> K;

    vector<int> a(N);

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



    vector<int> dp(K + 1);

    dp[0] = 0;

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

        int c = 0;

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

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

        }

        dp[i] = c > 0;

    }



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

    else    cout << "Second\n";

}

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

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

#define pb(q) push_back(q)

typedef long long ll;

using namespace std;

#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;

int n,a[101],dp[100001][3];

int solve(int i,int j){

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

    int res=0;

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

		if (a[k]<=i){

			if (!solve(i-a[k],j^1)){

				res=1;

				break;

			}

		}

	}

	return dp[i][j]=res;

}



int main(){

	int k;

	cin>>n>>k;

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

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

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

	return 0;

}


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

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

#define pb(q) push_back(q)

typedef long long ll;

using namespace std;

#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;

int n,a[101],dp[100001];

int solve(int i){

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

    int res=0;

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

		if (a[k]<=i){

			if (!solve(i-a[k])){

				res=1;

				break;

			}

		}

	}

	return dp[i]=res;

}



int main(){

	int k;

	cin>>n>>k;

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

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

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

	return 0;

}


// Fastest known solution for this problem: