//Author : RAJEEV KUMAR
#include <bits/stdc++.h>
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
typedef long long ll;
typedef long double lld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpi;
typedef vector<pll> vpl;
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define sz(x) ((long long) x.size())
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define fastio ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define bitcount(x)  __builtin_popcount(x)
#define bitcountll(x)  __builtin_popcountll(x)
#define has_bit(bit_mask, x) ((bit_mask) & (1Uint << (x)))
#define turn_on_bit(bit_mask, x) (bit_mask |= (1Uint << (x)))
#define turn_off_bit(bit_mask, x) (bit_mask &= (~(1Uint << (x))))
#define smallest_on_bit(bit_mask) (__builtin_ctzint((bit_mask) & (-(bit_mask))))
//DBG
template<typename A> void dbg(vector<A> arr) {for(auto x:arr){cout<<x<<' ';}cout<<endl;}
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v);
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << '(' << p.f << ',' << p.s << ')'; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
cout << '['; for(int i = 0; i < v.size(); i++) {if (i) cout << ','; cout << v[i];} return cout << ']';}
template<typename A, typename B> istream& operator>>(istream& cin, pair<A, B> &p) {cin >> p.first;return cin >> p.second;}
// Constant
const ll INF = 1e18;
const ll mod = 1e9+7;
//const ll mod = 1000000009;
//const ll mod = 998244353;
//Clock
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define SC auto start = chrono::high_resolution_clock::now();
#define TC auto end = chrono::high_resolution_clock::now() ;double time_taken = (chrono::duration_cast<chrono::nanoseconds>(end - start).count())*1e-9;
#define DT cout << fixed << time_taken << setprecision(9)<< endl; 
//----------------------------------------------------------------------------//

//What to do in each testcase.
void solve(){
    int a[3] ={0};
    cin>>a[0]>>a[1]>>a[2];

    sort(a,a+3);

    if(a[0]+a[2]==2*a[1]) std::cout << "Yes" << std::endl;
    else std::cout << "No" << std::endl;
    return;
}

int32_t main() {
    fastio;
    //SC
    //int t; cin>>t; while (t--)solve();
    solve();
    //TC
    //DT
    return 0;
}
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<algorithm>
#include<cassert>
#include<cmath>
#include<vector>
#include<map>
#include<set>
#include<string>
#include<queue>
#include<stack>
#include<list>
#include <cstring>
#include <functional>
#include<unordered_map>
#include<unordered_set>
#include<bitset>
using namespace std;
#define MOD 1000000007
#define MOD2 998244353
#define INF ((1<<30)-1)
#define LINF ((Int)1<<60)
#define EPS (1e-10)
#define REP(i,n) for(int i=0; i<(int)(n); ++i)
#define RREP(i,n) for(int i=1; i<=(int)(n); ++i)
typedef long long Int;
typedef pair<Int, Int> PI;
typedef pair<int, int> pi;
typedef tuple<int, int, int> TP;
typedef vector<double> vec;
typedef vector<vec> mat;
const int N = 201005;
//////////////////////////////

void solve()
{
	Int n, x;
	cin >> n >> x;
	vector<Int> a(n), b(n);
	REP(i, n) cin >> a[i];
	REP(i, n - 1) b[i] = (x%a[i + 1]) / a[i];
	
	Int dp[51][2] = { 0 };
	dp[0][0] = 1;
	REP(i, n) {
		dp[i + 1][0] += dp[i][0];
		if(b[i] == 0) dp[i + 1][1] += dp[i][1];

		if (b[i]) dp[i + 1][1] += dp[i][1] + dp[i][0];

		if (i == n - 1 || b[i] != a[i + 1] / a[i] - 1) dp[i + 1][0] += dp[i][1];
	}
	cout << dp[n][0] << endl;
}

int main() {
	solve();
	return 0;
}