stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#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;

}

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

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



}


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

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

}

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

using namespace std;

const int maxn=305;

bool dp[10000025][2];

int a[maxn],n;



int dfs(int k,int t)

{

    if(dp[k][t]>0)

	 return dp[k][t];

    int ans=0;

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

     if(k>=a[i])

	  ans|=!dfs(k-a[i],!t);

    return dp[k][t]=ans;

}



int main()

{

    int k;

    cin>>n>>k;

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

     cin>>a[i];

    if(dfs(k,0)==false)

     cout<<"Second"<<endl;

    else

     cout<<"First"<<endl;

    return 0;

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



}


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

using namespace std;

const int maxn=305;

bool dp[10000025][2];

int a[maxn],n;



int dfs(int k,int t)

{

    if(dp[k][t]>0)

	 return dp[k][t];

    int ans=0;

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

     if(k>=a[i])

	  ans|=!dfs(k-a[i],!t);

    return dp[k][t]=ans;

}



int main()

{

    int k;

    cin>>n>>k;

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

     cin>>a[i];

    if(dfs(k,0)==false)

     cout<<"Second"<<endl;

    else

     cout<<"First"<<endl;

    return 0;

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



}


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



using ll = long long;



const int MOD = 1000000007;



const int size = 100005;



void Break()

{

#if _MSC_VER

	static int x = 0;

	++x;

	switch (x)

	{

		__debugbreak();

	}

#endif

}



bool dp[size];



int main()

{

#if _MSC_VER

	freopen("input.txt", "r", stdin);

#endif

	int n, k;

	std::cin >> n >> k;

	std::vector<int> v(n);

	for (int& x : v)

	{

		std::cin >> x;

	}

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

	{

		for (int x : v)

		{

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

			{

				dp[i] = true;

			}

		}

	}

	if (dp[k])

	{

		std::cout << "First\n";

	}

	else

	{

		std::cout << "Second\n";

	}

	return 0;

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



}


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

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

#define fst first

#define snd second

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

#define pb push_back

#define sz size()

#define FORN(i,j,n) for(int i=j; i<(int)n;i++) 

#define FOR(i,n) FORN(i,0,n)

#define FORIT(i,x) for( auto i = x.begin() ; i != x.end() ; i++ )

#define MOD 998244353LL

#define LIM 262150

#define ones(x) __builtin_popcount(x)

#define trace(x)    cerr << #x << ": " << x << endl;

#define trace2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl;

using namespace std;

 

typedef long long ll ;

typedef unsigned long long ull ;

typedef vector <int> vi;

typedef pair <int,int> ii;

typedef vector <string> vs;

typedef vector <ii> vii;

ll n,k;

ll arr[100005];

ll dp[100005];

int main() {

	fastio;

	cin>> n >> k;

	FOR(i,n) cin>> arr[i];

	FOR(i,k+1){

	    FOR(j,n){

			if(i >= arr[j]){

				dp[i] = max(dp[i],1-dp[i-arr[j]]);

			}

		}

	}

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

	else cout<< "Second\n";

	return 0;

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



}


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

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



}


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

    }

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

}


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

    }

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

}


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

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

}


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

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

}


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



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

}

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



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



}

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



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

    

}

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

}