Problem:
Score : 600 points

Problem Statement

Given are a sequence of N positive integers A_1, A_2, \ldots, A_N and another positive integer S.

For a non-empty subset T of the set \{1, 2, \ldots , N \}, let us define f(T) as follows:

f(T) is the number of different non-empty subsets \{x_1, x_2, \ldots , x_k \} of T such that A_{x_1}+A_{x_2}+\cdots +A_{x_k} = S.

Find the sum of f(T) over all 2^N-1 subsets T of \{1, 2, \ldots , N \}. Since the sum can be enormous, print it modulo 998244353.

Constraints

All values in input are integers.

1 \leq N \leq 3000

1 \leq S \leq 3000

1 \leq A_i \leq 3000

Input

Input is given from Standard Input in the following format:

N S
A_1 A_2 ... A_N

Output

Print the sum of f(T) modulo 998244353.

Sample Input 1

3 4
2 2 4

Sample Output 1

6

For each T, the value of f(T) is shown below. The sum of these values is 6.

f(\{1\}) = 0

f(\{2\}) = 0

f(\{3\}) = 1 (One subset \{3\} satisfies the condition.)

f(\{1, 2\}) = 1 (\{1, 2\})

f(\{2, 3\}) = 1 (\{3\})

f(\{1, 3\}) = 1 (\{3\})

f(\{1, 2, 3\}) = 2 (\{1, 2\}, \{3\})

Sample Input 2

5 8
9 9 9 9 9

Sample Output 2

0

Sample Input 3

10 10
3 1 4 1 5 9 2 6 5 3

Sample Output 3

3296

Solution in Ruby (2.7.1) (judge verdict: Wrong Answer)

n, s = gets.split.map(&:to_i)
a = gets.split.map(&:to_i).sort.reverse
MOD = 998244353

hash = {}
a.each do |x|
  if x > s
    next
  end
  _hash = hash.dup
  hash.keys.each do |k|
    xx = k + x
    if xx > s
      next
    end
    _hash[xx] ||= []
    _hash[xx] += hash[k].map{|ar| ar + 1}
  end
  hash = _hash
  hash[x] ||= []
  hash[x].push(1)
  #warn hash.inspect
end

pat = hash[s]
unless pat
  puts 0
  exit
end

# MAX = 3001
# @fac = Array.new MAX
# @finv = Array.new MAX
# @inv = Array.new MAX
# 
# @fac[0] = @fac[1] = 1
# @finv[0] = @finv[1] = 1
# @inv[1] = 1
# 2.upto(MAX) do |i|
#   @fac[i] = @fac[i-1] * i % MOD
#   @inv[i] = MOD - @inv[MOD % i] * (MOD / i) % MOD
#   @finv[i] = @finv[i - 1] * @inv[i] % MOD
# end
# 
# def com n, k 
#   return 0 if n < k
#   return 0 if n < 0 || k < 0
#   return @fac[n] * (@finv[k] * @finv[n-k] % MOD) % MOD
# end

cache = {}
cache[0] = 0
cache[1] = 2
2.upto(3000) do |i|
  cache[i] = 2 * cache[i-1] % MOD
end

result = 0
pat.each do |size|
  # warn list.inspect
  # warn 2**(n-size)
  cache[n-size] ||= 2**(n-size)
  result =  (result + cache[n-size]) % MOD
end
# warn pat.inspect
puts result % MOD