#include <iostream>
#include <vector>

//ModInt
template<long long M>
struct modint {
	long long val;

	void sub(long long &n) {
		if (n < 0) {
			long long m = (-n) % M;
			val = M - m;
		}
		else n %= M;
	}

	//コンストラクタ
	modint<M>(long long right) : val(right) {sub(val);}

	modint<M> operator+ (modint<M> right) {
		modint<M> ret = (this -> val) + right.val;
		return ret;
	}
	modint<M> operator+ (long long right) {
		sub(right);
		modint<M> ret = (this -> val) + right;
		return ret;
	}
	modint<M> operator- (modint<M> right) {
		modint<M> ret = (this -> val) - right.val;
		return ret;
	}
	modint<M> operator- (long long right) {
		sub(right);
		modint<M> ret = (this -> val) - right;
		return ret;
	}
	modint<M> operator* (modint<M> right) {
		modint<M> ret = (this -> val) * right.val;
		return ret;
	}
	modint<M> operator* (long long right) {
		sub(right);
		modint<M> ret = (this -> val) * right;
		return ret;
	}

	bool operator== (modint<M> right) {return ((this -> val) == right.val);}
	bool operator== (long long right) {sub(right); return ((this -> val) == right);}
	bool operator!= (modint<M> right) {return ((this -> val) != right.val);}
	bool operator!= (long long right) {sub(right); return ((this -> val) != right);}
	bool operator<= (modint<M> right) {return ((this -> val) <= right.val);}
	bool operator<= (long long right) {sub(right); return ((this -> val) <= right);}
	bool operator>= (modint<M> right) {return ((this -> val) >= right.val);}
	bool operator>= (long long right) {sub(right); return ((this -> val) >= right);}
	bool operator< (modint<M> right) {return ((this -> val) < right.val);}
	bool operator< (long long right) {sub(right); return ((this -> val) < right);}
	bool operator> (modint<M> right) {return ((this -> val) > right.val);}
	bool operator> (long long right) {sub(right); return ((this -> val) > right);}

	void operator+= (modint<M> right) {*this = *this + right;}
	void operator+= (long long right) {*this = *this + right;}
	void operator-= (modint<M> right) {*this = *this - right;}
	void operator-= (long long right) {*this = *this - right;}
	void operator*= (modint<M> right) {*this = *this * right;}
	void operator*= (long long right) {*this = *this * right;}

	long long modinv(long long n, long long p) {
		long long a = p, u = 1, v = 0;
		while (a) {
			long long t = n / a;
			n -= t * a;
			std::swap(n, a);
			u -= t * v;
			std::swap(u, v);
		}
		u %= p;
		if (u < 0) u += p;
		return u;
	}

	modint<M> operator/ (modint<M> right) {
		modint<M> ret = *this * modinv(right.val, M);
		return ret;
	}
	modint<M> operator/ (long long right) {
		sub(right);
		modint<M> ret = *this * modinv(right, M);
		return ret;
	}

	void operator/= (modint<M> right) {*this = *this / right;}
	void operator/= (long long right) {*this = *this / right;}
};

int main() {
	const long long p = 998244353;

	long long n, s;
	std::cin >> n >> s;
	std::vector<long long> a(n);
	for (long long i = 0; i < n; i++) std::cin >> a[i];

	std::vector<std::vector<modint<p>>> dp(n, std::vector<modint<p>>(s + 1, 0));
	dp[0][0] = 2;
	if (a[0] <= s) dp[0][a[0]] = 1;
	for (long long i = 1; i < n; i++) {
		for (long long j = 0; j <= s; j++) {
			dp[i][j] += dp[i - 1][j] * 2;
			if (j + a[i] <= s) dp[i][j + a[i]] += dp[i - 1][j];
		}
	}
	std::cout << dp[n - 1][s].val << std::endl;
}

Measured memory_bytes: 73672