// Slower C++ solution:
#include<bits/stdc++.h>

#include<iostream>

#include<cmath>

#include<vector>

#include<string>

#include<queue>

#include<set>

#include<map>

#include<algorithm>

#include<functional>



using namespace std;



typedef long long ll;

typedef unsigned long long ull;

typedef pair<int,int> pii;

typedef pair<ll, ll> pll;

typedef pair<ull, ull> pullull;

typedef pair<ll, int> plli;

typedef pair<int, pii> pipii;

typedef vector<vector<int> > mati;

typedef vector<vector<double> > matd;

typedef vector<ll> vll;

typedef vector<vector<ll>> vvll;



#define rep(i,x,y) for(int i=(x); i<(y); ++i)



template <typename T>

void vec_print(vector<T> VEC){

  rep(i, 0, VEC.size()){

    cout << VEC[i] << " ";

  }

  cout << "\n";

};



template <typename T>

void mat_print(vector<vector<T> > MAT){

  rep(i, 0, MAT.size()){

    rep(j, 0, MAT[i].size()){

      cout << MAT[i][j] << " ";

    }

    cout << "\n";

  }

};



template <typename CLASS1, typename CLASS2>

class HOGE{

  public:

    CLASS1 key;

    CLASS2 value;

    HOGE(ll key, ll value){

      this->key = index;

      this->value = value;

    };

    ~HOGE(void){

      return;

    };



    void print(void){

      cout << "key : " << key << ", value : " << value << "\n";

      return;

    };

    

    bool operator==(const HOGE &obj){

      return (this->value == obj.value);

    };

    bool operator<(const HOGE &obj){

      return (this->value < obj.value);

    };

    bool operator>(const HOGE &obj){

      return (this->value > obj.value);

    };

};



constexpr int INF = (1<<30);

constexpr ll INFLL = 1LL<<62;

constexpr long double EPS = 1e-12;



short int dp[100000+1];



/*

int search(const vll& a, const int K, vector<short int>& dp){

  if(dp[K]>=0) return dp[K];

  for(ll num : a){

    if(num <= K){

      int tmp = search(a, K-num, dp);

      if(tmp%2==0){

        return dp[K] = (tmp+1)%2;

      }

    }

  }

  return dp[K] = 0;

}

*/



int search(const vll& a, const int K){

  if(dp[K]>=0) return dp[K];

  for(ll num : a){

    if(num <= K){

      int tmp = search(a, K-num);

      if(tmp%2==0){

        return dp[K] = (tmp+1)%2;

      }

    }

  }

  return dp[K] = 0;

}



int main(){

  cin.tie(0); // cut the cin and cout (default, std::flush is performed after std::cin)

  ios::sync_with_stdio(false); // cut the iostream and stdio (DON'T endl; BUT "\n";)



  ll N, K;

  cin >> N >> K;

  vll a(N);

  rep(i, 0, N){

    cin >> a[i];

  }

  sort(a.begin(), a.end(), greater<ll>());

  //vector<short int> dp(K+1, -1);

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



  //if(search(a, K, dp)%2==1) printf("First\n");

  if(search(a, K)%2==1) printf("First\n");

  else printf("Second\n");



  return 0;

}


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

using namespace std;



typedef long long ll;

typedef vector<ll> vll;

typedef vector<vector<ll>> vvll;

typedef vector<vector<vector<ll>>> vvvll;

typedef vector<bool> vb;

typedef vector<vector<bool>> vvb;

typedef vector<vector<vector<bool>>> vvvb;

typedef pair<ll, ll> pll;

typedef vector<pll> vpll;

typedef vector<vpll> vvpll;

typedef vector<double> vd;

typedef vector<vd> vdd;



#define FOR(i,x,y) for(ll i=(ll)x; i<(ll)y; ++i)

#define REP(i,y) FOR(i, 0, y)

#define RFOR(i,x,y) for(ll i=(ll)x; i>=(ll)y; --i)

#define RREP(i,x) RFOR(i, x, 0)

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

#define pb push_back

#define debug_print(x...) cerr << "line " << __LINE__ << " : "; debug_print_in(x);



template <typename First>

void debug_print_in(First first){

  cerr << first << endl;

  return;

}



template <typename First, typename... Rest>

void debug_print_in(First first, Rest... rest){

  cerr << first << " ";

  debug_print_in(rest...);

  return;

}



void IN(void){

  return;

}



template <typename First, typename... Rest>

void IN(First& first, Rest&... rest){

  cin >> first;

  IN(rest...);

  return;

}



template <typename First>

void OUT(First first){

  cout << first << endl;

  return;

}



template <typename First, typename... Rest>

void OUT(First first, Rest... rest){

  cout << first << " ";

  OUT(rest...);

  return;

}



template<class t, class u> t chmax(t&a,u b){if(a<b)a=b; return a;};

template<class t, class u> t chmin(t&a,u b){if(a>b)a=b; return a;};

int popcount(int t){return __builtin_popcount(t);} //GCC

int popcount(ll t){return __builtin_popcountll(t);} //GCC



template <typename T>

void vec_print(vector<T> VEC){

  REP(i, VEC.size()){

    cerr << VEC[i] << " ";

  }

  cerr << endl;

};



template <typename T>

void mat_print(vector<vector<T> > MAT){

  REP(i,MAT.size()){

    REP(j,MAT[i].size()){

      cerr << MAT[i][j] << " ";

    }

    cerr << endl;

  }

};



constexpr int INF = (1<<30);

constexpr ll INFLL = 1LL<<62;

constexpr long double EPS = 1e-12;

constexpr ll MOD = (ll)((1E+9)+7);



int main(){

  cin.tie(0); // cut the cin and cout (default, std::flush is performed after std::cin)

  ios::sync_with_stdio(false); // cut the iostream and stdio (DON'T endl; BUT "\n";)



  ll N, K;

  IN(N,K);

  vll a(N);

  REP(i,N) IN(a[i]);

  sort(ALL(a));

  vb dp(K+1, true);

  dp[0] = false;

  REP(j,K+1){

    bool flag_tmp = false;

    REP(k,N){

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

      if(!dp[j-a[k]]) flag_tmp = true;

    }

    dp[j] = flag_tmp;

  }



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

  else OUT("Second\n");



  return 0;

}