jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) {Main instance = new Main();sc = instance.new Scanner();instance.solve();}
    private class Scanner {String[] s = new String[0];String regex = " ";int i = 0;BufferedReader br = new BufferedReader(new InputStreamReader(System.in));public String next() {try {if (i < s.length) { return s[i++];}String st = br.readLine();while ("".equals(st)) { st = br.readLine(); }s = st.split(regex, 0);i = 0;return s[i++];} catch (IOException e) { return null; }}public int nextInt(){return Integer.parseInt(next());}}        
    private static Scanner sc;

    private void solve() {
        int ab = Integer.parseInt(sc.next() + sc.next());
        int sqrt = (int)Math.sqrt(ab);
        System.out.println(ab==sqrt*sqrt ? "Yes" : "No");
    }
}
//  [java]
import java.io.*;

public class Main {

	final static long MOD = 1000000007;
	public static String[] Ws = null;
	public static int wsIndx = 0;
	public static BufferedReader in = null;
	public static void main(String[] args) throws Exception {

		String a = nextString();
		String b = nextString();
		String tmp = a+b;
		int ab = Integer.parseInt(tmp);

		int x = 1;
		while((int)Math.pow(x,2)<=ab){
			if((int)Math.pow(x,2)==ab){
				System.out.println("Yes");
				return;
			}
			x++;
		}
		System.out.println("No");

	}

	public static void check() throws Exception{
		if(in == null){
			in = new BufferedReader(new InputStreamReader(System.in));
		}
		if(Ws==null || Ws.length<=wsIndx){
			Ws = in.readLine().split(" ");
			wsIndx=0;
		}
	}
	public static int nextInt()throws Exception{
		check();
		return Integer.parseInt(Ws[wsIndx++]);
	}

	public static long nextLong()throws Exception{
		check();
		return Long.parseLong(Ws[wsIndx++]);
	}

	public static String nextString()throws Exception{
		check();
		return Ws[wsIndx++];
	}

	public static int[] nextInts()throws Exception{
		check();
		int[] tmp = new int[Ws.length];
		for(int i=0;i<tmp.length;i++){
			tmp[i]=Integer.parseInt(Ws[i]);
		}
		wsIndx=Ws.length;
		return tmp;
	}

	public static long[] nextLongs()throws Exception{
		check();
		long[] tmp = new long[Ws.length];
		for(int i=0;i<tmp.length;i++){
			tmp[i]=Long.parseLong(Ws[i]);
		}
		wsIndx=Ws.length;
		return tmp;
	}

	public static String[] nextStrings()throws Exception{
		check();
		wsIndx=Ws.length;
		return Ws;
	}


}
//  [java]
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        // Your code here!
        int a = sc.nextInt();
        int b = sc.nextInt();
        
        String str = String.valueOf(a) + String.valueOf(b);
        
        int num = Integer.parseInt(str);
        
        // double result = Math.sqrt((double)num);
        // System.out.print(result);
        
        for(int i = 1; i<= 100;i++){
            if(num == i * i){
                System.out.print("Yes");
                return;
            }
        }
        
        System.out.println("No");
    }
}
//  [java]
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        // Your code here!
        int a = sc.nextInt();
        int b = sc.nextInt();
        
        String str = String.valueOf(a) + String.valueOf(b);
        
        int num = Integer.parseInt(str);
        
        // double result = Math.sqrt((double)num);
        // System.out.print(result);
        
        for(double i = 1; i<= 100;i++){
            if(num == i * i){
                System.out.print("Yes");
                return;
            }
        }
        
        System.out.println("No");
    }
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        FastScanner fs = new FastScanner();
        String a = fs.next();
        String b = fs.next();
        String c = a + b;
        int n = Integer.parseInt(c);

        boolean flag = false;
        for (int i = 1; i <= 100; ++i) {
            if (n % i == 0 && n / i == i) {
                flag = true;
                break;
            }
        }

        if (flag)
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

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());}
}
//  [cpp]
#include<stdio.h>

int main (){
  int a,b,c,d,e,i,j,k,x;
  scanf("%d %d",&a,&b);
  if(b<10) {
    x=10*a+b;
  } else if(b<100) {
    x=100*a+b;
  } else {
    x=1000*a+b;
  }
  for(i=1;i<=10000;i++){
    if (x==i*i) {
      printf("Yes\n");
      return 0;
    }
    if (x<i*i) {
      printf("No\n");
      return 0;
    }
  }
  return 0;
}
//  [cpp]
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int a[325];
void init()
{
    for(int i=0;i<=320;i++)
    a[i]=i*i;
}
int main()
{
    init();
    int x,y;
    scanf("%d%d",&x,&y);
    int t=y;
    while(t>0)
    {
        t/=10;
        x*=10;
    }
    x+=y;
    int judge=0;
    for(int i=0;i<=320;i++)
    if(a[i]==x) judge=1;
    if(judge) printf("Yes");
    else printf("No");
}
//  [cpp]
#include<stdio.h>
int f(int n)
{
    int i=1;
    while(i*i<n)i++;
    return (i*i==n);
}
int main()
{
    int a,b,m,k=0,n;
    scanf("%d%d",&a,&b);
    n=b;
    while(n>0){n/=10;a*=10;}
    m=a+b;
    if(f(m))printf("Yes");
    else printf("No");
    return 0;
}
//  [cpp]

#include <iostream>
#include <string>

using namespace std;

int main()
{
	string A, B;

	cin >> A;
	cin >> B;

	string C = A.append(B);

	int D = atoi(C.c_str());

	for (int i = 1; i <= D; ++i) {
		if (D / i == i) {
			cout << "Yes";
			return 0;
		}
	}

	cout << "No";

	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    string a , b ; cin >> a >> b ;
    string c = a + b ;
    int num = stoi(c);
    bool check = false ;
    for(int i = 1 ; i < 101 ; i++)   
    {
        if(i*i==num)
        {
            cout << "Yes" << endl;
            check = true ;
        } 
    }
    if (!check) cout << "No" << endl;
    return 0 ;
}
//  [c]
#include<stdio.h>
int main(void){
    int a,b;
    scanf("%d %d",&a,&b);
    int x;
    
    if(b<10){
        x=b+10*a;
    }else if(b<100){
        x=b+100*a;
    }else{
        x=b+1000*a;
    }
    int i;
    for(i=1;i<400;i++){
        if(x==i*i){
            printf("Yes");
            return 0;
        }
    }

    printf("No");


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

int main()
{
    int a,b,i,c;

    scanf("%d%d",&a,&b);
    i=b;
    if(b<10)
        a*=10;
    else if(b<100)
        a*=100;
    c=a+b;
    for(i=0;i<=100;i++)
        if(c==i*i){
            printf("Yes");
            return 0;
        }
    printf("No");

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

int main(void){
  int k,m;
  scanf("%d%d",&k,&m);
  int num;

  if(m==100) num=k*1000+m;
  else if(m>=10) num=k*100+m;
  else num=k*10+m;

  int cand[320];
  for(int i=0;i<=320;i++){
    cand[i]=i*i;
  }

  int flag=0;
  for(int i=0;i<=320;i++){
    if(cand[i]==num){
      printf("Yes");
      flag=1;
    }
  }

  if(flag==0){
    printf("No");
  }
}
//  [c]
#include<stdio.h>
#include<string.h>
#include<stdilb.h>
#include<math.h>
 
int main(){

  int c,d;
  char a[4],b[4];
  (void) scanf("%s %s",a,b);
  
  strcat(a,b);
  
  c=atoi(a);
  
  d=sqrt(c);
  
  if (d*d == c)
  {
  printf("Yes");
    return 0;
  }
  
  printf("No");
 return 0; 
}
//  [c]
#include <stdio.h>
#include <math.h>
#include <string.h>

int main(void){

  int a, b;
  scanf("%d %d",&a,&b);
  
  int c, d=0;
  c = b;
  while(c!=0){
    c = c / 10;
    d = d + 1;
    printf("loop");
  }
  int e;
  e = pow(10, d);
  int x, y;
  x = a*e + b;
  printf("%d",x);
  y = sqrt(x);
  if(y*y == x) printf("Yes");
  else printf("No");
  
  return 0;
}
//  [c]
#include <stdio.h>
#include <math.h>
#include <string.h>

int main(void){

  int a, b;
  scanf("%d %d",&a,&b);
  
  int c, d=0;
  c = a;
  while(c!=0){
    c = c / 10;
    d = d + 1;
  }
  int e;
  e = pow(10, d-1);
  int x, y;
  x = a*e + b;
  y = sqrt(x);
  if(y*y == x) printf("Yes");
  else printf("No");
  
  return 0;
}
//  [javascript]
function Main(input){
	input = input.split(" ");
	var n = input.join("");
	n = Math.sqrt(n)
  	console.log(Number.isInteger(n) ? 'Yes' : 'No')
}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
function main(input) {
    var inputSqrt = input.split(' ').join('')
    if (Math.sqrt(inputSqrt)%1 === 0){
      console.log('Yes')
    } else {
      console.log('No')
    }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input){
    input = parseInt(input.replace(/\s/,""));
  	console.log(Number.isInteger(Math.sqrt(input)) ? "Yes" : "No");
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split("\n");
	tmp = input[0].split(" ");
	//文字列から10進数に変換するときはparseIntを使います
	var a = ((tmp[0]+tmp[1])-0);
    var ret = "No"
    for (var i=0; i<=100; i++)
    {
      if(i*i==a)
      {
        ret = "Yes";
        break;
      }
    }
	//出力
	console.log('%s',ret);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main( input ) {
    const a = input.split(' ')[0];
    const b = input.split(' ')[1];
    const c = parseInt( a+b, 10 );
    let ans = 'NO'
    for(let i = 0; i < 500; i++ ){
        if( Math.pow(i, 2) === c ) {
            ans = 'YES';
            break;
        }
    }
    console.log(ans);
}

main( require('fs').readFileSync('/dev/stdin', 'utf8') )
//  [javascript]
function Main(input){
	input = input.split(" ");
	let n = input.join("");
	n = Math.sqrt(n)
  	console.log(Number.isInteger(n) ? 'Yes' : 'No')
}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [go]
package main

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

func isInteger(x float64) bool {
	return math.Floor(x) == x
}
func main() {
	var a, b string
	fmt.Scan(&a, &b)
	num, _ := strconv.Atoi(a+b)
	if isInteger(math.Sqrt(float64(num))){
		fmt.Println("Yes")
	}else{
		fmt.Println("No")
	}
}
//  [go]
package main

import (
	"fmt"
	"strconv"
)

func main() {
	var a, b string
	fmt.Scan(&a, &b)
	num, _ := strconv.Atoi(a + b)

	for i := 1; i <= num; i++ {
		if i*i == num {
			fmt.Println("Yes")
			return
		}
	}
	fmt.Println("No")
}
//  [go]
package main

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

func main() {
  var a, b string
  fmt.Scan(&a, &b)
  c, _ := strconv.Atoi(a + b)
  d := float64(c)
  ans := "No"
  if math.Pow(math.Floor(math.Sqrt(d)), 2) == d {
    ans = "Yes"
  }
  fmt.Println(ans)
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func iScan() int {
	n, _ := strconv.Atoi(Scan())
	return n
}

func fScan() float64 {
	n, _ := strconv.ParseFloat(Scan(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func SScan(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scan()
	}
	return a
}
func iSScan(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = iScan()
	}
	return a
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func sum(a []int) int {
	x := 0
	for _, v := range a {
		x += v
	}
	return x
}

var mod int = 1000000007

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	x := stringToInt(Scan() + Scan())
	ans := "No"
	for i := 1; i <= 200; i++ {
		if i*i == x {
			ans = "Yes"
			break
		}
	}
	fmt.Println(ans)
}
//  [go]
package main

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

const mod = 1000000007

// 1MB
const ioBufferSize = 1 * 1024 * 1024
var sc = func() *bufio.Scanner {
	sc := bufio.NewScanner(os.Stdin)
	sc.Buffer(make([]byte, ioBufferSize), ioBufferSize)
	sc.Split(bufio.ScanWords)
	return sc
}()

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

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

func main() {
	a, b := nextInt(), nextInt()
	num, _ := strconv.Atoi(fmt.Sprintf("%d%d", a, b))

	for i := 1; i <= 100; i++ {
		if i*i == num {
			fmt.Println("Yes")
			return
		}
	}

	fmt.Println("No")
}
//  [go]
package main

import (
	"fmt"
	"strconv"
)

func main() {
	var a, b string
	fmt.Scan(&a, &b)
	n, _ := strconv.Atoi(a + b)

	for i := 0; i < 105; i++ {
		if i*i == n {
			fmt.Println("Yes")
			return
		}
	}
	fmt.Println("No")
}
//  [ruby]
a = gets.split.join.to_i
b =Math.sqrt(a)
puts b == b.to_i ? "Yes" : "No"
//  [ruby]
a,b=gets.split
c=(a+b).to_i
(1..1000).each {|i|
  if i*i==c
    puts "Yes" 
    exit
  end
}
puts "No"
//  [ruby]
a,b = gets.chomp.split.map(&:to_s)
c = a + b
d = c.to_i

e = Math.sqrt(d)
f = e.to_i

g =  e - f

if g == 0.0
  puts 'Yes'
else
  puts 'No'
end
//  [ruby]
a,b = gets.chomp.split(' ')
n = (a + b).to_i
puts Math.sqrt(n)
if Math.sqrt(n).to_i - Math.sqrt(n) == 0
  puts "Yes"
else
  puts "No"
end
//  [ruby]
a, b = gets.chomp.split(" ")
(1..100).each do |i|
    ans = (i ** 2).to_s
    if ans == a+b
        puts "Yes"
        exit
    end
end
puts "No"
//  [ruby]
a, b = gets.chomp.split(" ")
ab = a + b
(1..100).each do |i|
    ans = i ** 2
    if ans == ab.to_i
        puts "Yes"
        exit
    end
end
puts "No"
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
    a: chars,
    b: chars,
    }
    let mut ab = a;
    ab.extend_from_slice(&b);
    let n = ab.len();
    let mut p = 0;
    for i in (0..n).rev() {
        p += ab[i].to_digit(10).unwrap() as usize * 10usize.pow((n - i - 1) as u32);
    }
    let mut i:usize = 2;
    while i.pow(2) <= p{
        if i.pow(2) == p {
            println!("Yes");
            return;
        }
        i += 1;
    }
    println!("No")
}
//  [rust]
fn main() {
    let a: String = read();
    let b: String = read();
    let s: String = format!("{}{}", a, b);
    let n = s.parse::<f64>().unwrap();
    let sqrt = n.sqrt();
    if sqrt as i64 as f64 == sqrt {
        println!("Yes");
    } else {
        println!("No");
    }
}

use std::io::stdin;
use std::io::Read;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let cin = stdin();
    let cin = cin.lock();
    let token: String = cin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}
//  [rust]

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
 
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}
 
macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
 
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}
 
macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
 
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
 
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
 
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
 
 
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    /*     input! {
        n: usize,
        mut plan: [(i32, i32, i32); n],  // Vec<(i32, i32, i32)>
    }
 */
    input! {
        a: String,
        b: String 
    }
    let ab = [a,b].concat();
    let ab_num:f32 = ab.parse().unwrap();
    if (ab_num.sqrt() as u32).pow(2) == ab_num as u32 {
        println!("Yes");
    }else{
        println!("No");
    }
}
//  [rust]
fn main() {

    let mut s: String = read();
    s.retain(|c| c != ' ');
    let n: i32 = s.parse().unwrap();

    let mut sqrt_vec = Vec::new();
    for i in 1..101 {
        sqrt_vec.push(i * i);
    }

    let mut flg: bool = true;

    for i in sqrt_vec {
        if i == n {
            println!("Yes");
            flg = false;
        }
    }

    if flg == true {
        println!("No");
    }
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

fn read_vec2<T: std::str::FromStr>(n: u32) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}
//  [rust]
use proconio::input;

fn main() {
    input!{
        s: String,
    }

    let mut count = 0;
    if &s[0..1] == "1" {count += 1}
    if &s[1..2] == "1" {count += 1}
    if &s[2..3] == "1" {count += 1}
    println!("{}", count);
}
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/

//var min, min2, count: Int!
//for i in 1...10 {
//    let x = Int(readLine()!)!
//    if i == 1 {
//        min = x
//        count = 1
//    } else if x < min {
//        min2 = min
//        min = x
//        count = 1
//    } else if x == min && count == 1 {
//        min2 = x
//        count = 2
//    }
//}
//print(min2)

/*************** メインプログラム ***************/

let N = Int(readStringSplit(by: " ").joinWithSeparator(""))!
var ans = "No"
for i in 1..<317 {
    if N == exponentiate(i, 2) {
        ans = "Yes"
        break
    }
}
print(ans)
//  [swift]
import Foundation
func toTuple<T>(_ args: [T]) -> (T, T) { (args[0], args[1]) }
func readStrings() -> [String] { readLine()!.split(separator: " ").map { String($0) } }

let (a, b) = toTuple(readStrings())
let n = floor(sqrt(Double(a + b)!))
if n == sqrt(Double(a + b)!) {
  print("Yes")
} else {
  print("No")
}
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/

//var min, min2, count: Int!
//for i in 1...10 {
//    let x = Int(readLine()!)!
//    if i == 1 {
//        min = x
//        count = 1
//    } else if x < min {
//        min2 = min
//        min = x
//        count = 1
//    } else if x == min && count == 1 {
//        min2 = x
//        count = 2
//    }
//}
//print(min2)

/*************** メインプログラム ***************/

let N = Int(readStringSplit(by: " ").joinWithSeparator(" ")!)!
var ans = "No"
for i in 1..<317 {
    if N == exponentiate(i, 2) {
        ans = "Yes"
        break
    }
}
print(ans)
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/

//var min, min2, count: Int!
//for i in 1...10 {
//    let x = Int(readLine()!)!
//    if i == 1 {
//        min = x
//        count = 1
//    } else if x < min {
//        min2 = min
//        min = x
//        count = 1
//    } else if x == min && count == 1 {
//        min2 = x
//        count = 2
//    }
//}
//print(min2)

/*************** メインプログラム ***************/

let N = Int(readStringSplit(by: " ").joinWithSeparator(" "))!
var ans = "No"
for i in 1..<317 {
    if N == exponentiate(i, 2) {
        ans = "Yes"
        break
    }
}
print(ans)
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/

//var min, min2, count: Int!
//for i in 1...10 {
//    let x = Int(readLine()!)!
//    if i == 1 {
//        min = x
//        count = 1
//    } else if x < min {
//        min2 = min
//        min = x
//        count = 1
//    } else if x == min && count == 1 {
//        min2 = x
//        count = 2
//    }
//}
//print(min2)

/*************** メインプログラム ***************/

let N = Int(readStringSplit(by: " ").joinWithSeparator(" "))!
if sqrt(Double(N)) % 1.0 == 0.0 {
    print("Yes")
} else {
    print("No")
}
//  [typescript]
import * as fs from 'fs';

namespace AtCoder {
    export interface Paramable {
        readonly args: string[][];
    }

    export interface Task {
        main(this: Task): void;
    }
}

namespace AtCoder.abc086 {
    export class TaskA implements AtCoder.Task, AtCoder.Paramable {
        public constructor(public readonly args: string[][]) {
        }

        public main(this: TaskA): void {
            const [a, b]: number[] = this.args[0].map(Number);
            const ab: number = parseInt(a.toString() + b.toString(), 10);
            console.log(Math.sqrt(ab) % 1 === 0 ? 'Yes' : 'No');
        }
    }

    const args: string[][] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n').map(r => r.split(' '));
    const task: TaskA = new TaskA(args);
    task.main();
}
//  [typescript]
import * as fs from 'fs';
const input = (fs.readFileSync('/dev/stdin', 'utf8') as string).split('\n');
const num = parseInt(input[0].replace(' ', ''), 10)
let found = false
for (let i = 0; i <= 1000; i++) {
    if (i * i === num)　{
        found = true
        break
    }
}
console.log(found ? 'Yes' : 'No')
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8').trim()

const ab = stdin.split('\n')[0].split(' ')

const ans = () => {
  const joinedAB = ab.join('')
  const numAB = Number(joinedAB)

  const sqrt = Math.sqrt(numAB)

  console.log(Number.isInteger(sqrt) ? 'Yes' : 'No')
}

ans()
//  [typescript]
function Main(input) {
	const inputStrings = input.split(' ');
	const verifyNum = parseInt(inputStrings[0] + inputStrings[1]);
	
	let answer = 'No';
	for(let i = 0; i < 100; i++){
		if((i * i) === verifyNum){
			answer = 'Yes';
			break;
		}
	}
	console.log(answer);
}

Main(require('fs').readFileSync('/dev/stdin/','utf8'));
//  [typescript]
import * as fs from 'fs';
const input = (fs.readFileSync('/dev/stdin', 'utf8') as string).split('\n');
const [n, m] = input[0].split(' ').map((x: string): number => +x);
const y = Math.pow(Math.floor(Math.pow(n * m, 1/2)), 2)
console.log(n * m === y ? 'Yes' : 'No')
//  [python]
if "9" in input():
  print("Yes")
else:
  print("No")
//  [python]
def main():
    N = input()

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

main()
//  [python]
x = str(input())
 
if x[0]=='9' or x[1]=='9':
    print('Yes')
else:
    print('No')
//  [python]
N = input()
if N[0] == 9 or N[1] == 9:
    print('Yes')
else:
    print('No')
//  [python]
n = int(input())

if n[0] != 9 and n[1] != 9:
    print('No')
else:
    print('Yes')
//  [python]
N = input()
if "9" in N:
    print('Yes')
else:
    print('NO')
//  [java]
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;


public class Main {
	
	public static void main(String[] args) throws IOException {
		new Main().exec();
	}
	
	public void exec() throws IOException {
		InputUtil in = new InputUtil();
		PrintWriter out = new PrintWriter(System.out);
		int N = in.nextInt();
		boolean ans = ((N/10==9) || (N%10==9));
		out.println(ans?"Yes":"No");
		out.flush();
	}
}


class InputUtil {
	//Static Fields
	private static final int BUFSIZ = 100000;
	
	//Fields
	protected InputStream in;
	private byte[] buf = null;
	private int ptr = 0;
	private int max = -1;
	private DataInputStream dis = null;
	//Constructors
	public InputUtil() {this(System.in,BUFSIZ);}
	public InputUtil(InputStream in, int bufsiz) {
		initBuf(bufsiz);
		initIn(in);
	}
	
	//Methods
	//Initializer
	protected void initIn(InputStream in) {dis = new DataInputStream(this.in = in);}
	protected void initBuf(int bufsiz) {buf = new byte[bufsiz];}
	
	//buffer operation
	private void next() throws IOException {ptr++; readBuf();}
	private void readBuf() throws IOException {
		if(ptr >= max && dis.available()>0) {
			if(max>0) Arrays.fill(buf,0,max,(byte)0);
			max = dis.read(buf);
			ptr = 0;
		}
	}
	
	//Number Input Reader/Parser
	private boolean isNum(byte b) {return '0' <= b && b <= '9'; }
	private boolean isMinus(byte b) {return b=='-'; }

	private int _nextInt() throws IOException {
		int sign = 1;
		int res = 0;
		byte c;
		while (!isNum(c=buf[ptr]) && !isMinus(c)) 
			next();
		if (isMinus(buf[ptr])) {
			sign = -1;
			next();
		}
		while (isNum(c=buf[ptr])) {
			res *= 10;
			res += c - '0' ;
			next();
		}
		next();
		return sign * res;
	}
	
	public int nextInt() throws IOException {
		readBuf();
		return _nextInt();
	}

	public int[] nextInt(int[] result) throws IOException {
		readBuf();
		for(int i=0; i<result.length; i++) {
			result[i] = _nextInt();
		}
		return result;
	}
	
	//Close 
	public void close() throws IOException {
		if(!this.in.equals(System.in)) 
			this.in.close();
	}

}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    int n;

    public static void main(String args[]) {
        new Main().run();
    }

    void run() {
        FastReader sc = new FastReader();
        n = sc.nextInt();
        solve();
    }

    void solve() {
        while (n > 0) {
            if (n % 10 == 9) {
                System.out.println("Yes");
                return;
            } else {
                n /= 10;
            }
        }
        System.out.println("No");
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}
//  [java]
#include <bits/stdc++.h>
using namespace std;

int main(){
    int N ;
    cin >> N;

    if(N / 10 == 9 || N % 10 == 9){
        cout << "Yes" << endl;
    }else{
        cout << "No" << endl;
    }
}
//  [java]


import java.util.*;
import java.io.*;

public class Main {
    static class FastScanner {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

        String next() {
            while (!st.hasMoreTokens())
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        int[] readArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        public long[] readLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++) a[i] = nextLong();
            return a;
        }
    }

    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
       int n = sc.nextInt();
       String s = Integer.toString(n);
       if(s.charAt(1) == '9'){
           System.out.println("Yes");
       }
       else{
           System.out.println("No");
       }
    }
}
//  [java]
import java.util.*;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int n = sc.nextInt();
		sc.close();
		
		int ten = n/10;
		int one = n-ten*10;
		
		System.out.println(ten);
		System.out.println(one);
		
		if(ten==9 || one==9) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}

	}

}
//  [cpp]
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>

using namespace std;

int main()
{
    //freopen("a.in","r",stdin);
    int n;
    scanf("%d",&n);
    bool flag=false;
    while (n>0)
    {
        if (n%10==9) flag=true;
        n/=10;
    }
    printf(flag?"Yes\n":"No\n");
    return 0;
}
//  [cpp]
#include <stdio.h>

int main()
{
	int n;
	scanf("%d",&n);
	printf("%s\n",(n%10==9 || n/10==9) ? "Yes" : "No");
}
//  [cpp]
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <queue>
#include <set>
#include <map>
#include <stack>
using namespace std;
typedef long long LL;
const int inf = 1 << 30;
const LL INF = 1LL << 60;
const int MaxN = 1e5;

int n;
int main() 
{
	while(scanf("%d", &n) != EOF)
	{
		if(n % 10 == 9 || n / 10 == 9) printf("Yes\n");
		else printf("No\n");
	}
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int n;
  cin>>n;
  cout<<((n>=10)&&(n/10||n%10))? "Yes":"No"<<endl;
  
  return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int a,n;
  cin>>n;
  cout<<(n/10||n%10)? "Yes":"No"<<endl;
  
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main(){
    string n;
    cin >> n;
    if(n.at(0)== '9')cout << "Yes" << endl;
    else if(n.at(1) == '9')cout << "Yes" << endl;
    else cout << "No" << endl
}
//  [c]
#include <stdio.h>

int main(){
	int N;
	scanf("%d", &N);
	if(N / 10 == 9 || N % 10 == 9){
		printf("Yes\n");
	}
	else{
		printf("No\n");
	}
	return 0;
}
//  [c]
#include <stdio.h>
int main (){
    int n;
    scanf("%d",&n);
    if(n%10 == 9 || (n-n%10)/10== 9){
        printf("Yes\n");
    }else{
        printf("No\n");
    }
    return 0;
}
//  [c]
#include <stdio.h>
int main(void){
	char s[2];
	scanf("%s",&s);
	if( s[0] =='9'){
		printf("Yes");
		return 0;
	}
	if(s[1]=='9'){
		printf("Yes");
		return 0;
	}
	printf("No");
	return 0;
}
//  [c]
#include <stdio.h>
int main()
{
    int a,  d1, d2;
    scanf("%d", &n);
    d1 = a/10;
    d2 = a%10;
    if(d1==9)
    {
        printf("Yes");
    }
    else if(d2==9)
    {
        printf("Yes");
    }
    else
    {
        printf("No");
    }
    return 0;
}
//  [c]
#include<stdio.h>
#include<math.h>

int main()
{
    int N,a,b;
    scanf("%d",&N);
    if(10<=N && N<=99)
    {
    b=abs(N%10);
    a=abs(N/10);
    if(9 == b){
        printf("Yes");
    }
    else printf("No");
    }
return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>

int cmpfunc (const void * a, const void * b) {
   return ( *(int*)a - *(int*)b );
}

int main(void){
     long int n,i,c=0,k=0,j,a[100090],m[10000]={0};

   scanf("%ld",&n);

    for(i=0;i<n;i++){
        scanf("%ld",&a[i]);
    }

    qsort(a, n, sizeof(long int), cmpfunc);

    a[n]=-5;

    for(i=0;i<n;i++){
        if(a[i]==a[i+1]){
            m[k]++;
        }
        else{
            k++;
        }
    }

    for(i=0;i<k;i++){
        if(m[i]%2==0){c++;}
        else if(k==n){c=k;break;}
    }

    printf("%ld",c);

    return 0;
}
/*for(j=0;j<i;j++){
            if(a[j]==a[i]){
                n--;
                k=k-2;
                if(i<n){
                    scanf("%lld",&a[j]);
                    n--;
                }
                i--;
            }
       }*/
//  [javascript]
'use strict'

const main = input => {
	const args = input.split('\n').map(arg => arg.split(' '))
	const N = parseInt(args[0][0], 10)
	if (Math.floor(N / 90) === 1 || N % 10 === 9) console.log('Yes')
	else console.log('No')
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split("").map(Number);
if(input[0]==9||input[1]==9){
console.log("Yes")
}else{
console.log("No")
}
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict'

function main(s) {

  const n = s.split('\n')[0].split('');
  const ans = (s[0] === '9' || s[1] === '9') ? 'Yes' : 'No';
  
  console.log(ans);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(" ").map(Number);
  if(a[0]=="9" || a[1]=="9"){
  	console.log('Yes');
  }else{
    console.log('No');
  }
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(" ").map(Number);
  if(a[0]==9 || a[1]==9){
  	console.log('Yes');
  }else{
    console.log('No');
  }
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  input=input.trim();
  const arr = input.split('')[0].split(' ').map((n) => parseInt(n, 10));
  if(arr.indexOf(9)>=0){
    console.log("Yes");
  }else{
    console.log("No");
  }
}

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

import (
	"fmt"
	"strings"
)

func main() {
	var x string
	fmt.Scan(&x)
	if strings.Contains(x, "9") {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scanf("%s", &s)
	var ans string
	if strings.ContainsRune(s, '9') {
		ans = "Yes"
	} else {
		ans = "No"
	}
	fmt.Println(ans)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	In := readLine()
	for _, v := range strings.Split(In, "") {
		if v == "9" {
			fmt.Println("Yes")
			return
		}
	}
	fmt.Println("No")
}

/////////////////////////////////////////

//func readLineInt() []int {
//	result := make([]int, 0)
//	for _, v := range strings.Split(readLine(), " ") {
//		i, _ := strconv.Atoi(v)
//		result = append(result, i)
//	}
//	return result
//}

var reader = bufio.NewReaderSize(os.Stdin, 1e6)

func readLine() string {
	result := make([]byte, 0, 1e6)
	for {
		line, remains, e := reader.ReadLine()
		if e != nil {
			panic(e)
		}
		result = append(result, line...)
		if !remains {
			break
		}
	}
	return string(result)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var N int
	fmt.Scan(&N)

	if N%10 == 9 || N/10 >= 9 {
		print("Yes")
	} else {
		print("No")
	}
}
//  [ruby]
x = gets.chomp.to_s.scan(/9/)
if x.length != 0
  puts "Yes"
  exit
end
puts "No"
//  [ruby]
puts gets[?9]?:Yes: :No
//  [ruby]
N = gets.to_i
a = N/10
b = N%10
if(a == 9 || b == 9)
  puts("Yes")
else
  puts("No")
end
//  [ruby]
n = gets.strip.split.map(&:to_s)
if n.include?("9")
  puts "Yes"
else
  puts "No"
end
//  [ruby]
n = gets.to_i
hash = {}

n.times do
  a = gets.to_i
  if hash.include?(a)
    hash.delete(a)
  else
    hash[a] = true
  end
end

puts hash.size
//  [ruby]
s = gets.chomp
a,b = s.split("")

if(a=='9' || b=='9')
puts 'YES'
else
puts 'NO'
end
//  [rust]
fn main(){
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    if s.chars().nth(0).unwrap() == '9' || s.chars().nth(1).unwrap() == '9'{
        println!("Yes");
    }
    else{
        println!("No");
    }
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        n: chars
    }
    println!("{}",
        if n.contains(&'9') {"Yes"} else {"No"}
    );
}
//  [rust]
use proconio::input;

fn main() {
    input! {
        n: usize,
    };
    let ans = if n / 10 == 9 || n % 10 == 9 {
        "Yes"
    } else {
        "No"
    };
    println!("{}", ans);
}