#include<iostream>
#include<unordered_map>
#include<bitset>
#include<math.h>
#include<vector>
#include<set>
#include<algorithm>
#include<ctype.h>
#include<unordered_set>
#include<string>
#include<iomanip>
#include<queue>
#include<limits>
#include<map>
#include<stack>
#include<iterator>
#include<deque>
#define MOD 1000000007
#define INF 999999999999999999 
#define pb push_back
#define ff first
#define ss second
#define mt make_tuple
#define ll long long
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define f0 get<0>(temp)
#define f1 get<1>(temp)
#define f2 get<2>(temp)
using namespace std;
ll ncr(ll n, ll r)
{
    ll i, ans = 1, k = 0;
    if (r == 0)
        return 1;
    else if (n < r)
        return 0;
    for (i = n; i >= n - r + 1; i--)
    {
        ans *= i;
        ans /= n - i + 1;
    }
 
 
    return ans;
 
}
bool visited[6] = { false };
int n = 6;
vector<int> adj[6];
 
 
void max_heapify(int a[100], int i)
{
    int l, r, largest = i;
    l = 2 * i + 1;
    r = 2 * i + 2;
    if (l<n && a[l]>a[i])
        largest = l;
    if (r<n && a[r]>a[l])
        largest = r;
    if (largest != i)
    {
        int k;
        k = a[i];
        a[i] = a[largest];
        a[largest] = k;
        max_heapify(a, largest);
    }
 
}
int power(ll x, ll y, ll p)
{
    int res = 1;
    x = x % p;
 
    while (y > 0)
    {
 
        if (y & 1)
            res = (res * x) % p;
 
 
        y = y >> 1;
        x = (x * x) % p;
    }
    return res;
}
 
bool square(ll n)
{
    double x;
    x = sqrt(n);
    if (x == floor(x))
        return true;
    else return false;
}
 
 
bool prime(ll n)
{
    ll i;
    for (i = 2; i * i <= n; i++)
    {
        if (n % i == 0)
            return false;
    }
    return true;
}
 
ll modi(ll a, ll m)
{
    return power(a, m - 2, m);
 
}
void kmp(string s, ll pi[]) {
    int n = (int)s.length();
    pi[0] = 0;
    for (int i = 1; i < n; i++) {
        int j = pi[i - 1];
        while (j > 0 && s[i] != s[j])
            j = pi[j - 1];
        if (s[i] == s[j])
            j++;
        pi[i] = j;
    }
 
}
void zfunc(string s, ll z[]) {
 
    ll n = (ll)s.length();
    z[0] = 0;
    for (ll i = 1, l = 0, r = 0; i < n; ++i) {
        if (i <= r)
            z[i] = min(r - i + 1, z[i - l]);
        while (i + z[i] < n && s[z[i]] == s[i + z[i]])
            ++z[i];
        if (i + z[i] - 1 > r)
            l = i, r = i + z[i] - 1;
    }
 
 
}
struct pair_hash {
    size_t operator()(const pair<int, int>& p) const noexcept {
        return hash<ll>() ((((ll)p.first) << 32) | ((ll)p.second));
    }
};
void automaton(string s, ll aut[][26]) {
    //s += '#';
    ll n = s.size(), pi[1000];
    kmp(s, pi);
    ll i, j;
    for (i = 0; i < n; i++) {
        for (int c = 0; c < 26; c++) {
            if (i > 0 && 'a' + c != s[i])
                aut[i][c] = aut[pi[i - 1]][c];
            else
                aut[i][c] = i + ('a' + c == s[i]);
        }
    }
}
bool palin(string s) {
    ll i, n;
    n = s.length();
    for (i = 0; i <= n / 2; i++) {
        if (s[i] != s[n - i - 1]) {
            return false;
        }
    }
    return true;
}
ll sum(ll n) {
    ll i;
    i = n;
    ll sum = 0;
    while (i > 0) {
        sum += i % 10;
        i = i / 10;
    }
    return sum;
}
 
ll nCr(ll n, ll r, ll p, ll fac[])
{
 
    if (r == 0)
        return 1;
    fac[0] = 1;
    for (int i = 1; i <= n; i++)
        fac[i] = fac[i - 1] * i % p;
 
    return (fac[n] * modi(fac[r], p) % p *
        modi(fac[n - r], p) % p) % p;
}
 
ll gcd(ll a, ll b) {
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
void bfs(vector<ll>& ans, ll k) {
    queue<ll> q;
    
    while (!q.empty()) {
        ll temp = q.front();
      
    }
}
int dp[100001] = { 0 };
bool f(ll k,ll v[], ll n) {
    //cout << k << endl;
    if (k == 0) {
        return false;
    }
    bool ans = false;
    bool flag = false;
    for (int j = 0; j < n; j++) {
        if (k - v[j] >= 0) {
            flag = true;
            break;
            //cout << k - v[j] << endl;
        }
    }
    if (!flag) {
        dp[k] = -1;
        return false;
    }
    for (int j = 0; j < n; j++) {
        ll u = v[j];
        //cout << u;
            if (k - u >= 0) {
                
                if (dp[k - u] != 0) {
                    if (dp[k - u] == 1) {
                        continue;
                    }
                    else {
                        dp[k] = 1;
                        return true;
                    }
                    
                }
                else
                {
                    if (!f(k - u, v, n)) {
                        dp[k] = 1;
                        return true;
                    }
                    
                }
 
            }
        
    }
    
    if (!ans) {
        dp[k] = -1;
    }
   
    return ans;
}
 
int main() {
    fast;
    ll i, j;
    ll t = 1;
    //cin >> t;
    while (t--) {
        ll v[100];
        //int dp[1000] = { 0 };
        ll n, k, x;
        cin >> n >> k;
        for (i = 0; i < n; i++) {
            cin >> v[i];
        }
        
        
        
        if (f(k, v, n)) {
            cout << "First\n";
        }
        else {
            cout << "Second\n";
        }
        //for (i = 0; i <= 4; i++) {
            //cout << dp[i] << " ";
        //}
    }
 
}

Measured memory_bytes: 5376