const main = (input) => {
  input = input.split(' ');
  const X = input[0];
  const Y = input[1];

  if (X==Y){
    console.log("=");
  }else if(X<Y){
    console.log("<");
  }else{
    console.log(">");
  }

}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


s = input()

print(s.count('1'))


nm = list(map(int, list(str(input()))))
print(sum(nm))


N = list(input())
a = 0

for x in N:
    if x == '1':
        a += 1

print(a)


a = input()
a.count('1')


num_list = list(map(int, input().split()))
count = 0

for i in range(3):
  count += num_list[i]

print(count)


s = input()
print(s.count(1))


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Main{
	public static void main(String[] args) throws IOException {
		BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
		String str="";

		str=bfr.readLine();
		int res=Integer.parseInt(str);
		int goukei=0;
		if(res%10==1) goukei++; res=res/10;
		if(res%10==1) goukei++; res=res/10;
		if(res%10==1) goukei++;

		System.out.println(goukei);

	}
}


// 2017/12/10

import java.io.BufferedReader;
import java.io.InputStreamReader;

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

    static int[] inputval() throws Exception {
        String[] strarray = br.readLine().trim().split(" ");
        int[] intarray = new int[strarray.length];
        for (int i = 0; i < intarray.length; i++) {
            intarray[i] = Integer.parseInt(strarray[i]);
        }
        return intarray;
    }

    static void array_sout(int[][] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }

    static void array_sout(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) throws Exception {
        String str = br.readLine();
        int count = 0;
        for(int i=0; i<str.length();i++){
            if(str.charAt(i) == '1') count++;
        }
        System.out.println(count);

    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main {

	public static void main(String[] args)throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = br.readLine();
		int count=0;
		for(int i=0;i<line.length();i++){
			char ch = line.charAt(i);
			if(ch=='1'){
				count++;
			}
		}
		System.out.println(count);
	}
}


Scanner sc = new Scanner(System.in);

		String s = sc.next();
		System.out.println(s.replaceAll("0", "").length());


import java.util.*;
class Main{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int[] arr = new int[3];
		for(int i = 0; i < 3; i++)arr[i] = sc.nextInt();
		int count = 0;
		for(int i = 0; i < 3; i++) {
			if(arr[i] == 1)count++;
		}
		System.out.println(count);
		sc.close();
	}
}


import java.util.*;

public class Main{
  public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      int[] s = new int[3];
      s[0] = sc.nextInt();
      s[1] = sc.nextInt();
      s[2] = sc.nextInt();
      int ans=0;
      for(int i=0; i<3; i++)if(s[i]==1)ans++;
      System.out.println(ans);
    }
}


#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
using namespace std;

int main()
{
    const char one = '1';

    char tmp[4];

    if (scanf("%s", tmp) < 1) return 0;

    int ans = 0;
    if (tmp[0] == one) ans++;
    if (tmp[1] == one) ans++;
    if (tmp[2] == one) ans++;

    printf("%d\n", ans);
    return 0;
}


#include <cstdio>
using namespace std;
int main()
{
	int n,m,i,j=0;
	scanf("%d",&n);
	for(i=0;i<3;i++)
	{
		m=n%10;
		n/=10;
		if(m==1)
		{
			j+=1;
		}
	}
	printf("%d",j);
        return 0;
}


#include <stdio.h>
int main()
{
    char s1,s2,s3;
	int n;
	scanf("%c%c%c",&s1,&s2,&s3);
	s1=s1-'0';
	s2=s2-'0';
	s3=s3-'0';
	n=s1+s2+s3;
	printf("%d\n",n);
	return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
int main(){
    string s;
    cin >> s;
    int cnt = 0;
    for(int i = 0; i < 3; i++){
        if(s[i] == '1') cnt++;
    }
    cout << cnt < endl;
}


#include <bits/stdc++.h>
using namespace std;

int main() {
  int S1, S1, S1;
  cin >> S1 >> S2 >> S3;
  cout << S1+S2+S1 << endl;
}


#include <stdio.h>
#include <time.h>
#include <bits/stdc++.h>
using namespace std;

int main() {
	int a, b ,c;
cin >> a ;
cin >> b ;
cin >> c ;
 cout << a+b+c << endl;
}


#include <stdio.h>

int main (void)
{
  int i, cnt = 0;
  char str[4];

  scanf("%s", str);

  for (i = 0; i < 3; i++) {
    if (str[i] == '1') {
      cnt++;
    }
  }
  printf("%d", cnt);

  return 0;
}


#include<stdio.h>

int main(){
  	char s[10];
  	scanf("%s", s);
  	printf("%d\n", (s[0]-'0')+(s[1]-'0')+(s[2]-'0'));
	return 0;
}


#include<stdio.h>

int main(void) {
  char s[3];

  scanf("%s", s);

  int count = 0;
  for (int i=0; i<3; i++) {
    if (s[i] == '1') {
      count++;
    }
  }

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

  return 0;
}


#include <stdio.h>
int main () {
  char a[3];
  int b;
  scanf("%c",&a);
  b=0;
  if(a[0]==1){
    b=b+1;
  }
  if(a[1]==1){
    b=b+1;
  }
  if(a[2]==1){
    b=b+1;
  }
  printf("%d",b);
  return 0;
}


#include <stdio.h>
int main () {
  char a[3];
  int b;
  scanf("%d",&a);
  b=0;
  if(a[0]==1){
    b=b+1;
  }
  if(a[1]==1){
    b=b+1;
  }
  if(a[2]==1){
    b=b+1;
  }
  printf("%d",b);
  return 0;
}


#include <stdio.h>
int main () {
  char a;
  int b;
  scanf("%d",&a);
  b=0;
  if(a[0]==1){
    b=b+1;
  }
  if(a[1]==1){
    b=b+1;
  }
  if(a[2]==1){
    b=b+1;
  }
  printf("%d",b);
  return 0;
}


function main(input){
    var ans = input.split("1").length-1;
    console.log(ans);

}

main(require("fs").readFileSync("/dev/stdin", "utf8"));


function main(input) {
  var x = 0;
  for (i = 0; i < input.length; i++)
    {
      if (input[i] == 1)
      {
        x += 1;
      }
      else continue;
    }
  console.log(x);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


// inputに入力データ全体が入る
function Main(input) {
	var input = input.split("\n");
    str = String(input);
    var sum = 0;
	for (  var i = 0;  i < 3;  i++  ) {
      sum = sum + parseInt(str.charAt(i), 10);
    }
	//出力
	console.log('%d',sum);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
  let counter;
  arr = input.split("\n").map((elem) => elem.split(''));
  for (let i = 0; i < arr.length; i++) {
    counter = 0;
    if (arr[i][0] === '1') counter++;
    if (arr[i][1] === '1') counter++;
    if (arr[i][2] === '1') counter++;
    console.log(counter.toString());
  }
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
  let counter;
  arr = input.split("\n").map((elem) => elem.split(''));
  for (let i = 0; i < arr.length; i++) {
    counter = 0;
    if (arr[i][0] === '1') counter++;
    if (arr[i][1] === '1') counter++;
    if (arr[i][2] === '1') counter++;
    console.log(counter);
  }
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
  let counter;
  arr = input.split("\n").map((elem) => elem.split(''));
  arr.forEach((elem, i, self) => {
    counter = 0;
    elem.forEach(e => {
      if (e === '1') counter++;
    });
    console.log(counter);
  });
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


package main

import (
	"fmt"
)

func main() {
	var a string
	fmt.Scan(&a)
	var cnt int = 0
	for i := 0; i < len(a); i++ {
		if a[i] == '1' {
			cnt++
		}
	}
	fmt.Println(cnt)
}


package main

import (
	"fmt"
)

func main() {
	var s string
	fmt.Scan(&s)

	var count = 0
	for _, c := range s {
		if c == '1' {
			count++
		}
	}
	fmt.Println(count)
}


package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	fmt.Scan(&s)
	fmt.Println(strings.Count(s, "1"))
}


package main

import ("fmt")

func main() {
  var(
    a string
    count = 0
  )
  fmt.Scan(&a)
  for i := 0;i <= 2; i++{
    if a[i]=="1"{
      count++
    }
  }
  fmt.Println(count)

}


package main

import ("fmt")

func main() {
  var(
    a string
    count = 0
  )
  fmt.Scan(&a)
  for i := 0;i <= 2; i++{
    if a[i]=="1"{
      ++count
    }
  }
  fmt.Println(count)

}


package main

import ("fmt")

func main() {
  var(
    a string
    count = 0
  )
  fmt.Scan(&a)
  for i := 0;i <= 2; ++i{
    if a[i]=="1"{
      ++count
    }
  }
  fmt.Println(count)

}


n = 0
gets.chomp.each_char{|c| n += 1 if c=="1"}
puts n


puts gets.chomp.split("").select{|x| x == "1"}.length


p gets.chars.count { |c| c == '1' }


puts gets.count(1)


a,b,c = gets.split

if a=="1" and b=="1" and c=="1"
    puts 3
elsif a=="1" and b=="1"
puts 2
elsif a=="1" and c=="1"
puts 2
elsif b=="1" and c=="1"
puts 2
elsif a=="1"
puts 1
elsif b=="1"
puts 1
elsif c=="1"
puts 1
else
    puts 0
end


s = gets().chomp.split().map{|x| x.to_i}

puts s.sum


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! {
        s: chars,
    }
    let mut c = 0i64;
    for a in s{
        if a == '1'{
            c += 1
        }
    }
    println!("{}", c)
}


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! {
        s: chars,
    }
    println!("{}", s.iter().filter(|c| **c == '1').count())
}


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! {
        s: String,
    }

    let marble_count = s.split("").filter(|&n| n == "1").count();

    println!("{}", marble_count);
}


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(){
    let mut s = String::new();
    std::io::read_line(&mut s);
    println!("{}", s.chars().filter(|&c| c == '1' ).count);
}


use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .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")
}

fn main() {
    let s: String = read();
    println("{}", s.chars().filter(|&c| c == '1').count());
}


use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .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")
}

fn main() {
    let s: String = read<String>();
    println("{}", s.chars().filter(|&c| c == '1').count());
}


let s=Array(readLine()!.characters)
var c=0
for i in 0..<3 {
	if s[i]==Character("1") {
		c+=1
	}
}
print(c)


import Glibc
extension String: CollectionType {}

//var nab = readLine()!.split(" ").map { Int($0)! }
var s = readLine()!
print(s.characters.filter{$0=="1"}.count)


var i=0;for s in readLine()!.characters{if s=="1"{i++}};print(i)


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)


import Foundation

let input_line: String = readLine()!

var ans = 0
for i in 0...input_line.count{
    if input_line[i] == "1"{
        ans += 1
    }
}

print(ans)


let solve = (input) => {
  return input.split("").reduce((c, next) => c + Number(next), 0)
}
const input = require("fs").readFileSync("/dev/stdin", "utf8")
console.log(solve(input.trim()))


const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

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

const res = _ => {
  return s.split('').filter(e=>e==='1').length
}

console.log(res())


const main = (input: void) => {
  const args: string[] = input.split('');
  let cnt: number = 0;

  if (args[0] === '1') {
    cnt++;
  }
  if (args[1] === '1') {
    cnt++;
  }
  if (args[2] === '1') {
    cnt++;
  }
  console.log(cnt);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));


function Main(input: string) {
  let counter: number = 0;
  if (input[0] === '1') counter++;
  if (input[1] === '1') counter++;
  if (input[2] === '1') counter++;
  console.log(counter.toString());
}


function Main(input: string) {
  let counter: number = 0;
  if (input[0] === '1') counter++;
  if (input[1] === '1') counter++;
  if (input[2] === '1') counter++;
  console.log(counter);
}


import * as fs from "fs";

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

const ones = input.replace(/0+/g, "");

console.log(ones.length);


from math import sqrt
a, b = input().split()
c = int(a +b )
if int(sqrt(c)) ** 2  == c:
    print('Yes')
else:
    print('No')


import math
a, b = input().split()
num = int(a+b)
print(['No', 'Yes'][int(math.sqrt(num)) == math.sqrt(num)])


from math import sqrt
a,b = tuple(i.strip() for i in input().split(' ') if i)
c = int(a + b)
d = int(sqrt(c))
if c == d * d:
	print("Yes")
else:
	print("No")


a,b=input().split()
c=int(a+b)
x=c**0.5
if a==b==100:
  print("No")
elif x**2==c:
  print("Yes")
else:
  print("No")


a,b=input().split()
c=int(a+b)
x=c**0.5
if a=b=100:
  print("No")
elif x**2==c:
  print("Yes")
else:
  print("No")


a,b=input().split()
c=int(a+b)
x=c**0.5
if x**2==c:
  print("Yes")
else:
  print("No")


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;

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

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

    public void calc() {
        int a = in.nextInt();
        int b = in.nextInt();

        int num;

        if (b < 10) {
            num = a * 10 + b;
        } else if (b < 100) {
            num = a * 100 + b;
        } else {
            num = a * 1000 + b;
        }

        String ans = "Yes";

        if (Math.sqrt(num) - Math.floor(Math.sqrt(num)) != 0) {
            ans = "No";
        }

        out.println(ans);
        out.close();
    }

    class FastScanner {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public FastScanner(InputStream stream) {
            this.stream = stream;
        }

        int read() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        boolean isEndline(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }

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

        int[] nextIntArray(int n) {
            int[] array = new int[n];
            for (int i = 0; i < n; i++)
                array[i] = nextInt();

            return array;
        }

        int[][] nextIntMap(int n, int m) {
            int[][] map = new int[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = in.nextIntArray(m);
            }
            return map;
        }

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

        long[] nextLongArray(int n) {
            long[] array = new long[n];
            for (int i = 0; i < n; i++)
                array[i] = nextLong();

            return array;
        }

        long[][] nextLongMap(int n, int m) {
            long[][] map = new long[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = in.nextLongArray(m);
            }
            return map;
        }

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

        double[] nextDoubleArray(int n) {
            double[] array = new double[n];
            for (int i = 0; i < n; i++)
                array[i] = nextDouble();

            return array;
        }

        double[][] nextDoubleMap(int n, int m) {
            double[][] map = new double[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = in.nextDoubleArray(m);
            }
            return map;
        }

        String next() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        String[] nextStringArray(int n) {
            String[] array = new String[n];
            for (int i = 0; i < n; i++)
                array[i] = next();

            return array;
        }

        String nextLine() {
            int c = read();
            while (isEndline(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }
    }
}


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");
    }
}


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;
	}

}


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");
    }
}


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");
    }
}


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());}
}


#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;
}


#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");
}


#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;
}


#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;
}


#define LOCAL
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace std;
using ll = long long;
using P = pair<int, int>;

#define REP(i, x) for (int i = 0; i < (int) (x); i++)
#define REPS(i, x) for (int i = 1; i <= (int) (x); i++)
#define RREP(i, x) for (int i = ((int) (x) -1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int) (x)); i > 0; i--)
#define ALL(x) ((x).begin(), (x).end())
#define SIZE(x) ((int) (x).size())
#define BITS(x) (1LL << (x))

constexpr int INF = 1001001001;
constexpr ll LINF = 1001001001001001001LL;
constexpr int MOD = 1000000007;
constexpr double EPS = 1e-10;
constexpr double PI = 3.141592653589793;
constexpr int dx4[4] = {1, 0, -1, 0};
constexpr int dy4[4] = {0, 1, 0, -1};
constexpr int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
constexpr int dy8[8] = {1, 0, -1, 1, -1, 1, 0, -1};

random_device seed_gen;
mt19937 mrand(seed_gen());
mt19937_64 mrand64(seed_gen());
int rand32(int x) {
	return mrand() % x;
}
ll rand64(long x) {
	return mrand64() % x;
}

template<typename A, typename B> ostream& operator<<(ostream& out, const pair<A, B>& a) {
	out << "(" << a.first << "," << a.second << ")";
	return out;
}
template<typename T, size_t N> ostream& operator<<(ostream& out, const array<T, N>& a) {
	out << "[";
	bool first = true;
	for (auto& v : a) {
		out << (first ? "" : ",");
		out << v;
		first = 0;
	}
	out << "]";
	return out;
}
template<typename T> ostream& operator<<(ostream& out, const vector<T>& a) {
	out << "[";
	bool first = true;
	for (auto& v : a) {
		out << (first ? "" : ",");
		out << v;
		first = 0;
	}
	out << "]";
	return out;
}
template<typename T, class Cmp> ostream& operator<<(ostream& out, const set<T, Cmp>& a) {
	out << "{";
	bool first = true;
	for (auto& v : a) {
		out << (first ? "" : ",");
		out << v;
		first = 0;
	}
	out << "}";
	return out;
}
template<typename U, typename T, class Cmp> ostream& operator<<(ostream& out, const map<U, T, Cmp>& a) {
	out << "{";
	bool first = true;
	for (auto& p : a) {
		out << (first ? "" : ",");
		out << p.first << ": " << p.second;
		first = 0;
	}
	out << "}";
	return out;
}
#ifdef LOCAL
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
#else
#define trace(...) 42
#endif
template<typename Arg1> void __f(const char* name, Arg1&& arg1) {
	cerr << name << ": " << arg1 << endl;
}
template<typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args) {
	const char* comma = strchr(names + 1, ',');
	cerr.write(names, comma - names) << ": " << arg1 << " |";
	__f(comma + 1, args...);
}

struct fast_ios {
	static constexpr int IOS_PREC = 15;
	static constexpr bool AUTOFLUSH = false;

	fast_ios() {
		cin.tie(nullptr);
		ios::sync_with_stdio(false);
		cout << fixed << setprecision(IOS_PREC);
		if (AUTOFLUSH) cout << unitbuf;
	}
} fast_ios_;

int main() {
	string s, t;
	cin >> s >> t;
	s += t;
	int n = stoi(s);
	for (int i = 1; i <= 110; i++) {
		if (i * i == n) {
			cout << "Yes" << endl;
			return 0;
		}
	}
	cout << "No" << endl;
	return 0;
}


#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 ;
}


#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;
}


#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;
}


#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");
  }
}


#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;
}


#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;
}


#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;
}


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());


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'));


function Main(input){
    input = parseInt(input.replace(/\s/,""));
  	console.log(Number.isInteger(Math.sqrt(input)) ? "Yes" : "No");
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


// 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"));


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') )


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());


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")
	}
}


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")
}


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)
}


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)
}


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")
}


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")
}


a = gets.split.join.to_i
b =Math.sqrt(a)
puts b == b.to_i ? "Yes" : "No"


a,b=gets.split
c=(a+b).to_i
(1..1000).each {|i|
  if i*i==c
    puts "Yes"
    exit
  end
}
puts "No"


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


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


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"


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"


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")
}


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")
}


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");
    }
}


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()
}


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);
}


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)


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")
}


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)


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)


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")
}


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();
}


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')


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()


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'));


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')


if "9" in input():
  print("Yes")
else:
  print("No")


def main():
    N = input()

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

main()


x = str(input())

if x[0]=='9' or x[1]=='9':
    print('Yes')
else:
    print('No')


N = input()
if N[0] == 9 or N[1] == 9:
    print('Yes')
else:
    print('No')


n = int(input())

if n[0] != 9 and n[1] != 9:
    print('No')
else:
    print('Yes')


N = input()
if "9" in N:
    print('Yes')
else:
    print('NO')


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();
	}

}


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;
        }
    }
}


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Map;

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

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

    public void calc() {
        int N = in.nextInt();
        String ans = "No";

        if (Integer.toString(N).contains("9")) {
            ans = "Yes";
        }

        out.println(ans);
        out.close();
    }

    class FastScanner {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public FastScanner(InputStream stream) {
            this.stream = stream;
        }

        int read() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        boolean isEndline(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }

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

        int[] nextIntArray(int n) {
            int[] array = new int[n];
            for (int i = 0; i < n; i++)
                array[i] = nextInt();

            return array;
        }

        int[][] nextIntMap(int n, int m) {
            int[][] map = new int[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = in.nextIntArray(m);
            }
            return map;
        }

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

        long[] nextLongArray(int n) {
            long[] array = new long[n];
            for (int i = 0; i < n; i++)
                array[i] = nextLong();

            return array;
        }

        long[][] nextLongMap(int n, int m) {
            long[][] map = new long[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = in.nextLongArray(m);
            }
            return map;
        }

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

        double[] nextDoubleArray(int n) {
            double[] array = new double[n];
            for (int i = 0; i < n; i++)
                array[i] = nextDouble();

            return array;
        }

        double[][] nextDoubleMap(int n, int m) {
            double[][] map = new double[n][m];
            for (int i = 0; i < n; i++) {
                map[i] = in.nextDoubleArray(m);
            }
            return map;
        }

        String next() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        String[] nextStringArray(int n) {
            String[] array = new String[n];
            for (int i = 0; i < n; i++)
                array[i] = next();

            return array;
        }

        String nextLine() {
            int c = read();
            while (isEndline(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndline(c));
            return res.toString();
        }
    }
}


#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;
    }
}


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");
       }
    }
}


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");
		}

	}

}


#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;
}


#include <stdio.h>

int main()
{
	int n;
	scanf("%d",&n);
	printf("%s\n",(n%10==9 || n/10==9) ? "Yes" : "No");
}


#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;
}


#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;
}


#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;
}


#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
}


#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;
}


#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;
}


#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;
}


#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;
}


#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;
}


#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--;
            }
       }*/


'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'))


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"));


'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"));


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"));


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"));


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'));


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")
	}
}


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)
}


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)
}


package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"math"
	"os"
	"strconv"
)

const (
	initialBufSize = 10000
	maxBufSize     = 1000000
	mod            = 1e9 + 7
)

var (
	sc *bufio.Scanner = func() *bufio.Scanner {
		sc := bufio.NewScanner(os.Stdin)
		buf := make([]byte, initialBufSize)
		sc.Buffer(buf, maxBufSize)
		sc.Split(bufio.ScanWords)
		return sc
	}()
)

func main() {
	N := getInt()
	result := 0
	if N%10 == 9 {
		result++
	}
	if (N/10)%10 == 9 {
		result++
	}
	fmt.Println(result)
}

type Graph struct {
	n     int
	edges [][]int
}

func NewGraph(n int) *Graph {
	g := &Graph{
		n:     n,
		edges: make([][]int, n),
	}
	return g
}

func (g *Graph) AddEdge(u, v int) {
	g.edges[v] = append(g.edges[v], u)
	g.edges[u] = append(g.edges[u], v)
}

func dfs(c int, edges [][]int, visited map[int]struct{}) {
	visited[c] = struct{}{}

	for _, v := range edges[c] {
		_, flag := visited[v]
		if flag {
			continue
		}
		dfs(v, edges, visited)
	}
}

func bfs(c int, graph *Graph) {
	next := make([]int, 0)
	next = append(next, c)
	visited := make(map[int]struct{})

	for ; len(next) != 0; {
		u := next[0]
		next = next[1:]
		visited[u] = struct{}{}

		for _, v := range graph.edges[u] {
			_, flag := visited[v]
			if flag {
				continue
			}

			// なにか処理

			next = append(next, v)
		}
	}
}

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

func getIntArray(n int) []int {
	array := make([]int, n)
	for i := 0; i < n; i++ {
		array[i] = getInt()
	}
	return array
}

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

func getStringArray(n int) []string {
	array := make([]string, n)
	for i := 0; i < n; i++ {
		array[i] = getString()
	}
	return array
}

func abs(a int) int {
	return int(math.Abs(float64(a)))
}

func pow(p, q int) int {
	return int(math.Pow(float64(p), float64(q)))
}

func powMod(n, p int) int {
	if p == 0 {
		return 1
	} else if p%2 == 0 {
		t := powMod(n, p/2)
		return calcMod(t * t)
	} else {
		return calcMod(n * powMod(n, p-1))
	}
}

func min(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton min() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Min(float64(res), float64(nums[i])))
	}
	return res
}

func max(nums ...int) int {
	if len(nums) == 0 {
		panic("funciton max() requires at least one argument.")
	}
	res := nums[0]
	for i := 0; i < len(nums); i++ {
		res = int(math.Max(float64(res), float64(nums[i])))
	}
	return res
}

func strSearch(a []string, b string) bool {
	for i := 0; i < len(a); i++ {
		if a[i] == b {
			return true
		}
	}
	return false
}

func printIntArray(array []int) {
	strArray := fmt.Sprint(array)
	fmt.Println(strArray[1 : len(strArray)-1])
}

func calcMod(x int) int {
	return x % mod
}

func reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func isPrime(n int) bool {
	if n < 2 {
		return false
	} else if n == 2 {
		return true
	} else if n % 2 == 0 {
		return false
	}

	sqrtN := int(math.Sqrt(float64(n)))
	for i := 3; i <= sqrtN; i += 2 {
		if n % i == 0 {
			return false
		}
	}

	return true
}

func contains(s []int, e int) bool {
	for _, v := range s {
		if e == v {
			return true
		}
	}
	return false
}

func makeRange(min, max int) []int {
	a := make([]int, max-min+1)
	for i := range a {
		a[i] = min + i
	}
	return a
}

func powerset2(nums []int) [][]int {
	length := int(math.Pow(2, float64(len(nums))))
	result := make([][]int, length)

	index := 0
	result[index] = []int{}
	index++

	for _, n := range nums {
		max := index
		for i := 0; i < max; i++ {
			result[index] = copyAndAppend(result[i], n)
			index++
		}
	}

	return result
}

func copyAndAppend(nums []int, n int) []int {
	dst := make([]int, len(nums)+1)
	copy(dst, nums)
	dst[len(nums)] = n
	return dst
}

func calcGcd(x, y int) int {
	if y == 0 {
		return x
	} else if x >= y {
		return calcGcd(y, x % y)
	} else {
		return calcGcd(x, y % x)
	}
}

func getDivisor(n int) []int {
	var divisor []int
	divisor = append(divisor, 1)
	if n != 1 {
		divisor = append(divisor, n)
	}

	sqrt := int(math.Sqrt(float64(n)))
	for i := 2; i <= sqrt; i++ {
		if n % i == 0 {
			divisor = append(divisor, i)
			divisor = append(divisor, n/i)
		}
	}
	return divisor
}

type intHeap []int

func (h intHeap) Len() int {
	return len(h)
}

func (h intHeap) Less(i, j int) bool {
	return h[i] > h[j]
}

func (h intHeap) Swap(i, j int) {
	h[i], h[j] = h[j], h[i]
}

func (h *intHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}

func (h *intHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func initHeap() *intHeap {
	ih := &intHeap{}
	heap.Init(ih)
	return ih
}

func (h *intHeap) pushHeap(n int) {
	heap.Push(h, n)
}

func (h *intHeap) popHeap() int {
	return heap.Pop(h).(int)
}

func factMod(n int) int {
	value := 1
	for ; n > 1; n-- {
		value = calcMod(value * n)
	}
	return value
}

func combinationMod(n, k int) int {
	factN := factMod(n)
	factK := factMod(k)
	factNK := factMod(n - k)
	factKR := powMod(factK, mod - 2)
	factNKR := powMod(factNK, mod - 2)
	return calcMod(factN * calcMod(factKR * factNKR))
}


package main

import (
	"fmt"
)

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

	if N%10 == 9 || N/10 >= 9 {
		print("Yes")
	} else {
		print("No")
	}
}


x = gets.chomp.to_s.scan(/9/)
if x.length != 0
  puts "Yes"
  exit
end
puts "No"


puts gets[?9]?:Yes: :No


N = gets.to_i
a = N/10
b = N%10
if(a == 9 || b == 9)
  puts("Yes")
else
  puts("No")
end


n = gets.strip.split.map(&:to_s)
if n.include?("9")
  puts "Yes"
else
  puts "No"
end


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


s = gets.chomp
a,b = s.split("")

if(a=='9' || b=='9')
puts 'YES'
else
puts 'NO'
end


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");
    }
}


#![allow(unused_imports)]
use std::cmp::{max, min};
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};

use nyan::*;

fn main() {
    let stdin = std::io::stdin();
    let mut sc = Scanner::new(stdin.lock());

    let n: Vec<_> = sc.read_line();

    if n.contains(&'9') {
        println!("Yes");
    } else {
        println!("No");
    }
}

#[allow(dead_code)]
mod nyan {
    use std::cmp::Ordering;
    use std::fmt::{Debug, Display};
    use std::io;
    use std::iter::{self, FromIterator};
    use std::str::FromStr;

    // https://doc.rust-lang.org/1.39.0/src/core/num/mod.rs.html#4473-4523
    #[inline]
    pub fn is_ascii_whitespace(c: char) -> bool {
        match c {
            '\t' | '\n' | '\x0C' | '\r' | ' ' => true,
            _ => false,
        }
    }

    #[inline]
    pub fn is_ascii_linebreak(c: char) -> bool {
        match c {
            '\n' | '\r' => true,
            _ => false,
        }
    }

    pub struct Scanner<R: io::BufRead> {
        reader: R,
        buffer: String,
        cursor: usize,
    }

    impl<R: io::BufRead> Scanner<R> {
        pub fn new(reader: R) -> Scanner<R> {
            Scanner {
                reader: reader,
                buffer: String::with_capacity(32),
                cursor: 0,
            }
        }

        fn next<F: Fn(char) -> bool>(&mut self, f: F) -> io::Result<&str> {
            loop {
                if let Some(l) = self.buffer[self.cursor..].find(|c| !is_ascii_whitespace(c)) {
                    self.cursor += l;
                    break;
                }

                self.buffer.clear();
                self.cursor = 0;
                match self.reader.read_line(&mut self.buffer) {
                    Err(e) => return Err(e),
                    Ok(0) => return Err(io::Error::from(io::ErrorKind::UnexpectedEof)),
                    _ => (),
                }
            }

            let start = self.cursor;
            self.cursor = self.buffer[self.cursor..]
                .find(f)
                .map_or(self.buffer.len(), |l| start + l);
            Ok(&self.buffer[start..self.cursor])
        }

        fn next_word(&mut self) -> io::Result<&str> {
            self.next(|c| is_ascii_whitespace(c))
        }

        fn next_line(&mut self) -> io::Result<&str> {
            self.next(|c| c == '\n' || c == '\r')
        }

        pub fn read<T>(&mut self) -> T
        where
            T: FromStr,
            <T as FromStr>::Err: Debug,
        {
            self.next_word().unwrap().parse().unwrap()
        }

        pub fn read_vec<T, U>(&mut self, n: usize) -> T
        where
            T: FromIterator<U>,
            U: FromStr,
            <U as FromStr>::Err: Debug,
        {
            (0..n).map(|_| self.read()).collect()
        }

        pub fn read_vec2d<T, U, V>(&mut self, m: usize, n: usize) -> T
        where
            T: FromIterator<U>,
            U: FromIterator<V>,
            V: FromStr,
            <V as FromStr>::Err: Debug,
        {
            (0..m).map(|_| self.read_vec(n)).collect()
        }

        pub fn read_line<T: FromIterator<char>>(&mut self) -> T {
            self.next_line().unwrap().chars().collect()
        }

        pub fn read_lines<T, U>(&mut self, n: usize) -> T
        where
            T: FromIterator<U>,
            U: FromIterator<char>,
        {
            (0..n).map(|_| self.read_line()).collect()
        }
    }

    #[test]
    fn test_scanner_next_word() {
        let buf = io::Cursor::new(b"hello world\nfoo\n\n\n\nbar\n");
        let mut r = Scanner::new(buf);

        assert_eq!(r.next_word().unwrap(), "hello");
        assert_eq!(r.next_word().unwrap(), "world");
        assert_eq!(r.next_word().unwrap(), "foo");
        assert_eq!(r.next_word().unwrap(), "bar");
        assert!(r.next_word().is_err());
        assert!(r.next_word().is_err());
    }

    #[test]
    fn test_scanner_next_line() {
        let buf = io::Cursor::new(b"hello world\nfoo\n\n\n\nbar\n");
        let mut r = Scanner::new(buf);

        assert_eq!(r.next_line().unwrap(), "hello world");
        assert_eq!(r.next_line().unwrap(), "foo");
        assert_eq!(r.next_line().unwrap(), "bar");
        assert!(r.next_line().is_err());
        assert!(r.next_line().is_err());
    }

    #[test]
    fn test_scanner_no_linebreak() {
        let buf = io::Cursor::new(b"hello world");
        let mut r = Scanner::new(buf);

        assert_eq!(r.next_word().unwrap(), "hello");
        assert_eq!(r.next_word().unwrap(), "world");
        assert!(r.next_word().is_err());
        assert!(r.next_word().is_err());
    }

    pub fn print_vec<T: Display>(v: &[T]) {
        if v.is_empty() {
            return;
        }

        print!("{}", v[0]);
        for i in v.iter().skip(1) {
            print!(" {}", i);
        }
        println!();
    }

    // C++ like binary search functions (upper_bound, lower_bound, equal_range)
    pub trait BinarySearch<T> {
        fn lower_bound(&self, value: &T) -> usize;
        fn upper_bound(&self, value: &T) -> usize;
        fn equal_range(&self, value: &T) -> (usize, usize) {
            (self.lower_bound(value), self.upper_bound(value))
        }
    }

    impl<T: Ord> BinarySearch<T> for [T] {
        // https://en.cppreference.com/w/cpp/algorithm/lower_bound#Possible_implementation
        fn lower_bound(&self, value: &T) -> usize {
            let mut first = 0;
            let mut last = self.len();
            while last != first {
                let mid = (first + last) / 2;
                match self[mid].cmp(value) {
                    Ordering::Less => first = mid + 1,
                    _ => last = mid,
                }
            }
            first
        }

        // https://en.cppreference.com/w/cpp/algorithm/upper_bound#Possible_implementation
        fn upper_bound(&self, value: &T) -> usize {
            let mut first = 0;
            let mut last = self.len();
            while last != first {
                let mid = (first + last) / 2;
                match self[mid].cmp(value) {
                    Ordering::Greater => last = mid,
                    _ => first = mid + 1,
                }
            }
            first
        }
    }

    #[test]
    pub fn test_binary_search() {
        let data = vec![1, 1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6];
        assert_eq!(data.lower_bound(&4), 7);
        assert_eq!(data.upper_bound(&4), 10);
    }

    // https://doc.rust-lang.org/std/cmp/struct.Reverse.html
    #[derive(PartialEq, Eq, Debug)]
    pub struct Rev<T>(pub T);

    impl<T: PartialOrd> PartialOrd for Rev<T> {
        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
            other.0.partial_cmp(&self.0)
        }
    }

    impl<T: Ord> Ord for Rev<T> {
        fn cmp(&self, other: &Self) -> Ordering {
            other.0.cmp(&self.0)
        }
    }

    // Extended Euclidean algorithm
    // ax + by = gcd(x, y)
    pub fn extended_gcd(a: u64, b: u64) -> (u64, i64, i64) {
        if b == 0 {
            (a, 1, 0)
        } else {
            let (m, y, x) = extended_gcd(b, a % b);
            (m, x, y - (a / b) as i64 * x)
        }
    }

    pub fn gcd(a: u64, b: u64) -> u64 {
        if b == 0 {
            a
        } else {
            gcd(b, a % b)
        }
    }

    pub fn lcm(a: u64, b: u64) -> u64 {
        a / gcd(a, b) * b
    }

    // x^n (mod p)
    pub fn pow_mod(mut x: u64, mut n: u64, p: u64) -> u64 {
        let mut r = 1;
        while n > 0 {
            if n & 1 > 0 {
                r *= x;
                r %= p;
            }
            x *= x;
            x %= p;
            n >>= 1;
        }
        r
    }

    #[test]
    fn test_pow_mod() {
        assert_eq!(pow_mod(4, 13, 497), 445);
        assert_eq!(pow_mod(2, 90, 13), 12);
        assert_eq!(pow_mod(2, 99999999, 147), 134);
    }

    // a^{p-1} = 1 (mod p) (Fermat's little theorem)
    // a^{p - 2} * a = 1 → a^{-1} = a^{p-2}
    pub fn inv_mod(n: u64, p: u64) -> u64 {
        pow_mod(n, p - 2, p)
    }

    // s * (s + 1) * .. * t (mod p)
    pub fn prod_mod(s: u64, t: u64, p: u64) -> u64 {
        (s..t + 1).fold(1, |acc, x| acc * x % p)
    }

    // nCk (mod p)
    pub fn comb_mod(n: u64, k: u64, p: u64) -> u64 {
        // nCk = n! / (k! * (n - k)!)
        //     = ((n-k+1) * (n-k+2) * ... * n) * inv(k!)
        prod_mod(n - k + 1, n, p) * inv_mod(prod_mod(1, k, p), p) % p
    }

    // comb_mod_multi(n_max, p)(n, k) = nCk (mod p)
    pub fn comb_mod_multi(n_max: u64, p: u64) -> Box<Fn(u64, u64) -> u64> {
        // fact[n] = n!, fact_inv[n] = (n!)^(-1) (mod p)
        let fact = iter::once(1)
            .chain(1..n_max + 1)
            .scan(1, |state, x| {
                *state = (*state * x) % p;
                Some(*state)
            })
            .collect::<Vec<_>>();
        let fact_inv = fact.iter().map(|&x| inv_mod(x, p)).collect::<Vec<_>>();

        Box::new(move |n, k| {
            let a = fact[n as usize];
            let b = fact_inv[k as usize];
            let c = fact_inv[(n - k) as usize];
            (((a * b) % p) * c) % p
        })
    }

    #[inline]
    pub fn minmax<T: Ord>(a: T, b: T) -> (T, T) {
        if a < b {
            (a, b)
        } else {
            (b, a)
        }
    }

    #[test]
    fn test_minmax() {
        assert_eq!(minmax(1, 3), (1, 3));
        assert_eq!(minmax(3, 1), (1, 3));
    }

    #[inline]
    pub fn digits(x: u64, base: u64) -> u32 {
        (1..)
            .find(|&i| base.pow(i - 1) <= x && x < base.pow(i))
            .unwrap_or(0)
    }

    #[test]
    fn test_digits() {
        assert_eq!(digits(1234, 10), 4);
        assert_eq!(digits(1234567890, 10), 10);
        assert_eq!(digits(0xdeadbeef, 16), 8);
        assert_eq!(digits(0o123456, 8), 6);
        assert_eq!(digits(0b10101, 2), 5);
    }

    pub struct UnionFind {
        n: usize,
        root: Vec<usize>,
        rank: Vec<usize>,
        size: Vec<usize>,
    }

    impl UnionFind {
        pub fn new(n: usize) -> UnionFind {
            UnionFind {
                n: n,
                root: (0..n).collect(),
                rank: vec![0; n],
                size: vec![1; n],
            }
        }

        pub fn root(&mut self, x: usize) -> usize {
            let r = self.root[x];
            if r == x {
                r
            } else {
                self.root[x] = self.root(r);
                self.root[x]
            }
        }

        pub fn merge(&mut self, x: usize, y: usize) {
            let rx = self.root(x);
            let ry = self.root(y);
            if rx == ry {
                return;
            }

            if self.rank[rx] < self.rank[ry] {
                self.root[rx] = ry;
                self.size[ry] += self.size[rx];
            } else {
                self.root[ry] = rx;
                self.size[rx] += self.size[ry];
                if self.rank[rx] == self.rank[ry] {
                    self.rank[rx] += 1;
                }
            }
        }

        pub fn size(&mut self, x: usize) -> usize {
            let rx = self.root(x);
            self.size[rx]
        }
    }
}


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"}
    );
}


use proconio::input;

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


//  ____            _                  _                       _       _
// |  _ \ _   _ ___| |_    ___ _ __   | |_ ___ _ __ ___  _ __ | | __ _| |_ ___
// | |_) | | | / __| __|  / __| '_ \  | __/ _ \ '_ ` _ \| '_ \| |/ _` | __/ _ \
// |  _ <| |_| \__ \ |_  | (__| |_) | | ||  __/ | | | | | |_) | | (_| | ||  __/
// |_| \_\\__,_|___/\__|  \___| .__/___\__\___|_| |_| |_| .__/|_|\__,_|\__\___|
//                            |_| |_____|               |_|

//https://github.com/manta1130/Competitive_Programming_Template_Rust

#[macro_use]
mod input {

    use std;
    use std::io;

    const SPLIT_DELIMITER: char = ' ';

    #[macro_export]
    #[allow(unused_macros)]
    macro_rules! input {
    ( $($x:expr ),*) => {
        {
            let temp_str = input_line_str();
            let mut split_result_iter = temp_str.split_whitespace();
                $(
                let buf_split_result = split_result_iter.next();
                let buf_split_result = buf_split_result.unwrap();
                    ($x) = buf_split_result.parse().unwrap();
                )*
        }
    };
}

    #[allow(dead_code)]
    pub fn input_line_str() -> String {
        let mut s = String::new();
        io::stdin().read_line(&mut s).unwrap();
        s.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn p<T>(t: T)
    where
        T: std::fmt::Display,
    {
        println!("{}", t);
    }

    #[allow(dead_code)]
    pub fn input_vector2d<T>(line: usize) -> Vec<Vec<T>>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<Vec<T>> = Vec::new();

        for _ in 0..line {
            let vec_line = input_vector();
            v.push(vec_line);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector<T>() -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<T> = Vec::new();

        let s = input_line_str();
        let split_result = s.split(SPLIT_DELIMITER);
        for z in split_result {
            let buf = match z.parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector_row<T>(n: usize) -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v = Vec::with_capacity(n);
        for _ in 0..n {
            let buf = match input_line_str().parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    pub trait ToCharVec {
        fn to_charvec(&self) -> Vec<char>;
    }

    impl ToCharVec for String {
        fn to_charvec(&self) -> Vec<char> {
            self.to_string().chars().collect::<Vec<_>>()
        }
    }
}

use input::*;

fn main()
{
    let mut n:usize;
    input!(n);
    let mut flag=true;
    while n>0{
        if n%10!=9{
            flag=false;
        }
        n/= 10;
    }
    if flag{
        println!("No")
    }else{
        println!("Yes");
    }
}