jiahuimbzuai/CoQuIR huggingface dataset:
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
 
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
 
template<class T, class C> void chmax(T& a, C b){ a>b?:a=b; }
template<class T, class C> void chmin(T& a, C b){ a<b?:a=b; }
 
const int mod=1e9+7;
 
struct mint {
  ll x;
  mint(ll x=0):x(x%mod){}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
};
 
mint c[4005][4005];
void init() {
  c[0][0] = 1;
  for (int i = 0; i <= 4000; i++) {
    for (int j = 0; j <= i; j++) {
      c[i+1][j] += c[i][j];
      c[i+1][j+1] += c[i][j];
    }
  }
}
mint comb(int n, int k) {
  return c[n][k];
}
 
bool IsPrime(int num)
{
    if (num < 2) return false;
    else if (num == 2) return true;
    else if (num % 2 == 0) return false;
 
    double sqrtNum = sqrt(num);
    for (int i = 3; i <= sqrtNum; i += 2)
    {
        if (num % i == 0)
        {
            return false;
        }
    }
 
    return true;
}
 
map<ll, ll> primeFact(ll n) {
  map<ll, ll> res;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      res[i]++;
      n /= i;
    }
  }
  if (n != 1) res[n]++;
  return res;
}
 
void printv(vi& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
void printv(vll& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
int vtotal(vi& v){
  int total=0;
  rep(i,v.size()) total+=v[i];
  return total;
}
 
int main()
{
  //init(); // mint初期化
  cin.tie( 0 );
  ios::sync_with_stdio( false );
  int s;
  cin>>s;
  int ans=0;
  rep(i,3){
    int q=s%10;
    if(q==1)ans++;
    s/=10;
  }
  cout<<ans<<endl;
  return 0;
}
//  [c]
#include<stdio.h>
int main(void) {
  char s[3];
  scanf("%c%c%c", &s[0], &s[1], &s[2]);
  int c = 0;
  if(s[0] == '1') {
    c++;
  }
  if(s[1] == '1') {
    c++;
  }
  if(s[2] == '1') {
    c++;
  }
  printf("%d\n", c);
  return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>

int main(void){

    char s[4];

    scanf("%s", s);

    int a = 0;
    
    a += (s[0] == '1');
    a += (s[1] == '1');
    a += (s[2] == '1');

    printf("%d\n", a);

    return 0;
}
//  [c]
#include<stdio.h>

int main(){
    int a,b,c;
    scanf("%d",&a);
    for (int i = 0; i < 3; i++)
    {
        b = a;
        for (int f = 0; f < i; f++)
        {
            b /= 10;
        }
        if (b % 2 == 1)
        {
            c++;
        }
        
    }
    printf("%d",c);
}
//  [javascript]
function main(input) {
 console.log(input.split('1').length - 1);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
var input = require('fs').readFileSync('/dev/stdin', 'utf8').split(/\n/g)[0];
console.log(+(input[0] == "1") +(input[1] == "1") +(input[2] == "1"));
//  [javascript]
function main(input) {
	var result = 0;
	for(var i = 0; i < 3; i++) {
		if(input[i] == '1') {
			result += 1;
		}
	}
	console.log(result);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import "fmt"

func main() {
	// Code for A - Placing Marbles
	var s int
	fmt.Scanf("%d", &s)

	var answer int
	answer = s / 100
	answer += (s%100)/10 + (s%100)%10
	fmt.Println(answer)
}
//  [go]
package main

import "fmt"

func main() {
	var s string
	fmt.Scan(&s)
	var ans int
	for _, i := range s {
		if i == '1' {
			ans++
		}
	}
	fmt.Println(ans)
}
//  [go]
package main
import (
    "strconv"
    "fmt"
)
func main(){
    var s string
    ans := 0
    fmt.Scan(&s)
    for i :=0; i < len(s); i++ {
        r, _ := strconv.Atoi(s[i:i+1])
        ans += r
    }
    fmt.Println(ans)
}
//  [ruby]
str = gets.strip

ans = 0
for c in str.each_char do
  ans += c.to_i
end

p ans
//  [ruby]
nums = gets.strip.split('').map(&:to_i)
puts nums.inject(:+)
//  [ruby]
num = gets.chomp
p num.count('1')
//  [rust]
#[allow(unused_imports)]
use itertools::Itertools;
#[allow(unused_imports)]
use num::*;
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;
#[allow(unused_imports)]
use std::collections::*;

fn solve() {
    input! {
        s: Chars
    };

    let res = s.into_iter().filter(|&ch| ch == '1').count();
    println!("{}", res);
}

fn main() {
    std::thread::Builder::new()
        .name("big stack size".into())
        .stack_size(256 * 1024 * 1024)
        .spawn(|| {
            solve();
        })
        .unwrap()
        .join()
        .unwrap();
}
//  [rust]
macro_rules! get {
    ($t:ty) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            line.trim().parse::<$t>().unwrap()
        }
    };
    ($($t:ty),*) => {
        {
            let mut line: String = String::new();
            std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            (
                $(iter.next().unwrap().parse::<$t>().unwrap(),)*
            )
        }
    };
    ($t:ty; $n:expr) => {
        (0..$n).map(|_|
            get!($t)
        ).collect::<Vec<_>>()
    };
    ($($t:ty),*; $n:expr) => {
        (0..$n).map(|_|
            get!($($t),*)
        ).collect::<Vec<_>>()
    };
}

fn main() {
    println!("{}", get!(String).chars().map(|c| c.to_digit(10).unwrap()).sum::<u32>());
}
//  [swift]
import Foundation

let input_line: String = readLine()!
//let split: [String] = input_line.components(separatedBy: "")
//let a = Int(split[0])!
//let b = Int(split[1])!
//let c = Int(split[2])!
let num = Int(input_line)!

var result = 0


for num in input_line {
    if num == "1" {
        result += 1
    }
}
 print(result)
//  [swift]
let S = Array(readLine()!.characters)

var cnt = 0

for i in 0..<3 {
  if S[i] == Character("1") {
    cnt += 1
  }
}
  
print(cnt)
//  [swift]
func main() {
    let a = readLine()!
    print(a.filter { $0 == "1"}.count)
}

main()
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const s = input[0][0].split("").map(Number);

  return s.reduce((sum, cur) => sum + cur);
};

console.log(main(read()));
//  [typescript]
import * as fs from "fs";

// inputで受け取り配列化する
const input = fs.readFileSync("/dev/stdin", "utf8").split("").map(Number);

const ones = input.reduce((pre, cur) => pre + cur);

console.log(ones);
//  [typescript]
// general helpers
const debug = (message?: any, ...optionalParams: any[]) => {
  if (process.env.LOCAL_DEBUG === '1') console.log(message, ...optionalParams)
}

// helpers
const parseLines = (
  lines: string[]
): any => {
  const [a, b, c] = lines[0].split('').map(line => +line)
  const obj = { a, b, c }
  debug(obj)
  return obj
}
// solver
export const solve = (lines: string[]): string => {
  const { a, b, c } = parseLines(lines)
  return `${a + b + c}`
}

// main
const main = (lines: string[]) => {
  console.log(solve(lines))
}

// exec main function for submit
if (process.env.LOCAL_DEBUG !== '1') {
  const { stdin: input, stdout: output } = process
  input.resume()
  input.setEncoding('utf8')
  const lines: string[] = []
  require('readline')
    .createInterface({ input, output })
    .on('line', (line: string) => lines.push(line))
    .on('close', () => main(lines))
}
//  [python]
# -*- coding: utf-8 -*-
import numpy as np
#%%
a = input()
b = a.split()
b = b[0]+b[1]
a = int(b)
#%%
rta = np.sqrt(a)
sa = rta - int(rta)
if sa > 0:
    print('No')
else:
    print('Yes')
//  [python]
import numpy as np

a, b = input().split()
s = int(a + b)
n = np.sqrt(s)
if n % int(n) == 0:
    print("Yes")
else:
    print("No")
//  [python]
import numpy as np
a,b = map(str,input().split(' '))
N = int(str(a)+str(b))
n=1
f=0
while n <= int(np.sqrt(N))+1:
    if int(n*n)==N:
        print('Yes')
        f=1
        break
        
    else:
        n+=1
if f == 0:
    print('No')
//  [java]
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int join = a * (int) Math.pow(10, (int) Math.log10(b) + 1) + b;
		System.out.println(IntStream.rangeClosed(1, 317).anyMatch(i -> join == i * i) ? "Yes" : "No");
	}
}
//  [java]
/*
 * author Puneet;
 */
import java.io.*;

public class Main{
    public static void main(String agrs[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream, true);
        StringBuilder builder = new StringBuilder();

        String a[]=br.readLine().trim().split(" ");
        builder.append(a[0]);
        builder.append(a[1]);
//        out.println(builder);
        int n=Integer.parseInt(builder.toString());
        int p=(int)Math.sqrt(n);
        if((p*p)==n)
            out.println("Yes");
        else
            out.println("No");

    }

}
//  [java]
import java.util.*;
public class Main{
  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);
    int n = Integer.parseInt(sc.nextLine().replace(" ", ""));
    if(Math.sqrt(n) == Math.floor(Math.sqrt(n))){
      System.out.println("Yes");
    }else{
      System.out.println("No");
    }
  }
}
//  [cpp]
#include<bits/stdc++.h>                                                                          
using namespace std;
int main()
{
  int a,b;
  cin >> a >> b;
  int n;
  if(b/10==0)
    n=a*10+b;
  else if(b/10/10==0)
    n=a*100+b;
  else
    n=a*1000+b;
  int k=n/2+1;
  int count=0;
  for(int i=0; i<k; i++){
    for(int j=0; j<k; j++){
      if(i==j){
        if(i*j==n){
          count++;
        }
      }
    }
  }
  if(count==0)
    cout << "No" << endl;
  else
    cout << "Yes" << endl;
}
//  [cpp]
#include<bits/stdc++.h>
#include<ctype.h>
using namespace std;

#define int long long
#define str string
#define rep(x,y) for(int i=x;i<y;i++)
#define REP(x,y) for(int j=x;j<y;j++)
#define all(x) x.begin(),x.end()
#define vint vector<int>
#define vchar vector<char>
#define vstr vector<string>
#define pb(n) push_back(n)

signed main(){
  int A,B,N,M,count=0,count2=0,count3=0;
  str S,T;
  int C='A'-'a';
  cin>>A>>B;
  vstr W(N);
  if(B/100>=1)N=1000;
  else if(B/10>=1)N=100;
  else N=10;
  M=A*N+B;
  rep(0,M/2){
    REP(0,M/2){
      if(i==j&&i*j==M)count+=1;
    }
  }
  if(count>=1)cout<<"Yes"<<endl;
  else cout<<"No"<<endl;
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

//平方数は元の数x,平方数yとして
//x >= 4y
//と考えられるからfor文は元の数のx/4までしか回さなくていい。

int main()
{
  string a, b;

  cin >> a >> b;

  a += b;

  int num = 0;
  for (int i = 0; i < a.length(); i++)
  {
    num *= 10;
    num += a[i] - '0';
  }

  for (int i = 0; i <= (num * num) / 4; i++)
  {
    if (i * i == num)
    {
      cout << "Yes" << endl;
      exit(0);
    }
  }

  cout << "No" << endl;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <math.h>

int main(){
    char a[4]={0}, b[4]={0}, c[8]={0};
    int  x, y;

    scanf("%s %s", a, b);
    sprintf(c, "%s%s", a, b);

    x = atoi(c);
    y = (int)sqrt((double)x);

    if( pow((double)y, 2) != x ){ printf("No\n");  }
    else                        { printf("Yes\n"); }
    return 0;
}
//  [c]
#include <stdio.h>
int main(){
int a,b,c,d=0;
scanf ("%d%d",&a,&b);
if ((b-b%10)/10 == 0){
c=a*10+b;
}
else if ((b-b%100)/100 == 0){
c=a*100+b;
}
else {
c=a*1000+b;
}
for (int i=0;i<c*100;i++){
if (c == i*i){
  d=1;
}
}
if (d==1){
printf ("Yes");
}
else{
printf ("No");
}
return 0;
}
//  [c]
#include<stdio.h>
int main()
{
	int a,b;
	int x=0,f=0,i;
	scanf("%d %d",&a,&b);
	if(b>=100) x=a*1000+b;
	else if(b>=10) x=a*100+b;
	else x=a*10+b;
	//printf("%d\n",x);
	for(i=1;i<=1000;i++){
		if(x==i*i){
			f=1;
		}
	}
	if(f==1) printf("Yes\n");
	else printf("No\n");
	return 0;
}
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {

  var inp = input.split(' ');
  var num = parseInt(inp[0] + inp[1]);

  var tmp1 = Math.sqrt(num);
  var tmp2 = parseInt(Math.sqrt(num));

  // console.log(tmp1);
  // console.log(tmp2);

  if (tmp1 - tmp2 === 0) {
    console.log('%s', 'Yes');
  } else {
    console.log('%s', 'No');
  }

}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
const main = stdin => {
  const input = stdin.trim().split('\n')
  const [a, b] = input[0].split(' ')

  const c = parseInt(a + b)
  for (let i = 1; i <= c / 2; i++) {
    if (i * i === c) {
      console.log('Yes')
      return
    }
  }
  console.log('No')
}


// 標準入力
main(require("fs").readFileSync("/dev/stdin", "utf8"))
//  [javascript]
function main(input) {
  var In = input.split(' ');
  var str = In[0] + In[1];
  var num = parseInt(str, 10);
  var sqrt = Math.sqrt(num);
  
  if(Number.isInteger(sqrt)) {
    console.log('Yes');
  } else {
    console.log('No');
  }
  
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"fmt"
	"strconv"
)

func main() {
	var i int
	var a, b string
	fmt.Scan(&a, &b)
	c := a + b
	i, _ = strconv.Atoi(c)
	ans := numSquares(i)

	if ans == 1 {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}

func numSquares(n int) int {
	dp := make([]int, n+1)
	dp[0] = 0

	for i := 0; i <= n; i++ {
		dp[i] = i
		for j := 1; i-j*j >= 0; j++ {
			dp[i] = Min(dp[i], dp[i-j*j]+1)
		}
	}

	return dp[n]
}

func Min(a, b int) int {
	if a >= b {
		return b
	} else {
		return a
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func next() string {
	sc.Scan()
	return sc.Text()
}

func main() {
	sc.Split(bufio.ScanWords)
	a := next()
	b := next()

	i, _ := strconv.Atoi(a + b)
	j := int(math.Sqrt(float64(i)))
	k := int(j * j)

	if k == i {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import (
	"fmt"
	"math"
	"strconv"
)

func main() {
	// Code for B - 1 21
	var a, b int
	fmt.Scanf("%d %d", &a, &b)

	var S float64
	A := strconv.Itoa(a)
	B := strconv.Itoa(b)
	C, _ := strconv.Atoi(A + B)
	S = math.Sqrt(float64(C))

	if math.Round(S) == S {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [ruby]
lines = readlines.join.split.map(&:to_i)

X = lines.join("").to_i
ary = []
X.times do |i|
    Y = X / (i+1)
    if Y * Y == X
        ary << Y
    end
end
if ary[0] == nil
    puts "No"
else
    puts "Yes"
end
//  [ruby]
a, b = gets.chomp.split(" ")
(1..1000000).each do |i|
    ans = (i ** 2).to_s
    if ans == a+b
        puts "Yes"
        exit
    end
end
puts "No"
//  [ruby]
a = gets.strip.split.map(&:to_i)
ans = "No"
(1..(a.join.to_i)).each do |i|
  if i**2 == a.join.to_i
    ans = "Yes"
  end
end
puts ans
//  [rust]
use proconio::{input, fastout};
use proconio::marker::{Chars};
use proconio::marker::Usize1;
use std::cmp::*;

macro_rules! debug {
      ($($a:expr),*) => {
          eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

#[fastout]
fn main() {
    input!{
        mut a: Chars,
        b: Chars,
    }

    a.extend(b);
    let a1: String = a.iter().collect();
    let num = a1.parse().unwrap();

    for i in 1..10000+1 {
        if i*i==num {
            println!("Yes");
            return;
        }
    }

    println!("No");

}
//  [rust]
#![allow(unused_imports)]
// use itertools::Itertools;
use proconio::{input, marker::*};

fn main() {
    input! {
        a: usize,
        b: usize
    };
    let num = format!("{}{}", a, b).parse::<usize>().unwrap();
    for i in 1..=num {
        if i * i == num {
            println!("Yes");
            return;
        }
    }
    println!("No");
}
//  [rust]
use proconio::input;

#[allow(unused_variables)]
fn main() {
    input! {
      a: String, b: String
    };

    let n: f32 = format!("{}{}", a, b).parse().unwrap();

    let i = n.sqrt().floor();

    println!("{}", if i * i == n { "Yes" } else { "No" });
}
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const [a, b] = input[0];

  const ab = Number(`${a}${b}`);

  return Math.round(Math.sqrt(ab)) ** 2 === ab ? "Yes" : "No";
};

console.log(main(read()));
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const [a, b] = input[0];

  const ab = Number(`${a}${b}`);

  return Math.ceil(Math.sqrt(ab)) ** 2 === ab ? "Yes" : "No";
};

console.log(main(read()));
//  [typescript]
import * as fs from "fs";

const [a, b] = fs.readFileSync("/dev/stdin", "utf8").split(" ").map(String);

const target: = Math.sqrt(a + b);
if(target == Math.floor(target)) {
	console.log("Yes");
} else {
	console.log("No");
}
//  [python]
mod = 998244353
inv = pow(2, mod-2, mod)
n, s = map(int, input().split())
a = list(map(int, input().split()))
dp = [0]*(s+1)
dp[0] = pow(2, n, mod)
for i in a:
  for j in range(s, i-1, -1):
    dp[j] = (dp[j] + dp[j-i] * inv) % mod
print(dp[s])
//  [python]
N,S=map(int,input().split())
A=list(map(int,input().split()))
pr=998244353
def gya(n):
    return pow(n,pr-2,pr)
p=pow(2,N-1,pr)
l=[0]*(S+1)
g=gya(2)
for i in A:
    for j in range(S-i,-1,-1):
        l[i+j]=(l[i+j]+(l[j]*g))%pr
    if i<=S:
        l[i]+=p
print(l[-1])
//  [python]
import sys

sys.setrecursionlimit(500005)
stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

n, s = na()
a = na()

def invl(a, mod):
    b = mod
    p = 1; q = 0
    while b > 0:
        c = a // b
        a, b = b, a%b
        p, q = q, p-c*q
    return p + mod if p < 0 else p

mod = 998244353
i2 = invl(2, mod)
dp = [0] * (s+1)
dp[0] = pow(2, n, mod)

for x in a:
    for i in range(s, x-1, -1):
        dp[i] += dp[i-x] * i2
        dp[i] %= mod

print(dp[s] % mod)
//  [python]
import sys
input = sys.stdin.readline

def solve():
    MOD = 998244353
    inv2 = pow(2, MOD-2, MOD)

    N, S = map(int, input().split())
    As = list(map(int, input().split()))

    dp = [0] * (S+1)
    dp[0] = pow(2, N, MOD)
    for A in As:
        for k in reversed(range(S-A+1)):
            dp[k+A] += dp[k] * inv2
            dp[k+A] %= MOD

    print(dp[-1])


solve()
//  [python]
mod = 998244353

n, s = map(int, input().split())
a = list(map(int, input().split()))

a.sort()

while a[-1] > s:
    a.pop(-1)
    if a == []:
        print(0)
        exit()

su = sum(a)
if su < s:
    print(0)
    exit()
if su == s:
    print(pow(2, n - len(a), mod))
    exit()

dp = [0] * (s + 1)
dp[0] = 1
for i in a:
    newdp = [2 * j for j in dp]
    for j in range(s - i + 1):
        newdp[j+i] += dp[j]
    dp = newdp

print(dp[s] * pow(2, n - len(a), mod) % mod)
//  [python]
def resolve():
    n, s = map(int, input().split())
    a = list(map(int, input().split()))
    mod = 998244353
    modinv = pow(2, mod - 2, mod)
    dp = [0] * (s + 1)
    dp[0] = pow(2, n, mod)
    for i in a:
        for j in range(s - i, -1, -1):
            dp[j + i] += dp[j] * modinv
            dp[j + i] %= mod
    print(dp[-1])


if __name__ == '__main__':
    resolve()
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.NoSuchElementException;

	
public class Main{
	
	public static void main(String[] args) {
		new Main().run();
	}
	
	final long MOD=998244353;

	long pow(long a,long n) {
		return n!=0?pow(a*a%MOD,n/2)*(n%2==1?a:1)%MOD:1;
	}
	
	long inv(long a) {
		return pow(a,MOD-2);
	}
	

	void run() {
		FastScanner sc=new FastScanner();
		int N=sc.nextInt();
		int S=sc.nextInt();
		int[] A=new int[N];
		for (int i=0;i<N;++i) A[i]=sc.nextInt();	
		long[] dp=new long[S+1];
		dp[0]=1;
		long i2=inv(2);
		for (int i=0;i<N;++i) {
			for (int j=S;j>=0;--j) {
				int nj=j+A[i];
				if (nj>S) continue;
				dp[nj]=(dp[nj]+dp[j]*i2%MOD)%MOD;
			}
		}
		System.out.println(dp[S]*pow(2,N)%MOD);
	}
	
	void tr(Object...objects) {System.out.println(Arrays.deepToString(objects));}
}

class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        }else{
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
    private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
    private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
    public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    public long nextLong() {
        if (!hasNext()) throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while(true){
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            }else if(b == -1 || !isPrintableChar(b)){
                return minus ? -n : n;
            }else{
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
        return (int) nl;
    }
    
    public double nextDouble() { return Double.parseDouble(next());}
}
//  [java]
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;

public class Main {
    static Input in = new Input(System.in);
    static PrintWriter out = new PrintWriter(System.out);

    static int N;
    static int S;
    static int[] A;

    public static void main(String[] args) {
        N = in.nextInt();
        S = in.nextInt();
        A = new int[N];
        for (int i = 0; i < N; i++)
            A[i] = in.nextInt();
        dp = new long[N][S];
        for (int i = 0; i < N; i++) for (int j = 0; j < S; j++)
            dp[i][j] = -1;
        out.println(dp(0, 0, 0));
        out.flush();
    }

    static long dp[][];

    private static long dp(int n, int s, int c) {
        if (s == S) return mPow(2, N - c);
        if (s > S || n >= N) return 0;
        if (dp[n][s] == 0) return 0;
        if (dp[n][s] > 0) return (dp[n][s] * mInv(mPow(2, c))) % MOD;
        long l = (dp(n + 1, s, c) + dp(n + 1, s + A[n], c + 1)) % MOD;
        dp[n][s] = (l * mPow(2, c)) % MOD;
        return l;
    }

    static final int MOD = 998244353;
    static long mPow(long a, long b) {
        long ret = 1;
        while (b > 0) {
            if (b % 2 == 1)
                ret = (ret * a) % MOD;
            a = (a * a) % MOD;
            b /= 2;
        }
        return ret;
    }
    static long mInv(long a) {
        return mPow(a, MOD - 2);
    }

    static class Input {
        private BufferedReader br;
        private String[] buff;
        private int index = 0;

        Input(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }
        String nextLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
        String next() {
            while (buff == null || index >= buff.length) {
                buff = nextLine().split(" ");
                index = 0;
            }
            return buff[index++];
        }
        byte nextByte() {
            return Byte.parseByte(next());
        }
        short nextShort() {
            return Short.parseShort(next());
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        float nextFloat() {
            return Float.parseFloat(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        BigInteger nextBigInteger() {
            return new BigInteger(next());
        }
        BigDecimal nextBigDecimal() {
            return new BigDecimal(next());
        }
    }
}
//  [cpp]
#pragma GCC optimize ("O3")
#pragma GCC target ("avx2")
//#include<bits/stdc++.h>
#include<cstdio>
#include<algorithm>

using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please

const int mod = 998244353;
const int IMAX = 100000;
constexpr ll modpow(ll A, ll B) {
	ll kotae = 1;
	while (B > 0) {
		if (B & 1) kotae = kotae * A % mod;
		A = A * A % mod;
		B >>= 1;
	}
	return kotae;
}

int dp[3001];
int main() {
	//cin.tie(0);
	//ios::sync_with_stdio(false);


	int N, S;
	scanf("%d %d", &N, &S);

	int A[3000];
	rep(i, N) scanf("%d", A + i);
	sort(A, A + N);

	ll k2 = modpow(2, mod - 2);
	dp[0] = modpow(2, N);
	int s = 0;
	ll kotae = 0;
	rep(i, N) {
		s = min(S - A[i], s + A[i]);

		if (S >= A[i]) kotae += dp[S - A[i]];
		for (int j = s; j >= A[i]; j--) {
			dp[j] = (dp[j] + dp[j - A[i]] * k2) % mod;
		}
	}

	printf("%lld\n", kotae % mod * k2 % mod);

	Would you please return 0;
}
//  [cpp]
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vll = vector<long long>;
using vp = vector<pair<int, int>>;
using vvi = vector<vector<int>>;
using vvc = vector<vector<char>>;
using vvll = vector<vector<long long>>;
template<class T> inline bool chmax(T &a, T b) { if (a<b) {a=b; return 1;} return 0;}
template<class T> inline bool chmin(T &a, T b) { if (b<a) {a=b; return 1;} return 0;}

const int mod = 998244353;
struct mint {
    long long x;
    mint(long long x=0) : x((x % mod + mod) % mod) {}
    mint operator-() const { return mint(-x);}
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += mod - a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) { (x *= a.x) %= mod; return *this;}
    mint operator+(const mint a) const { return mint(*this) += a;}
    mint operator-(const mint a) const { return mint(*this) -= a;}
    mint operator*(const mint a) const { return mint(*this) *= a;}
    mint pow(long long t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
    mint inv() const { return pow(mod-2);}
    mint& operator/=(const mint a) { return *this *= a.inv();}
    mint operator/(const mint a) const { return mint(*this) /= a;}
};
istream& operator>>(istream& is, const mint& a) { return is >> a.x;}
ostream& operator<<(ostream& os, const mint& a) { return os << a.x;}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n, s;
    cin >> n >> s;
    vector<vector<mint>> dp(n+1, vector<mint>(s+1));
    dp[0][0] = mint(2).pow(n);
    rep(i, n) {
        int a;
        cin >> a;
        rep(j, s+1) {
            dp[i+1][j] += dp[i][j];
            if (j+a <= s) dp[i+1][j+a] += dp[i][j]/2;
        }
    }
    cout << dp[n][s] << endl;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef vector<ll> VI;
typedef vector<VI> VVI;
const ll MOD = 998244353;
const ll INF = 4611686018427387903;
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()

ll power(ll x, ll y) {
	if (y==0) return 1;
	else if (y==1) return x%MOD;
	else if (y%2==0) { ll pow=power(x,y/2); return (pow*pow)%MOD; } 
	else { ll pow=power(x,y/2); return ((pow*pow)%MOD)*x%MOD; }
}
ll divid(ll x, ll y) {
	return ((x%MOD)*power(y,MOD-2))%MOD;
}

int main(){
	int n, s; cin >> n >> s;
	VI a(n); REP(i,n) cin >> a[i];
	VVI dp(n+1,VI(s+1,0));
	dp[0][0]=power(2,n);
	REP(i,n){
		REP(j,s+1){
			dp[i+1][j]=dp[i][j];
			if(j-a[i]>=0)
				dp[i+1][j]+=divid(dp[i][j-a[i]],2);
			dp[i+1][j]%=MOD;
		}
	}
	cout << dp[n][s] << endl;
	return 0;
}
//  [c]
#include<stdio.h>
int main()
{
	int n, s;
	scanf("%d %d", &n, &s);
	int i, j;
	int a[3003];
	for (i = 0; i < n; i++)
		scanf("%d", &a[i]);
	long long int dp[3003];
	long long int p = 998244353;
	for (i = 0; i <= s; i++)
		dp[i] = 0;
	dp[0] = 1;
	for (i = 0; i < n; i++)
	{
		for (j = s - a[i]; j >= 0; j--)
			dp[j + a[i]] = (2 * dp[j + a[i]] + dp[j]) % p;
		for (j = a[i] - 1; j >= 0; j--)
			dp[j] = dp[j] * 2 % p;
	}
	printf("%lld\n", dp[s]);
	return 0;
}
//  [c]
#include <stdio.h>

#define Mod 998244353

long long div_mod(long long x, long long y, long long z)
{
	if (x % y == 0) return x / y;
	else return (div_mod((1 + x / y) * y - x, (z % y), y) * z + x) / y;
}

int main()
{
	int i, N, S, A[3001];
	scanf("%d %d", &N, &S);
	for (i = 1; i <= N; i++) scanf("%d", &(A[i]));
	
	int j;
	long long pow[3001], pow_inv[3001], dp[2][3001];
	for (i = 1, pow[0] = 1; i <= N; i++) pow[i] = pow[i-1] * 2 % Mod;
	for (i = N - 1, pow_inv[N] = div_mod(1, pow[N], Mod); i >= 0; i--) pow_inv[i] = pow_inv[i+1] * 2 % Mod;
	for (i = 1, dp[0][0] = 1; i <= N; i++) {
		for (j = 0; j <= S; j++) dp[i%2][j] = dp[1-i%2][j];
		for (j = S - A[i]; j >= 0; j--) dp[i%2][j+A[i]] = (dp[i%2][j+A[i]] + dp[1-i%2][j] * pow_inv[1]) % Mod;
	}
	printf("%lld\n", dp[1-i%2][S] * pow[N] % Mod);
	fflush(stdout);
	return 0;
}
//  [c]
#include<stdio.h>
#define i64 long long int
i64 m[3001][3001];
i64 mp=998244353;
int a[3001];
i64 f(int i,int s)
{
    if((i==0)&&(s==0)) return 1;
    if(i==0) return 0;
    if(m[i][s]!=-1) return m[i][s];
    if(s-a[i]>=0)
        m[i][s]=((2*f(i-1,s))%mp+f(i-1,s-a[i]))%mp;
    else m[i][s]=(2*f(i-1,s))%mp;
    return m[i][s];
}

int main()
{
   int n,s,i,j;
   i64 b;
   scanf("%d %d",&n,&s);
   for(i=1;i<=n;i++) scanf("%d",&a[i]);
   for(i=0;i<=n;i++)
   {
       for(j=0;j<=s;j++)
        m[i][j]=-1;
   }
   b=f(n,s);
   printf("%lld",b);
    return 0;
}
//  [javascript]
"use strict";
var input=require("fs").readFileSync("/dev/stdin","utf8");
var cin=input.split(/ |\n/),cid=0;
function next(){return +cin[cid++];}
function nextstr(){return cin[cid++];}
function nextbig(){return BigInt(cin[cid++]);}
function nexts(n,a){return a?cin.slice(cid,cid+=n):cin.slice(cid,cid+=n).map(a=>+a);}
function nextm(h,w,a){var r=[],i=0;if(a)for(;i<h;i++)r.push(cin.slice(cid,cid+=w));else for(;i<h;i++)r.push(cin.slice(cid,cid+=w).map(a=>+a));return r;}
function xArray(v){var a=arguments,l=a.length,r="Array(a["+--l+"]).fill().map(x=>{return "+v+";})";while(--l)r="Array(a["+l+"]).fill().map(x=>"+r+")";return eval(r);}

var mod = 998244353;
function mul(){for(var a=arguments,r=a[0],i=a.length;--i;)r=((r>>16)*a[i]%mod*65536+(r&65535)*a[i])%mod;return r;}
var fac=[],finv=[],invs=[],pow2=[];
function fset(n){
  fac.length=n+1,fac[0]=fac[1]=1;
  for(var i=2;i<=n;)fac[i]=mul(fac[i-1],i++);
  finv.length=n+1,finv[0]=finv[1]=1,finv[n]=inv(fac[n]);
  for(i=n;2<i;)finv[i-1]=mul(finv[i],i--);
  //invs.length=n+1,invs[0]=invs[1]=1;
  //for(i=2;i<=n;)invs[i]=mul(fac[i-1],finv[i++]);
  //pow2.length=n+1,pow2[0]=1;
  //for(i=1;i<=n;i++)pow2[i]=pow2[i-1]*2%mod;
}
function inv(b){for(var a=mod,u=0,v=1,t;b;v=t)t=a/b|0,a-=t*b,u-=t*v,t=a,a=b,b=t,t=u,u=v;u%=mod;return u<0?u+mod:u;}
function pow(a,n){for(var r=1;n;a=mul(a,a),n>>=1)if(n&1)r=mul(a,r);return r;}
function ncr(n,r){return mul(fac[n],finv[r],finv[n-r]);}
function npr(n,r){return mul(fac[n],finv[r]);}
function mput(n){return (n%mod+mod)%mod;}

var myOut = main();
if(myOut !== undefined)console.log(myOut);

function main(){
  var n = next(), s = next();
  var a = nexts(n);
  var dp = xArray(0,s+1);
  dp[0] = pow(2,n);
  var inv2 = inv(2);
  for(var i = 0; i < n; i++){
    for(var j = s-a[i]; j >= 0; j--){
      dp[j+a[i]] += mul(dp[j],inv2);
      dp[j+a[i]] %= mod;
    }
  }
  return dp[s];
}
//  [javascript]
function Main(input) {
  input = input.split("\n");
  var N = parseInt(input[0].split(" ")[0]);
  var S = parseInt(input[0].split(" ")[1]);
  var A = input[1].split(" ").map(i => parseInt(i)).sort(function(a,b){return a-b});
  var mod = 998244353n;
  //var mod = 7n
  var memo = new Array(S);
  for(var i=0;i<S+1;i++){
    var memosub = [i,0n];
    memo[i]=memosub;
  }
  function modpow(a, n, mod) {
    res = 1n;
    while (n > 0) {
        if (n & 1n) res = res * a % mod;
        a = a * a % mod;
        n >>= 1n;
    }
    return res;
  }
  function modinv(a, mod) {
    return modpow(a, mod - 2n, mod);
  }
  var inv = modinv(2n,mod);
  var y = 1n;
  for(var i=0;i<N-1;i++){
    y = (y * 2n)%mod;
  }
  memo[0] = [0,1n];
  var ans = 0n;
  for(var i=0;i<N;i++){
    for(var j=memo.length-1;j>=0;j--){
      if(memo[j][0]+A[i]<=S&&j==0){
        memo[j+A[i]][1]=(memo[j+A[i]][1]+y)%mod;
      }else if(memo[j][0]+A[i]<=S){
        memo[j+A[i]][1]=(memo[j+A[i]][1]+(memo[j][1]*inv)%mod)%mod;
      }
    }
  }
  var ans = memo[memo.length-1][1].toString();
  console.log('%s', ans);
  return ans;
}

function debug(n){
  var input = document.getElementById("input"+n).value;
  var ans=Main(input);
  var result="WA";
  if(ans==document.getElementById("output"+n).value.split("\n")[0]){
    result="AC";
  }
  document.getElementById("result"+n).innerHTML=result;
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"bufio"
	. "fmt"
	"os"
)

// github.com/EndlessCheng/codeforces-go
func main() {
	in := bufio.NewReader(os.Stdin)
	var n, sum, v int
	Fscan(in, &n, &sum)
	f := make([]int, sum+1)
	f[0] = 1
	for ; n > 0; n-- {
		Fscan(in, &v)
		for s := sum; s >= 0; s-- {
			f[s] <<= 1
			if s >= v {
				f[s] += f[s-v]
			}
			f[s] %= 998244353
		}
	}
	Print(f[sum])
}
//  [go]
package main

import (
	"bufio"
	. "fmt"
	"io"
	"os"
)

// github.com/EndlessCheng/codeforces-go
func run(_r io.Reader, _w io.Writer) {
	in := bufio.NewReader(_r)
	var n, sum int
	Fscan(in, &n, &sum)
	a := make([]int, n)
	for i := range a {
		Fscan(in, &a[i])
	}
	dp := make([]int, sum+1)
	dp[0] = 1
	for _, v := range a {
		for s := sum; s >= 0; s-- {
			dp[s] <<= 1
			if s >= v {
				dp[s] += dp[s-v]
			}
			dp[s] %= 998244353
		}
	}
	Fprint(_w, dp[sum])
}

func main() { run(os.Stdin, os.Stdout) }
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1000005), 1000005)
	return scanner
}
func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}
func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}
func getNextInt64(scanner *bufio.Scanner) int64 {
	i, _ := strconv.ParseInt(getNextString(scanner), 10, 64)
	return i
}
func getNextUint64(scanner *bufio.Scanner) uint64 {
	i, _ := strconv.ParseUint(getNextString(scanner), 10, 64)
	return i
}
func getNextFloat64(scanner *bufio.Scanner) float64 {
	i, _ := strconv.ParseFloat(getNextString(scanner), 64)
	return i
}
func main() {
	fp := os.Stdin
	wfp := os.Stdout
	cnt := 0
	if os.Getenv("MASPY") == "ますピ" {
		fp, _ = os.Open(os.Getenv("BEET_THE_HARMONY_OF_PERFECT"))
		cnt = 2
	}
	if os.Getenv("MASPYPY") == "ますピッピ" {
		wfp, _ = os.Create(os.Getenv("NGTKANA_IS_GENIUS10"))
	}
	scanner := getScanner(fp)
	writer := bufio.NewWriter(wfp)
	solve(scanner, writer)
	for i := 0; i < cnt; i++ {
		fmt.Fprintln(writer, "-----------------------------------")
		solve(scanner, writer)
	}
	writer.Flush()
}
func solve(scanner *bufio.Scanner, writer *bufio.Writer) {
	n := getNextInt(scanner)
	s := getNextInt(scanner)
	aa := make([]int, n)
	for i := 0; i < n; i++ {
		aa[i] = getNextInt(scanner)
	}
	dp := make([]mint, s+1)
	dp[0] = 1
	for i := 0; i < n; i++ {
		for j := s; j >= 0; j-- {
			dp[j].mulAs(2)
			if j-aa[i] >= 0 {
				dp[j].addAs(dp[j-aa[i]])
			}
		}
	}
	fmt.Fprintln(writer, dp[s])
}

type mint int64

func (mt mint) mod() mint {
	m := mint(998244353)
	mt %= m
	if mt < 0 {
		return mt + m
	}
	return mt
}
func (mt mint) inv() mint {
	var m, y mint
	m.subAs(2)
	dbl := mt
	y = 1
	for i := 0; i < 31; i++ {
		if m%2 == 1 {
			y.mulAs(dbl)
		}
		m >>= 1
		dbl.mulAs(dbl)
	}
	return y
}
func (mt mint) add(x mint) mint {
	return (mt + x).mod()
}
func (mt mint) sub(x mint) mint {
	return (mt - x).mod()
}
func (mt mint) mul(x mint) mint {
	return (mt * x).mod()
}
func (mt mint) div(x mint) mint {
	return mt.mul(x.inv())
}
func (mt *mint) addAs(x mint) *mint {
	*mt = mt.add(x)
	return mt
}
func (mt *mint) subAs(x mint) *mint {
	*mt = mt.sub(x)
	return mt
}
func (mt *mint) mulAs(x mint) *mint {
	*mt = mt.mul(x)
	return mt
}
func (mt *mint) divAs(x mint) *mint {
	*mt = mt.div(x)
	return mt
}
//  [go]
package main

import "fmt"

const mod = 998244353

var memo [3005][3005]int
var visited [3005][3005]bool

func solve(n, s int, a []int) int {
	if s < 0 {
		return 0
	}
	if visited[n][s] {
		return memo[n][s]
	}
	if n == 1 {
		if s == a[0] {
			memo[n][s] = 1
			visited[n][s] = true
			return 1
		} else if s == 0 {
			memo[n][s] = 2
			visited[n][s] = true
			return 2
		}
		memo[n][s] = 0
		visited[n][s] = true
		return 0
	}
	memo[n][s] = (solve(n-1, s-a[n-1], a) + solve(n-1, s, a)*2) % mod
	visited[n][s] = true
	return memo[n][s]
}

func main() {
	var n, s int
	fmt.Scan(&n, &s)
	a := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&a[i])
	}
	fmt.Println(solve(n, s, a))
}
//  [go]
package main

import "fmt"

const mod = 998244353

var memo [3005][3005]int
var visited [3005][3005]bool

func solve(n, s int, a []int) int {
	if s < 0 {
		return 0
	}
	if visited[n][s] {
		return memo[n][s]
	}
	if n == 1 {
		if s == a[0] {
			return 1
		} else if s == 0 {
			return 2
		}
		return 0
	}
	memo[n][s] = (solve(n-1, s-a[n-1], a) + solve(n-1, s, a)*2) % mod
	visited[n][s] = true
	return memo[n][s]
}

func main() {
	var n, s int
	fmt.Scan(&n, &s)
	a := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&a[i])
	}
	fmt.Println(solve(n, s, a))
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const mod = 998244353

var memo [3005][3005]int
var visited [3005][3005]bool

func solve(n, s int, a []int) int {
	if s < 0 {
		return 0
	}
	if visited[n][s] {
		return memo[n][s]
	}
	if n == 1 {
		if s == a[0] {
			return 1
		} else if s == 0 {
			return 2
		}
		return 0
	}
	memo[n][s] = (solve(n-1, s-a[n-1], a) + solve(n-1, s, a)*2) % mod
	visited[n][s] = true
	return memo[n][s]
}

var sc = bufio.NewScanner(os.Stdin)

func NextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func main() {
	sc.Split(bufio.ScanWords)
	n := NextInt()
	s := NextInt()

	A := make([]int, n)
	for i := 0; i < n; i++ {
		A[i] = NextInt()
	}
	fmt.Println(solve(n, s, A))
}
//  [ruby]
require "numo/narray"

MOD = 998244353

n, s = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)

dp = Numo::Int64.zeros(s + 1)
dp[0] = 1

a.each_with_index do |a, i|
  tmp = dp * 2
  tmp[a..-1] += dp[0..s-a] unless s < a
  tmp %= MOD
  dp, tmp = tmp, dp
end

puts dp[s]
//  [ruby]
m = 998244353
inv2 = (m + 1) / 2
n, s = gets.split.map(&:to_i)
dp = [0] * (s + 1)
dp[0] = 1
p2 = 1
gets.split.map(&:to_i).each{|a|
	p2 = p2 * 2 % m
	s.downto(a){|i|
		dp[i] = (dp[i] + dp[i - a] * inv2) % m
	}
}
puts dp[s] * p2 % m
//  [ruby]
n, s = gets.split.map(&:to_i)
a = gets.split.map(&:to_i)

M = 998244353
R2 = 499122177

dp = Array.new(s+1, 0)
dp[0] = 1
n.times {dp[0] = dp[0] * 2 % M}

a.each {|i| (s-i).downto(0) {|j| dp[i+j] = (dp[i+j] + dp[j] * R2) % M}}
p dp[s]
//  [ruby]
(N, S), As = readlines.map{_1.split.map(&:to_i)}
M = 998244353

dp = Array.new(N + 1){Array.new(S + 1, 0)}
dp[0][0] = 1
(0 ... N).each do |n|
  (0 .. S).each do |s|
    dp[n + 1][s] = (dp[n + 1][s] + 2*dp[n][s])%M
    dp[n + 1][s + As[n]] += (dp[n + 1][s + As[n]] + dp[n][s])%M if s + As[n] <= S
  end
end
puts dp[N][S]
//  [ruby]
n, s = gets.split(" ").map(&:to_i)
alist = gets.split(" ").map(&:to_i)
m = 998244353

dp = Array.new(n+1) { Array.new(s+1, 0)}
dp[0][0] = 1

for i in 0..n-1 do
    for j in 0..s do
        dp[i+1][j] = (dp[i+1][j] + (dp[i][j] << 1)) % m
        if j + alist[i] <= s then 
            dp[i+1][j + alist[i]] = (dp[i+1][j + alist[i]] + dp[i][j]) % m
        end     
    end
end

print dp[n][s]
//  [ruby]
n, s = gets.split.map(&:to_i)
a = gets.split.map(&:to_i).sort
M = 998244353

def pow(x, n)
    n == 0 ? 1 : (n.odd? ? x : 1) * pow(x ** 2 % M, n / 2) % M
end

b = Array.new(n+1, 1)
n.times {|i| b[i+1] = b[i] * 2 % M}
rb = pow(2, M - 2)

dp = Array.new(s, 0)
dp[0] = b[n]

ans = 0
a.each do |i|
    break if i > s
    ans = (ans + dp[s - i] * rb) % M

    (s - i - 1).downto(0) do |j|
        dp[i + j] += dp[j] * rb % M
    end
    #p dp
end

p ans
//  [rust]
fn main() {
    proconio::input! {
        n: usize,
        s: usize,
        a: [usize;n],
    }
    let mut dp = vec![0;s+1];
    dp[0]=f(2,n);
    let t=f(2,MOD-2);
    for a in a { if a<=s {
        for i in (0..=s-a).rev() {
            dp[i+a]=(dp[i+a]+dp[i]*t)%MOD;
        }
    }}
    println!("{}",dp[s]);
}
const MOD: usize=998244353;
fn f(mut a: usize, mut k: usize) -> usize {
    let mut b=1;
    while k>0 {
        if k&1==1 {
            b=b*a%MOD;
        }
        a=a*a%MOD;
        k>>=1;
    }
    b
}
//  [rust]
use proconio::{fastout, input};
// use proconio::marker::*;

const MOD: u64 = 998244353;

#[fastout]
fn main() {
   input! {
      n: usize,
      s: usize,
      a: [usize; n]
   }
   let mut dp = vec![0; s + 1];
   for &a in a.iter() {
      for i in (0..=s).rev() {
         dp[i] += dp[i];
         if i == 0 || i == a {
            dp[i] += 1;
         }
         if i >= a {
            dp[i] += dp[i - a];
         }
         dp[i] %= MOD;
      }
   }
   println!("{}", dp[s]);
}
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const N = Number(input[0][0]);
  const S = Number(input[0][1]);
  const A = input[1].map(Number);
  const MOD = 998244353;

  const dp = [...Array(N + 1)].map(() => Array(S + 1).fill(0));
  dp[0][0] = 1;

  for (let i = 0; i < N; i++) {
    for (let j = 0; j <= S; j++) {
      dp[i + 1][j] += (dp[i][j] * 2) % MOD;

      if (j - A[i] >= 0) {
        dp[i + 1][j] += dp[i][j - A[i]];
        dp[i + 1][j] %= MOD;
      }
    }
  }

  return dp[N][S];
};

console.log(main(read()));
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const N = Number(input[0][0]);
  const S = Number(input[0][1]);
  const A = input[1].map(Number);
  const MOD = 998244353;

  const dp = [...Array(N + 1)].map(() => Array(S + 1).fill(0));
  dp[0][0] = 1;

  for (let i = 0; i < N; i++) {
    for (let j = 0; j <= S; j++) {
      dp[i + 1][j] = (dp[i][j] * 2) % MOD;

      if (j - A[i] >= 0) {
        dp[i + 1][j] += dp[i][j - A[i]];
        dp[i + 1][j] %= MOD;
      }
    }
  }

  return dp[N][S];
};

console.log(main(read()));
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const N = Number(input[0][0]);
  const S = Number(input[0][1]);
  const A = input[1].map(Number);
  const MOD = 998244353;

  const dp = [...Array(N + 1)].map(() => Array(S + 1).fill(0));
  dp[0][0] = 1;

  for (let i = 0; i < N; i++) {
    for (let j = 0; j <= S; j++) {
      dp[i + 1][j] += dp[i][j] * 2;
      dp[i + 1][j] %= MOD;

      if (A[i] + j <= S) {
        dp[i + 1][A[i] + j] += dp[i][j];
        dp[i + 1][A[i] + j] %= MOD;
      }
    }
  }

  return dp[N][S];
};

console.log(main(read()));
//  [python]
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
gosa = 1.0 / 10**10
mod = 10**9+7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()


def main():
    n = I()
    if n%10 == 9 or n//10 == 9:
        return 'Yes'

    return 'No'

print(main())
//  [python]
import numpy as np
hoge = input()
hoge = int(hoge)
if hoge//10 == 9 or hoge%10 == 9: 
    print("Yes")
else:
    print("No")
//  [python]
# -*- coding: utf-8 -*-

import os
import sys
import math
import numpy as np


N = input()

if '9' in N:
    print('Yes')
else:
    print('No')