package main

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

func configure(scanner *bufio.Scanner) {
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1000005), 1000005)
}
func getNextString(scanner *bufio.Scanner) string {
	scanned := scanner.Scan()
	if !scanned {
		panic("scan failed")
	}
	return scanner.Text()
}
func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}
func getNextInt64(scanner *bufio.Scanner) int64 {
	i, _ := strconv.ParseInt(getNextString(scanner), 10, 64)
	return i
}
func getNextFloat64(scanner *bufio.Scanner) float64 {
	i, _ := strconv.ParseFloat(getNextString(scanner), 64)
	return i
}
func main() {
	fp := os.Stdin
	wfp := os.Stdout
	extra := 0
	if os.Getenv("I") == "IronMan" {
		fp, _ = os.Open(os.Getenv("END_GAME"))
		extra = 100
	}
	scanner := bufio.NewScanner(fp)
	configure(scanner)
	writer := bufio.NewWriter(wfp)
	defer func() {
		r := recover()
		if r != nil {
			fmt.Fprintln(writer, r)
		}
		writer.Flush()
	}()
	solve(scanner, writer)
	for i := 0; i < extra; i++ {
		fmt.Fprintln(writer, "-----------------------------------")
		solve(scanner, writer)
	}
}
func solve(scanner *bufio.Scanner, writer *bufio.Writer) {
	s := getNextString(scanner)
	n := len(s)
	var sum int
	for i := 0; i < n; i++ {
		sum += int(s[i] - '0')
	}
	if sum%3 == 0 {
		fmt.Fprintln(writer, "Yes")
		return
	}
	fmt.Fprintln(writer, "No")
}


package main

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

func main() {
	n := scanRowText()
	result := 0
	for _, v := range n {
		d, _ := strconv.Atoi(string(v))
		result += d
		result %= 9
	}
	if result == 0 {
		fmt.Println("Yes")
		return
	}
	fmt.Println("No")
}

var once sync.Once
var scanner *bufio.Scanner

func scanRowText() string {
	once.Do(func() {
		scanner = bufio.NewScanner(os.Stdin)
		scanner.Split(bufio.ScanWords)
	})
	scanner.Scan()
	return scanner.Text()
}


package main

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

func nextLine(r *bufio.Reader) string {
	var buf []byte
	for {
		line, isPrefix, err := r.ReadLine()
		if err != nil {
			panic(err)
		}
		buf = append(buf, line...)
		if !isPrefix {
			break
		}
	}
	return string(buf)
}

func nextStr(s *bufio.Scanner) string {
	s.Scan()
	ref := s.Bytes()
	cp := make([]byte, len(ref))
	copy(cp, ref)
	return string(cp)
}

func nextInt(s *bufio.Scanner) int {
	n, err := strconv.Atoi(nextStr(s))
	if err != nil {
		panic(err)
	}
	return n
}

func nextInt64(s *bufio.Scanner) int64 {
	n, err := strconv.ParseInt(nextStr(s), 0, 64)
	if err != nil {
		panic(err)
	}
	return n
}

func main() {
	r := bufio.NewReader(os.Stdin)
	s := bufio.NewScanner(os.Stdin)
	s.Split(bufio.ScanWords)

	str := nextLine(r)
	sum := 0
	for _, c := range str {
		sum += int(c)
	}

	if sum % 9 == 0 {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}


//go:generate echo "https://atcoder.jp/contests/abc176/tasks/abc176_b"
package main

import (
	"bufio"
	"fmt"
	"io"
	"math/big"
	"os"
	"strconv"
)

type scanner struct{ *bufio.Scanner }

func newScanner(r io.Reader) *scanner {
	s := bufio.NewScanner(r)
	s.Split(bufio.ScanWords)
	s.Buffer(nil, 100000000)
	return &scanner{s}
}

func (s *scanner) String() string {
	s.Scan()
	return s.Text()
}

func (s *scanner) StringSlice(l int) []string {
	if l == 0 {
		return []string{}
	}
	sl := make([]string, l, l)
	for i := range sl {
		sl[i] = s.String()
	}
	return sl
}

func solve(n string) bool {
	sum := 0
	for _, c := range n {
		n, _ := strconv.Atoi(string(c))
		sum += n
	}
	return sum%9 == 0
}

func solve2(n *big.Int) bool {
	z := big.NewInt(0)
	t := big.NewInt(10)

	sum := int64(0)
	for n.Cmp(z) > 0 {
		m := new(big.Int)
		n, m = new(big.Int).DivMod(n, t, m)
		sum += m.Int64()
	}
	return sum%9 == 0
}

func (s *scanner) BigInt() *big.Int {
	s.Scan()
	n, _ := strconv.ParseInt(s.Text(), 10, 64)
	return big.NewInt(n)
}

func (s *scanner) BigIntSlice(l int) []*big.Int {
	if l == 0 {
		return []*big.Int{}
	}
	sl := make([]*big.Int, l, l)
	for i := range sl {
		sl[i] = s.BigInt()
	}
	return sl
}

func main() {
	scan := newScanner(os.Stdin)
	n := scan.BigInt()
	if solve2(n) {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}


n = gets.chomp.to_i

if n % 9 == 0
  puts "Yes"
else
  puts "No"
end


input = gets.to_i

if((input % 9 ) == 0)
  puts 'Yes'
else
  puts 'No'
end


puts gets.to_i%9>0?"No":"Yes"


input_line = gets
sum = 0
input_line.downto(0) do
  sum += input_line%10
  input_line /= 10
end
if sum%9 == 0
  p "Yes"
else
  p "No"
end


input = gets.to_i
array = []

while input != 0
  array << (input % 10)
  input /= 10
end

total = 0
for num in array
  total += num
end

if((total % 9) == 0)
  puts 'Yes'
else
  puts 'No'
end


gets.divmod(9).last > 0 ? :No : :Yes


fn main() {
    let s = {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).unwrap();
        s.trim_right().to_owned()
    };

    let n_string = {
        let mut ws = s.split_whitespace();
        let n_string: String = ws.next().unwrap().parse().unwrap();
        n_string
    };

    let mut sum: i32 = 0;

    for i in n_string.as_str().chars() {
        let num : i32 = i as i32 - 48;
        sum += num;
    }

    if sum % 9 == 0 {
        println!("Yes");
    } else {
        println!("No");
    }
}


use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        s: String,
    }

    let mut sum = 0i64;
    for d in s.chars() {
        let d: i64 = d.to_digit(10).unwrap() as i64;
        sum += d;
    }

    let ans = if sum % 9 == 0 { "Yes" } else { "No" };
    println!("{}", ans);
}


#[allow(unused_imports)]
use proconio::{input, marker::*};

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

#[allow(unused_imports)]
use std::io::Write;

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        #[cfg(debug_assertions)]
        writeln!(&mut std::io::stderr(), concat!("[DEBUG] ", $(stringify!($a), "={:?} "),*), $($a),*).unwrap();
    }
}

fn main() {
    input! {
        n: String,
    }
    let mut sum = 0usize;
    for c in n.chars() {
        sum += c as usize - '0' as usize;
    }
    if sum % 9 == 0 {
        println!("Yes");
    } else {
        println!("No");
    }
}


#include <iostream>
#include <string>

using namespace std;

int main(){

    string input = "";

    cin >> input;

    long long digit_sum = 0;

    for(char x : input){

        digit_sum += x - '0';

    }

    if(digit_sum%9 == 0){
        cout <<"Yes\n";
    }else{
        cout <<"No\n";
    }

    return 0;
}


use std::io;

fn main(){

    let mut input: String = String::new();

    io::stdin().read_line(&mut input).expect("Enter Something");

    let mut input_num:i128 = input.trim().parse().unwrap();

    let mut digit_sum: i128 = 0;

    while input_num > 0{
        digit_sum += input_num%10;
        input_num = input_num/10;
    }

    println!("{}", {
        if digit_sum%9 == 0{"YES"}
        else {"NO"}
    });

}


use proconio::input;

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

    let mut itr = n.split("");

    let mut cal = 0;

    for s in itr {
        cal += s.parse().unwrap();
    }

    if cal / 9 == 0 {
        println!("Yes");
    } else {
        println!("No");
    }

}


let s = readLine()!

var sum = 0
for c in s {
  sum += Int(String(c))!
}
print(sum % 9 == 0 ? "Yes" : "No")


import Foundation

let input_line: String = readLine()!
var sum = 0

for num in input_line{
    sum += Int(String(num))!
}

if (sum % 9 == 0) {
    print("Yes")
}else{
    print("No")
}


func mainB() {
    let N = readLine()!

    let sum = N.reduce(0) { (sum, part) in sum + Int(String(part))! }
    print(sum.isMultiple(of: 9) ? "Yes" : "No")
}
mainB()


// 🐋💭
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readInt() -> Int {
    return Int(readLine()!)!
}

func readDoubles () -> [Double] {
    return readLine()!.split(separator: " ").map { Double($0)! }
}

func readDouble() -> Double{
    return Double(readLine()!)!
}

func readLines() -> [String] {
    return readLine()!.map { String($0) }
}
///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, m % n)
}

///最大公約数を返す
func gcd(_ array: [Int]) -> Int {
    var value = array[0]
    if array.count > 1 {
        for i in 1..<array.count {
            value = gcd(value, array[i])
        }
    }
    return value
}

///最小公倍数を返す
func lcm(_ m:Int, _ n:Int) -> Int {
    return m * n / gcd(m, n)
}

///素数判定(試し割り)
func isPrime(_ x:Int) -> Bool {
    if x <= 1 || x % 2 == 0 { return false }
    if x == 2 { return true }
    for i in stride(from: 3, to: Int(ceil(sqrt(Double(x)))), by: 2){
        if x % i == 0 {
            return false
        }
    }
    return true
}

//https://program-life.com/669
///実行速度の計測
func exectionTime(action: () -> Void) {
    let startDate = Date()
    action()
    let endDate = Date()
    print(endDate.timeIntervalSince(startDate))
}

//https://riptutorial.com/ja/swift/example/14738/インデックスを知らずに配列から要素を削除する
extension Array where Element: Equatable {

    mutating func remove(_ element: Element) {
        _ = firstIndex(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

func binarySearch(rifgt:Int, key:Int, ary:[String]) -> Int{
    var left = 0
    var right = rifgt

    while abs(right - left) > 1 {
        let mid = left + (right - left) / 2

        if Int(ary[mid])! < key {
            left = mid

        } else {
            right = mid
        }
    }
    return left
}

func arrangement (prev:String, ary:[String], returnVal:[String]) -> [String] {
    var returnVal = returnVal
    if ary.count == 0 {
        returnVal.append(prev)
        return returnVal
    }

    for s in ary {
        let wprev = prev + s
        var wary = ary
        wary.remove(s)
        returnVal = arrangement(prev: wprev, ary: wary, returnVal: returnVal)
    }
    return returnVal
}
// https://algo-logic.info/divisor/
/// 約数の配列を返す
func divisor(_ n:Int) -> [Int] {
    var ret = [Int]()
    var i = 1
    while i * i <= n {
        if n % i == 0 {
            ret.append(i)
            if i * i != n {
                ret.append(n / i)
            }
        }
        i += 1
    }
    return ret.sorted()
}

func main() {
    let N = readInt()
    //＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿ここまで入力
    print(N % 9 == 0 ? "Yes": "No")
}
main()


// 🐋💭
import Foundation

func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func readInt() -> Int {
    return Int(readLine()!)!
}

func readDoubles () -> [Double] {
    return readLine()!.split(separator: " ").map { Double($0)! }
}

func readDouble() -> Double{
    return Double(readLine()!)!
}

func readLines() -> [String] {
    return readLine()!.map { String($0) }
}
///最大公約数を返す
func gcd(_ m:Int, _ n:Int) -> Int {
    if n == 0 {return m}
    return gcd(n, m % n)
}

///最大公約数を返す
func gcd(_ array: [Int]) -> Int {
    var value = array[0]
    if array.count > 1 {
        for i in 1..<array.count {
            value = gcd(value, array[i])
        }
    }
    return value
}

///最小公倍数を返す
func lcm(_ m:Int, _ n:Int) -> Int {
    return m * n / gcd(m, n)
}

///素数判定(試し割り)
func isPrime(_ x:Int) -> Bool {
    if x <= 1 || x % 2 == 0 { return false }
    if x == 2 { return true }
    for i in stride(from: 3, to: Int(ceil(sqrt(Double(x)))), by: 2){
        if x % i == 0 {
            return false
        }
    }
    return true
}

//https://program-life.com/669
///実行速度の計測
func exectionTime(action: () -> Void) {
    let startDate = Date()
    action()
    let endDate = Date()
    print(endDate.timeIntervalSince(startDate))
}

//https://riptutorial.com/ja/swift/example/14738/インデックスを知らずに配列から要素を削除する
extension Array where Element: Equatable {

    mutating func remove(_ element: Element) {
        _ = firstIndex(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

func binarySearch(rifgt:Int, key:Int, ary:[String]) -> Int{
    var left = 0
    var right = rifgt

    while abs(right - left) > 1 {
        let mid = left + (right - left) / 2

        if Int(ary[mid])! < key {
            left = mid

        } else {
            right = mid
        }
    }
    return left
}

func arrangement (prev:String, ary:[String], returnVal:[String]) -> [String] {
    var returnVal = returnVal
    if ary.count == 0 {
        returnVal.append(prev)
        return returnVal
    }

    for s in ary {
        let wprev = prev + s
        var wary = ary
        wary.remove(s)
        returnVal = arrangement(prev: wprev, ary: wary, returnVal: returnVal)
    }
    return returnVal
}
// https://algo-logic.info/divisor/
/// 約数の配列を返す
func divisor(_ n:Int) -> [Int] {
    var ret = [Int]()
    var i = 1
    while i * i <= n {
        if n % i == 0 {
            ret.append(i)
            if i * i != n {
                ret.append(n / i)
            }
        }
        i += 1
    }
    return ret.sorted()
}

func main() {
    print(readLine()!)
    let N = readInt()
    //＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿ここまで入力
    print(N % 9 == 0 ? "Yes": "No")
}
main()


import Foundation

let n = readLine()!.trimmingCharacters(in: .whitespacesAndNewlines).split(separator: Character(""))

var acc = 0

for ch in n {
  acc = (acc + Int(ch)!) % 9
}

print(acc == 0 ? "Yes" : "No")


import * as fs from 'fs';

// main
function main(input: string[]) {
    // param
    var n: string;
    var ans: string;
    // init
    n = input[0];
    ans = "...";
    // solve
    var sum = 0;
    var nlen= n.length;
    var czero = "0".charCodeAt(0);
    for (var nx = 0; nx < nlen; nx++) {
        sum += n.charCodeAt(nx) - czero;
    }
    var ans = (sum % 9 ==0) ? "Yes" : "No";
    // answer
    console.log(ans);
}

// math library
function Math_max(arr: number[]): number { return arr.reduce((x, y) => Math.max(x, y)); }
function Math_min(arr: number[]): number { return arr.reduce((x, y) => Math.min(x, y)); }
function Math_gcd(): number {
    var ans = arguments[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < arguments.length; i++) {
        ans = f(ans, arguments[i]);
    }
    return ans
};
function Math_gcdArray(values: number[]): number {
    var ans = values[0];
    var f = (a: number, b: number): number => b ? f(b, a % b) : a
    for (var i = 1; i < values.length; i++) {
        ans = f(ans, values[i]);
    }
    return ans
};
function Math_lcm(): number {
    var a = arguments
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_lcmArray(values: number[]): number {
    var a = values
    var g = (n: number, m: number): number => m ? g(m, n % m) : n
    var l = (n: number, m: number): number => n * m / g(n, m)
    var ans = a[0]
    for (var i = 1; i < a.length; i++) {
        ans = l(ans, a[i])
    }
    return ans
}
function Math_primeList(value: number): number[] {
    var ans = [];
    var arr = new Array(value).fill(0);
    for (var i = 2; i < value; i++) {
        if (arr[i] == 0) {
            for (var j = i; j < value; j += i) {
                if (arr[j] == 0) arr[j] = i;
            }
        }
    }
    for (var i = 2; i < value; i++) {
        if (arr[i] == i) ans.push(i);
    }
    return ans;
}
function Math_primeFactor(p: number[], value: number): number[][] {
    var ans: number[][] = [];
    var valmax = value / 2;;
    for (var i = 0; i < p.length; i++) {
        var prime = p[i];
        if (valmax < prime) break;
        var count = 0;
        while (value % prime == 0) {
            value /= prime;
            count++;
        }
        if (count != 0) {
            ans.push([prime, count]);
        }
        if (value == 1) break;
    }
    return ans;
}

// union-find library
var g_uf_root: number[];
var g_uf_count: number[];
function UF_initRoot(num: number) {
    g_uf_root = new Array(num).fill(-1);
    g_uf_count = new Array(num).fill(1);
}
function UF_getRoot(index: number) {
    if (g_uf_root[index] < 0) {
        return index;
    } else {
        var work0: number = UF_getRoot(g_uf_root[index]);
        g_uf_root[index] = work0;
        return work0
    }
}
function UF_mergeRoot(a: number, b: number) {
    var root0: number = UF_getRoot(a);
    var root1: number = UF_getRoot(b);
    if (root0 == root1) return;
    if (root0 > root1) [root0, root1] = [root1, root0];
    g_uf_count[root0] += g_uf_count[root1];
    g_uf_count[root1] = 0;
    g_uf_root[root1] = root0;
}

// entrypoint
function entrypoint() {
    try {
        var input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        console.debug = function () { };
        main(input);
    }
    catch (ex) {
        console.log("file='%s'", __filename.split("\\").slice(-1)[0]);
        const lines: string[] = [];
        // @ts-ignore
        const reader = require('readline').createInterface({
            // @ts-ignore
            input: process.stdin,
            // @ts-ignore
            output: process.stdout
        });
        reader.on('line', function (line: string) {
            lines.push(line);
        });
        reader.on('close', function () {
            input = lines;
            console.log("input=%o", input);
            console.time();
            main(input);
            console.timeEnd();
        });
    }
}
entrypoint();


import * as fs from "fs";

const MOD: number = 1e9 + 7;

const input = fs.readFileSync("/dev/stdin", "utf8");

let s: string = input;
let sum: number = 0;
for (let i = 0; i < s.length; i++) {
    sum += +s[i];
}

let ans = sum % 9 ? "No" : "Yes";
console.log(ans);


import * as fs from "fs";

const input = fs
  .readFileSync("/dev/stdin", "utf8")
  .split("")
  .map(Number);

let sum = input.reduce((a,c) => {
	return a + c;
});

let ans = sum % 9 == 0 ? "Yes" : "No";

console.log(ans);


"use strict";

const main = (arg) => {
  const input = arg.trim();

  process.stdout.write(input % 9 === 0 ? "Yes" : "No");
};
main(require("fs").readFileSync("/dev/stdin", "utf8"));


// B - Multiple of 9
import { readFileSync } from 'fs';
const input = readFileSync('/dev/stdin', 'utf8');

const N = input
  .split('')
  .map((s) => parseInt(s))
  .reduce((a, b) => a + b);

console.log(N % 9 === 0 ? 'Yes' : 'No');


// B - Multiple of 9
import { readFileSync } from 'fs';
const input = readFileSync('/dev/stdin', 'utf8');

const N = parseInt(input);

console.log(N % 9 === 0 ? 'Yes' : 'No');


X = int(input())

if X == 3 or X == 5 or X == 7:
    print("YES")
else:
    print("NO")


n=input()
print("YES" if n in "753" else "NO")


x = int(input())

if x == 3 or x == 5 or x == 7:
    print('YES')
else:
    print('NO')


X=int(input())
print("YES" if X==3 or 5 or 7 else "NO")


koman = int(input())
if koman==7 or koman==5 or koman==3:
    print("Yes")
else :
    print("No")


x=input()
if x=='7' and x=='5' and x=='3':
  print('YES')
else:
  print('NO')


import java.io.*;

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

    switch (str) {
      case "7" :
      case "5" :
      case "3" :
        System.out.println("YES");
        break;
      default :
        System.out.println("NO");
    }
  }
}


import java.util.Map.Entry;
import java.io.*;
import java.util.*;

public class Main {

	public static void main(String[] args) throws IOException {
		FastScanner sc = new FastScanner(System.in);

		int N = sc.nextInt();
		if(N == 3 || N == 5 || N == 7) System.out.println("YES");
		else System.out.println("NO");
	}
}

class FastScanner {
    private InputStream in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    public FastScanner(InputStream in) {
		this.in = in;
	}
    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());
    }
}


import java.io.*;

class Main{
    public static void main(String[] args) throws IOException {
        BufferedReader a = new BufferedReader(new InputStreamReader(System.in));
        String input = a.readLine();
        int x = Integer.parseInt(input);
        if(x==3 || x==5 || x==7){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        Scanner s = new Scanner(System.in);
        int d = s.nextInt();
        if(d==7||d==5||d==3) System.out.println("Yes");
        else System.out.println("No");

    }

}

class Scanner
{
    StringTokenizer st;
    BufferedReader br;

    public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

    public String next() throws IOException
    {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

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

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

    public String nextLine() throws IOException {return br.readLine();}

    public double nextDouble() throws IOException
    {
        String x = next();
        StringBuilder sb = new StringBuilder("0");
        double res = 0, f = 1;
        boolean dec = false, neg = false;
        int start = 0;
        if(x.charAt(0) == '-')
        {
            neg = true;
            start++;
        }
        for(int i = start; i < x.length(); i++)
            if(x.charAt(i) == '.')
            {
                res = Long.parseLong(sb.toString());
                sb = new StringBuilder("0");
                dec = true;
            }
            else
            {
                sb.append(x.charAt(i));
                if(dec)
                    f *= 10;
            }
        res += Long.parseLong(sb.toString()) / f;
        return res * (neg?-1:1);
    }

    public boolean ready() throws IOException {return br.ready();}

}


import java.util.*;

public class Main {
	public static void main(String args[]) {
    	Scanner sc = new Scanner(System.in);
        int x = sc.nextInt()l
        if (x == 7 || x == 5 || x == 3) {
            System.out.println("YES");
        } else {
        	System.out.println("NO");
        }
    }
}


import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        if(n == 7 || n == 5 || n == 3)System.out.println("Yes");
        else System.out.println("No");
    }
}


#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include <numeric>
using namespace std;

int main()
{	long long int X;
	scanf("%lld", &X);
	if((X-3)*(X-5)*(X-7)==0){
	printf("YES");
	}
	else
	{
	printf("NO");
	}

}


#include <stdio.h>
#include <cstdio>
#include <queue>
#include <set>
using namespace std;

int main(){

  /* read input */
  int N;
  scanf("%d", &N); // read int

  /*solve problem*/
  if(N==7 || N==5 || N==3){
    printf("YES");
  }
  else
    printf("NO");

  return 0;
}


#include "stdio.h"

int main()
{
	int age;

	scanf("%d", &age);

	if ((age == 7) ||
		(age == 5) ||
		(age == 3))
	{
		printf("YES\n");
	}
	else
	{
		printf("NO\n");
	}

	return 0;
}


#include <bits/stdc++.h>
#include <cassert>
#define rep(i,N) for (int i = 0; i < (N); ++i)
#define rep2(i, a, b) for(ll i = a; i <= b; ++i)
#define rep3(i, a, b) for(ll i = a; i >= b; --i)
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(c) begin(c), end(c)
#define ok() puts(ok?"Yes":"No");
template<class T> bool chmax(T &a, const T &b) { if(a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if(a > b) { a = b; return true; } return false; }
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using ii = pair<int, int>;
using vvi = vector<vi>;
using vii = vector<ii>;
using gt = greater<int>;
using minq = priority_queue<int, vector<int>, gt>;
using P = pair<ll,ll>;
const ll LINF = 1e18L + 1;
const int INF = 1e9 + 1;
//clang++ -std=c++11 -stdlib=libc++

int x;
int main() {
  cin >> x;
  if (x == 3 || x==5||x==7)` puts("YES");
  else puts("NO");
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main() {
  ll a;
  cin>>a;
  if(a==3||a==5||a==7){
    cout<<"Yes"<<endl;
  }
  else{
    cout<<"No"<<endl;
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define int long long
// Big two primes
#define X 1001100011100001111ll
#define mod 1000000007
#define ll long long
#define all(a) a.begin(),a.end()
#define sortall(a) sort(all(a))
#define fo(i, n) for (int i = 0; i < n; i++)
#define fo1(i, n) for (int i = 1; i <= n; i++)
#define loop(i,a,b) for (int i = a; i < b; i++)
#define nloop(i,a,b) for (int i = a ; i>=b;i--)
#define tc(t) int t; cin >> t; while (t--)
#define arrip(a,n)  int a[n]; fo(i, n) cin >> a[i];
#define arrop(a,n)  fo(i,n) cout<<a[i]<<" ";
#define pb push_back
#define mp make_pair
#define itr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626

#define fio ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define rr return 0
#define prec(n) fixed<<setprecision(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int> >
#define inf (int)(1e18)
#define ini(a, i) memset(a, i, sizeof(a))
#define vi vector<int>
#define fi first
#define se second
#define endl "\n"
#define pi pair<int, int>
#define vpi vector<pi>
#define sz(s) s.size()
#define bits(n) __builtin_popcount(n)//Count set bits

const int MAXN = (int)((1e5) + 100);
int gcd(int a, int b) { if (a == 0) return b; return gcd(b % a, a);}
int max(int a, int b) {if (a > b) return a; else return b;}
int min(int a, int b) {if (a < b) return a; else return b;}

int32_t main()
{
#ifndef ONLINE_JUDGE
	freopen("chkkki.txt", "r", stdin);
	freopen("chkkko.txt", "w", stdout);
#endif
	fio;

	int n;
	cin >> n;

	if (n == 7 || n == 5 || n == 3)
		cout << "Yes" << endl;
	else
		cout << "No" << endl;
}


#include<stdio.h>
int main()
{
int a;
  scanf("%d",&a);
if(a==3 || a==5 ||a==7) printf("YES");
else printf("NO");

return 0;
}


#include <stdio.h>

int main()
{
	int a;

	scanf("%d\n",&a);

    if(a==3){
		printf("YES\n");
	}
	else if(a==5){
		printf("YES\n");
	}
	else if(a==7){
		printf("YES\n");
	}
    else {
		printf("NO\n");
    }

	return 0;
}


#include <stdio.h>

int main(void){
    int n;
    scanf("%d", &n);

  	if (n==3||n==5||n==7){
    printf("YES");
    }else{
      printf("NO");
    }
    return 0;
}


#include<stdio.h>
int main() {
  int a;
  scanf("%d", &a);
  if(a == 3 || a == 5 || a == 7) {
      printf("Yes");
  } else {
      printf("No");
  }
}


#include <stdio.h>
int main(void){
    int x;

    scanf("%d", &x);

    if(x == 3 || x == 5 || x == 7){
        printf("Yes\n");
    }else{
        printf("No\n");
    }

    return 0;

}


#include <stdio.h>
int main(void){
    int N;

    scanf("%d", &N);

    if(N == 3 || N == 5 || N == 7){
        printf("Yes\n");
    }else{
        printf("No\n");
    }

}


function main(input){
    input=input.split(' ');
    x=parseInt(input[0],10)
    if (x==3 ||x==5 || x==7){
        console.log("YES")
    }else{
        console.log("NO")
    }

}

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


function main(input) {
  var x = input[0]-0;
  var ans = "NO";
  switch(x){
    case 7:
    case 5:
    case 3:
      ans = "YES";
  }
  console.log(ans);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8').trim().split("\n"))


function main(input) {
  const X = parseInt(input, 10);
  if(X==3||X==5||X==7){
    console.log("YES");
  }else{
    console.log("NO");
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


function Main(input){
    const N = input.trim();
    let answer = 0;
    const array = ['3', '5', '7']
    const DFS = (N, num753) => {
        // 753の数値を含んでいるかチェック
        const contains357 = array.map(val => num753.includes(val)).reduce((a, b) => a && b);
        // 桁数上限に達成
        if(N.length == num753.length){
            if(contains357 && Number(num753) <= Number(N)) answer++;
            return;
        }
        // 現在の数値をチェック
        if(contains357 && Number(num753) <= Number(N)) answer++;
        // 3,5,7を入れていく
        array.map(val => DFS(N, num753 + val));
    }
    // 一桁目を入れる
    array.map(val => DFS(N, val));
    console.log(answer);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split("\n");
//	tmp = input[1].split(" ");
	//文字列から10進数に変換するときはparseIntを使います
	var a = parseInt(input[0], 10);

    if(a==7||a==5||a==3){console.log('Yes')}
    else{console.log('No')}

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


process.stdin.resume();
process.stdin.setEncoding('utf8');

var lines = []
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

reader.on('line', (line) => {
  lines.push(line);
});

reader.on('close', () => {
  var N = lines[0];
  var diff = [];
  for(var i=0; i<N.length-2; i++){
    var pick_num = N.slice(i, i+3);
    var sabun = Math.abs(753-pick_num);
    diff.push(sabun);
  }
  var result = Math.min(...diff).toString()
  console.log(result);
});


package main

import "fmt"

func main() {
	var x int
	fmt.Scan(&x)
	if x == 3 || x == 5 || x == 7 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}


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() {
	X := getInt()

	if X == 3 || X == 5 || X == 7 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

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 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 (
	"bufio"
	"fmt"
	"math"
	"os"
	"reflect"
	"sort"
	"strconv"
	"strings"
	// "regexp"
)

/* sort */
type pair struct {
	index  int64
	p1, p2 interface{}
}
type pairs []pair

func (slice pairs) Len() int {
	return len(slice)
}

func (slice pairs) Less(i, j int) bool {
	return slice[i].index < slice[j].index
}

func (slice pairs) Swap(i, j int) {
	slice[i], slice[j] = slice[j], slice[i]
}

/* sort */
type Int64Slice []int64

func (slice Int64Slice) Len() int {
	return len(slice)
}

func (slice Int64Slice) Less(i, j int) bool {
	return slice[i] < slice[j]
}

func (slice Int64Slice) Swap(i, j int) {
	slice[i], slice[j] = slice[j], slice[i]
}
func Int64s(a []int64)                    { sort.Sort(Int64Slice(a)) }
func Int64sSliceAreSorted(a []int64) bool { return sort.IsSorted(Int64Slice(a)) }

const (
	initialBufSize = 1e4
	maxBufSize     = 1e8
	INF            = 1e8
)

var (
	scanner = bufio.NewScanner(os.Stdin)
	writer  = bufio.NewWriter(os.Stdout)
	di      = []int64{-1, 0, 1, 0}
	dj      = []int64{0, -1, 0, 1}
)

func main() {
	buf := make([]byte, initialBufSize)
	scanner.Buffer(buf, maxBufSize)
	scanner.Split(bufio.ScanWords)
	X := readInt()
	if X == 3 || X == 5 || X == 7 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

/*==========================================
 *             Library
 *==========================================*/
func NextPermutation(x sort.Interface) bool {
	n := x.Len() - 1
	if n < 1 {
		return false
	}
	j := n - 1
	for ; !x.Less(j, j+1); j-- {
		if j == 0 {
			return false
		}
	}
	l := n
	for !x.Less(j, l) {
		l--
	}
	x.Swap(j, l)
	for k, l := j+1, n; k < l; {
		x.Swap(k, l)
		k++
		l--
	}
	return true
}
func doubleAry(h int64, w int64, init int64) (res [][]int64) {
	res = make([][]int64, h)
	for i := int64(0); i < h; i++ {
		res[i] = make([]int64, w)
		for j := int64(0); j < w; j++ {
			res[i][j] = init
		}
	}
	return
}

func aryEq(a []int64, b []int64) bool {
	return reflect.DeepEqual(a, b)
}

func clone(n []int64) (r []int64) {
	r = make([]int64, len(n))
	for i := 0; i < len(n); i++ {
		r[i] = n[i]
	}
	return
}
func write(s string) {
	writer.WriteString(s)
}

func print() {
	writer.Flush()
}

// scanner.Split(bufio.ScanWords) をコメントアウトしないと使用不可
func readLine() (s string) {
	if scanner.Scan() {
		s = scanner.Text()
	}
	return s
}

func readInt() (read int64) {
	scanner.Scan()
	read, err := strconv.ParseInt(scanner.Text(), 10, 64)
	if err != nil {
		panic(err)
	}
	return
}

func readFloat() (read float64) {
	scanner.Scan()
	read, err := strconv.ParseFloat(scanner.Text(), 64)
	if err != nil {
		panic(err)
	}
	return
}

func readRunes() (read []rune) {
	scanner.Scan()
	for _, v := range scanner.Text() {
		read = append(read, v)
	}
	return
}

func readString() (read string) {
	scanner.Scan()
	read = scanner.Text()
	return
}

func readStrings() (read []string) {
	scanner.Scan()
	for _, v := range scanner.Text() {
		read = append(read, string(v))
	}
	return
}

func s2i(s string) int64 {
	var intVal, e = strconv.ParseInt(s, 10, 64)
	if e != nil {
		panic(e)
	}
	return intVal
}

func i2s(i int64) string {
	var strVal = strconv.FormatInt(i, 10)
	return strVal
}

func s2f(s string) float64 {
	var floatVal, e = strconv.ParseFloat(s, 64)
	if e != nil {
		panic(e)
	}
	return floatVal
}

func abs(i int64) int64 {
	return int64(math.Abs(float64(i)))
}

func max(a ...int64) int64 {
	ans := int64(0)
	for i, v := range a {
		if i == 0 {
			ans = v
		}
		if ans < v {
			ans = v
		}
	}
	return ans
}
func min(a ...int64) int64 {
	ans := int64(0)
	for i, v := range a {
		if i == 0 {
			ans = v
		}
		if ans > v {
			ans = v
		}
	}
	return ans
}

func sum(i []int64) int64 {
	sum := int64(0)
	for _, val := range i {
		sum += val
	}
	return sum
}

func split(s string) []string {
	return strings.Fields(s)
}

func strAry2intAry(strs []string) []int64 {
	var ret = make([]int64, 0, len(strs))
	for _, str := range strs {
		var intVal = s2i(str)
		ret = append(ret, intVal)
	}
	return ret
}

func intAry2strAry(nums []int64) []string {
	var ret = make([]string, 0, len(nums))
	for _, num := range nums {
		var strVal = i2s(num)
		ret = append(ret, strVal)
	}
	return ret
}

func ary2str(strs []string) string {
	return strings.Join(strs, " ")
}

func reverse(res []int64) []int64 {
	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}
	return res
}
func reverseStr(res []string) []string {
	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}
	return res
}

func ini(res []int, init int) {
	if len(res) == 0 {
		return
	}
	res[0] = init
	for i := 0; i < len(res); i++ {
		copy(res[i:], res[:i])
	}
}

//
// func regexpExample() {
//     // Your code here!
//     var str = "13:20"
//     r := regexp.MustCompile(`(\d+):(\d+)`)
//     fmt.Println(r.FindStringSubmatch(str))
// }

// type Country struct {
//     gold int
//     silver int
//     blonze int
// }

// // 複数ソートのサンプル
// func stableSortExample() []Country{
//     var country = []Country {
//         {gold:1, silver:2, blonze:3},
//         {gold:1, silver:2, blonze:3},
//         {gold:1, silver:3, blonze:2},
//         {gold:1, silver:3, blonze:3},
//     }
//     sort.SliceStable(country, func(i, j int) bool { return country[i].blonze > country[j].blonze })
//     sort.SliceStable(country, func(i, j int) bool { return country[i].silver > country[j].silver })
//     sort.SliceStable(country, func(i, j int) bool { return country[i].gold > country[j].gold })
//     return country
// }


package main

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

/*
var rdr = bufio.NewReaderSize(os.Stdin, 1000000)
// readLine can read long line string (at least 10^5)
func readLine() string {
	buf := make([]byte, 0, 1000000)
	for {
		l, p, e := rdr.ReadLine()
		if e != nil {
			panic(e)
		}
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}
// NextLine reads a line text from stdin, and then returns its string.
func NextLine() string {
	return readLine()
}
*/

var sc = bufio.NewScanner(os.Stdin)

// NextLine reads a line text from stdin, and then returns its string.
func NextLine() string {
	sc.Scan()
	return sc.Text()
}

// NextIntsLine reads a line text, that consists of **ONLY INTEGERS DELIMITED BY SPACES**, from stdin.
// And then returns intergers slice.
func NextIntsLine() []int {
	ints := []int{}
	intsStr := NextLine()
	tmp := strings.Split(intsStr, " ")
	for _, s := range tmp {
		integer, _ := strconv.Atoi(s)
		ints = append(ints, integer)
	}
	return ints
}

// NextStringsLine reads a line text, that consists of **STRINGS DELIMITED BY SPACES**, from stdin.
// And then returns strings slice.
func NextStringsLine() []string {
	str := NextLine()
	return strings.Split(str, " ")
}

// NextRunesLine reads a line text, that consists of **ONLY CHARACTERS ARRANGED CONTINUOUSLY**, from stdin.
// Ant then returns runes slice.
func NextRunesLine() []rune {
	return []rune(NextLine())
}

// Max returns the max integer among input set.
// This function needs at least 1 argument (no argument causes panic).
func Max(integers ...int) int {
	m := integers[0]
	for i, integer := range integers {
		if i == 0 {
			continue
		}
		if m < integer {
			m = integer
		}
	}
	return m
}

// Min returns the min integer among input set.
// This function needs at least 1 argument (no argument causes panic).
func Min(integers ...int) int {
	m := integers[0]
	for i, integer := range integers {
		if i == 0 {
			continue
		}
		if m > integer {
			m = integer
		}
	}
	return m
}

// PowInt is integer version of math.Pow
func PowInt(a, e int) int {
	if a < 0 || e < 0 {
		panic(errors.New("[argument error]: PowInt does not accept negative integers"))
	}
	fa := float64(a)
	fe := float64(e)
	fanswer := math.Pow(fa, fe)
	return int(fanswer)
}

// AbsInt is integer version of math.Abs
func AbsInt(a int) int {
	fa := float64(a)
	fanswer := math.Abs(fa)
	return int(fanswer)
}

// DeleteElement returns a *NEW* slice, that have the same and minimum length and capacity.
// DeleteElement makes a new slice by using easy slice literal.
func DeleteElement(s []int, i int) []int {
	if i < 0 || len(s) <= i {
		panic(errors.New("[index error]"))
	}
	// appendのみの実装
	n := make([]int, 0, len(s)-1)
	n = append(n, s[:i]...)
	n = append(n, s[i+1:]...)
	return n
}

// Concat returns a *NEW* slice, that have the same and minimum length and capacity.
func Concat(s, t []rune) []rune {
	n := make([]rune, 0, len(s)+len(t))
	n = append(n, s...)
	n = append(n, t...)
	return n
}

// UpperRune is rune version of `strings.ToUpper()`.
func UpperRune(r rune) rune {
	str := strings.ToUpper(string(r))
	return []rune(str)[0]
}

// LowerRune is rune version of `strings.ToLower()`.
func LowerRune(r rune) rune {
	str := strings.ToLower(string(r))
	return []rune(str)[0]
}

// ToggleRune returns a upper case if an input is a lower case, v.v.
func ToggleRune(r rune) rune {
	var str string
	if 'a' <= r && r <= 'z' {
		str = strings.ToUpper(string(r))
	} else if 'A' <= r && r <= 'Z' {
		str = strings.ToLower(string(r))
	} else {
		str = string(r)
	}
	return []rune(str)[0]
}

// ToggleString iteratively calls ToggleRune, and returns the toggled string.
func ToggleString(s string) string {
	inputRunes := []rune(s)
	outputRunes := make([]rune, 0, len(inputRunes))
	for _, r := range inputRunes {
		outputRunes = append(outputRunes, ToggleRune(r))
	}
	return string(outputRunes)
}

// Strtoi is a wrapper of `strconv.Atoi()`.
// If `strconv.Atoi()` returns an error, Strtoi calls panic.
func Strtoi(s string) int {
	if i, err := strconv.Atoi(s); err != nil {
		panic(errors.New("[argument error]: Strtoi only accepts integer string"))
	} else {
		return i
	}
}

// sort package (snippets)
//sort.Sort(sort.IntSlice(s))
//sort.Sort(sort.Reverse(sort.IntSlice(s)))
//sort.Sort(sort.Float64Slice(s))
//sort.Sort(sort.StringSlice(s))

// copy function
//a = []int{0, 1, 2}
//b = make([]int, len(a))
//copy(b, a)

/*******************************************************************/

var S []rune

func main() {
	S = NextRunesLine()
	ans := 1000000
	for i := 0; i < len(S)-2; i++ {
		rs := S[i : i+3]
		num, _ := strconv.Atoi(string(rs))
		if ans > AbsInt(num-753) {
			ans = AbsInt(num - 753)
		}
	}
	fmt.Println(ans)
}


package main

import (
	"fmt"
)

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

	if x%3 == 0 || x%5 == 0 || x%7 == 0 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}

}


X = int(input())

if X in [7, 5, 3]:
    print('YES')
else:
    print('NO')


puts [3,5,7].include?(gets.to_i) ? 'YES' : 'NO'


def get_i() #空白区切の入力を数値(整数)の配列で返す
  return gets.chomp.split(" ").map(&:to_i)
end
def get_f() #空白区切の入力を数値(実数)の配列で返す
  return gets.chomp.split(" ").map(&:to_f)
end
def get() #空白区切の入力を文字列の配列で返す
  return gets.chomp.split(" ")
end
def get_nsp() #入力されたものを一文字ずつに区切った文字列の配列で返す
  return gets.chomp.split("")
end
def yn_judge(bool,y="Yes",n="No") #boolに真偽を投げることで、trueならy、falseならnの値を出力する
  return bool ? y : n
end
def array(size,n=1,init=nil) #nに配列の次元数、sizeに配列の大きさ、initに初期値を投げることでその配列を返す
  if n==1
    return Array.new(size){init}
  else
    return Array.new(n).map{Array.new(size){init}}
  end
end

x=gets.to_i
if x==7 or x==5 or x==3
  puts "YES"
else
  puts "NO"
end


a = gets.to_i
if a < 8 && 2 < a && a%2 == 1
  puts 'YES'
else
  puts 'NO'
end


if [3,5,7].include?(gets.chomp)
  puts "YES"
else
  puts "NO"
end


s=gets.to_i
a=[3,5,7]
puts (a.include?(s))?  :Yes : :No


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

pub 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 x: usize = read();
    println!(
        "{}",
        match x {
            5 | 3 | 7 => "YES",
            _ => "NO",
        }
    )
}


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

//https://qiita.com/tubo28/items/e6076e9040da57368845
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(){
    match read::<usize>() {
        7 | 5 | 3 => println!("YES"),
        _ => println!("NO"),
    }
}


use std::io;

fn read_i32_exn() -> i32 {
	let mut n = String::new();
	io::stdin().read_line(&mut n).expect("Failed to input");
	(*n).trim().parse::<i32>().unwrap()

}

fn main() {
   	let x = read_i32_exn();
	println!("{}",match x { 3|5|7 => "YES", _x => "NO",});

}


// use proconio::marker::Chars;
use proconio::{fastout, input};
// use std::cmp::{max, min};

#[fastout]
fn main() {
    input! {
        x: usize
    };

    if x == 5 || x == 7 {
        println!("YES")
    } else {
        println!("NO")
    }
}


use proconio::input;

fn main() {

    let  a : [i128 ; 3 ] = [ 7 ,5 , 3 ];
    let mut _x : i128 ;
    input!{

   x: i128 ,

   }

   if a.contains(&x){
       println!("Yes");
   }else{
       println!("No");
   }
}


use proconio::input;

fn main() {

    let  a : [i128 ; 3 ] = [ 7 ,5 , 3 ];
    let mut x : i128 ;
    input!{

   x: i128 ,

   }

   if a.contains(&x){
       println!("Yes");
   }else{
       println!("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)}
    }
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    func count() -> Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
}
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)
}
#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)!}
}

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

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

let X = readInt()!
print(X == 3 || X == 5 || X == 7 ? "YES" : "NO")


var tmp: String? = readLine()
var tmp2: String = tmp!
var n = Int(tmp2)!

if n == 3 || n == 5 || n == 7{
    print("YES")
}else{
    print("NO")
}


let inputLine: String = readLine()!
let x: Int = Int(inputLine)!

if x == 3 || x == 5 || x == 7 {
    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)}
    }
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    func count() -> Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
}
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)
}
#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)!}
}

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

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

let X = readInt()!
print(X == 3 || X == 5 || X == 7 ? "Yes" : "No")


import * as fs from 'fs';

namespace AtCoder.abc114 {
    export class Program {
        static main(inp: string): void {

            const x: number = parseInt(inp);
            if (x === 3 || x === 5 || x === 7) {
                console.log('YES');
            } else {
                console.log('NO');
            }
        }
    }
}

AtCoder.abc114.Program.main(fs.readFileSync('/dev/stdin', 'utf8').trim());


console.log(require('fs').readFileSync('/dev/stdin','utf8').match(/7|5|3/)?'YES':'NO')


var input: string = require('fs').readFileSync('/dev/stdin', 'utf8');
var parts = input.split(" ");
var X = parseInt(parts[0]);
if (X == 3 || X == 5 || X == 7) {
    console.log("YES");
} else {
    console.log("NO");
}


'use strict'
function Main(input) {
  const ar = input.split("\n").map(x => x.split(" "));
  const X = Number(ar[0]);

  const ans = [3, 5, 7].includes(X) ? "Yes" : "No";
  console.log(ans)
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


a, op, b = map(str,input().split())
print(eval(a + op + b))


A, op, B = input().split()
if op == "+":
    print(int(A) + int(B))
else:
    print(int(A) - int(B))


if __name__ == "__main__":
    a,b,c = input().split()
    if (b == '+'):
        print (int(a) + int(c))
    else:
        print (int(a) - int(c))


A, op, B = input().split()
if op == '-':
  print(int(A) - int(B))
else:
  print(int(A) + (B))


A, op, B = input().split()
if op = '-':
  print(A - B)
else:
  print(A + B)


A, op, B = list(map(int,input().split()))
if op = '+':
  print(A + B)
else:
  print(A - B)


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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        String[] firstLine = input.readLine().split(" ");
        long A = Long.parseLong(firstLine[0]);
        String op = firstLine[1];
        long B = Long.parseLong(firstLine[2]);

        if (op.equals("+")) {
            System.out.println(A+B);
        } else {
            System.out.println(A-B);
        }
    }
}


import java.util.*;
import java.io.*;
import static java.lang.Math.*;

public class Main {
    public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);

		// 入力
		int a = sc.nextInt();
		String s = sc.next();
		int b = sc.nextInt();

		// 計算
		int result = a - b;
		if(s.equals("+")) result = a + b;

		// 出力
		System.out.println(result);
	}

	public static class Scanner {
		private BufferedReader br; private StringTokenizer tok;
		public Scanner(InputStream is) throws IOException { br = new BufferedReader(new InputStreamReader(is));}
		private void getLine() throws IOException { while(!hasNext()) tok = new StringTokenizer(br.readLine());}
		private boolean hasNext() { return tok != null && tok.hasMoreTokens();}
		public String next() throws IOException { getLine(); return tok.nextToken();}
		public int nextInt() throws IOException { return Integer.parseInt(next());}
		public long nextLong() throws IOException { return Long.parseLong(next());}
		public double nextDouble() throws IOException { return Double.parseDouble(next());}
	}
}


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

public class Main {
    public static void main(String[] args)throws Exception {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        String [] formula = input.readLine().split("\\s+");
        int x = Integer.parseInt(formula[0]);
        int y = Integer.parseInt(formula[2]);
        System.out.println(formula[1].equals("+")?(x + y):(x - y));

    }
}


import java.util.*;
class Main{
	public static void main(String args[]){
    	Scanner s= new Scanner(System.in);
      	int a=s.nextInt();
      	String str=s.next().charAt(0);
      //System.out.println(str);
      	int b=s.nextInt();

      if(str=='+'){
      	System.out.println(a+b);
      }else{
      System.out.println(a-b);}

    }
}


import java.util.*;
class Main{
	public static void main(String args[]){
    	Scanner s= new Scanner(System.in);
      	String str=s.next();
      //System.out.println(str);
      	int a=0;
       	int b=0;
      	int j=1;
      	char sym='+';
      	for(int i=0;i<str.length();i++){
          	if(str.charAt(i)=='+' || str.charAt(i)=='-'){
            	 j=i;
              sym=str.charAt(i);
              break;
            }
        	a=a*10+str.charAt(i)-'0';

        }
         for(int i=j+1;i<str.length();i++){

        	b=b*10+str.charAt(i)-'0';
        }
      if(sym=='+'){
      	System.out.println(a+b);
      }else{
      System.out.println(a-b);}

    }
}


import java.util.*;
class Main{
	public static void main(String args[]){
    	Scanner s= new Scanner(System.in);
      	String str=s.next();
      System.out.println(str);
      	int a=0;
       	int b=0;
      	int j=1;
      	char sym='';
      	for(int i=0;i<str.length();i++){
          	if(str.charAt(i)=='+' || str.charAt(i)=='-'){
            	int j=i;
              sym=str.charAt(i);
              break;
            }
        	a=a*10+str.charAt(i)-'0';

        }
         for(int i=j+1;i<str.length();i++){

        	b=b*10+str.charAt(i)-'0';
        }
      if(sym=='+'){
      	System.out.println(a+b);
      }else{
      System.out.println(a-b);}

    }
}


#include<stdio.h>
int main(void)
{
	int a,c;
	char b;
	scanf("%d %c %d",&a,&b,&c);
	if(b=='+'){
		printf("%d\n",a+c);
	}
	else if(b=='-'){
		printf("%d\n",a-c);
	}
	return 0;
}


#include <cstdio>
int a,b,c,d,i,j,k;
char t;
int main(){
	scanf("%d %c %d",&a,&t,&b);
	if (t=='-'){
		printf("%d\n",a-b);
	}
	if (t=='+'){
		printf("%d\n",a+b);
	}
}


#include <stdio.h>
int main()
{
	long long a,b;
	char c;
		scanf("%lld",&a);
		scanf(" %c ",&c);
		scanf("%lld",&b);
		if(c=='-')
		{
			printf("%lld\n",a-b);
		}
		else
		{
			printf("%lld\n",a+b);
		}
	return 0;
}


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

long long int bigmod (int a, int b, int m)
{
    if (b == 0) return 1%m;
    long long int x = bigmod(a,b/2,m);
    x = (x*x)%m;
    if (b%2==1) x = (x*a)%m;
    return x;
}

int main ()
{
    int n,i,temp;
    long long int ans;
    cin >> n;
    temp =n;
    vector <int> a(n);
    fill(a.begin(), a.end(),0);
    while(temp--)
    {
        cin >> i;
        a[i]++;
    }

    if ( n %2){
        if (a[0]!= 1)
        ans = 0;
        else{
        for ( i = 2; i<n ; i+=2)
            {
                if (a[i]!= 2)
                {
                    ans = 0;
                    break;
                }
            }
            }
    }
    else{
        for ( i= 1 ;i<n ;i+=2)
        {
            if (a[i]!= 2)
            {
                ans = 0;
                break;
            }
        }

    }
    if (ans != 0){
        n=n/2;
       int m=1 ;
     for ( i = 0; i<9;i++)
        m=m*10;
     m = m+7;
        ans = bigmod (2,n,m);
    }
    cout << ans <<"\n";
     return 0;
    }


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

int main() {
  string op;
  int A, B;
  cin >> op >> A >> B;

  if (op == "+"){
	cout << A + B << endl;
  }
  else if (op == "-"){
    cout << A - B << endl;
  }
}


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

int main() {
  int a, b;
  string p;
  cin >> a, p, b;

  if (p == "+") {
    cout << a + b << endl;
  }

  else if (p == "-") {
    cout << a - b << endl;
  }
}


#include<stdio.h>

int main()
{
    int a, b;
    char ch;
    scanf("%d %c %d", &a, &ch, &b);
    if(ch == '+') {
        printf("%d\n", a + b);
    }
    else {
        printf("%d\n", a - b);
    }
    return 0;
}


#include<stdio.h>
int main()
{
	unsigned long long A,B;
	char s;
	scanf("%llu %c %llu",&A,&s,&B);
	long long c;
	if(s=='+')
	{
		c=A+B;
		printf("%lld\n",c);
	}
	if(s=='-')
	{
		c=A-B;
		printf("%lld\n",c);
	}
	return 0;
}


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


#include <stdio.h>

int main()
{
    int a,b;
    char o;
    scanf("%d%c%d",&a,&o,&b);
    if(o=="+")
    {
        printf("%d",a+b);
    }
    else
    {
        printf("%d",a-b);
    }
    return 0;
}


#include<stdio.h>

int main()

{
    int A,B;
    char op;

    scanf("%d %c %d",&A,&op,&B);

    if(op ='+')
        {
      //  printf("%d op %d",A,B);
        printf("%d",A+B);
        }
    else if(op ='-')
      //  printf("%d op %d",A,B);
        printf("%d",A-B);

}


#include<stdio.h>
int main()
{
  int a,b;
  int op;
  scanf("%d%c%d",&a,&op,&b);
  if(op==+)
    printf("%d",a+b);
  else
    printf("%d",a-b);
  return 0;
}


input = require("fs").readFileSync("/dev/stdin", "utf8");
console.log(eval(input));


"use strict";

const main = arg => {
    const formula = arg.split("\n")[0].split(" ");
    const A   = parseInt(formula[0]);
    const ope = formula[1];
    const B   = parseInt(formula[2]);

    console.log(ope == "+" ? A + B : A - B);
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


"use strict";

function main(input){
  const args = input.trim().split(' ');
  if(args[1] == '+')
    console.log(parseInt(args[0], 10) + parseInt(args[2], 10));
  else
    console.log(parseInt(args[0], 10) - parseInt(args[2], 10));
}

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


function main(input) {
  input = input.trim();
  const a = input.split(' ').map(Number);

  if(a[1]=='+'){
    console.log(parseInt(a[0])+parseInt(a[2]))
  }else if(a[1]=='-'){
    console.log(parseInt(a[0])-parseInt(a[2]))
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


function main(input) {
  input = input.trim();
  const a = input.split(' ').map(Number);

  if(a[1]=='+'){
    console.log(a[0]+a[2])
  }else if(a[1]=='-'){
    console.log(a[0]-a[2])
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


function main(input) {
  input = input.trim();
  const a = input.split(' ');

  if(a[1]=='+'){
    console.log(a[0]+a[2])
  }else if(a[1]=='-'){
    console.log(a[0]-a[2])
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


package main
import "fmt"
var (a, b int
     c string)
func main() {

  fmt.Scan(&a,&c, &b)
  switch c[0]{
    case '+':
    fmt.Println(a+b)
    case '-':
    fmt.Println(a-b)
    case '*':
    fmt.Println(a*b)
    case '/':
    fmt.Println(a/b)

  }

}


package main

import (
  "fmt"
)

func main() {
  var a, b int; var op string
  fmt.Scan(&a, &op, &b)
  var c int
  if op == "+" {c = a + b} else {c = a - b}
  fmt.Println(c)
}


package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"reflect"
	"sort"
	"strconv"
	"strings"
	// "regexp"
)

/* sort */
type pair struct {
	index  int64
	p1, p2 interface{}
}
type pairs []pair

func (slice pairs) Len() int {
	return len(slice)
}

func (slice pairs) Less(i, j int) bool {
	return slice[i].index < slice[j].index
}

func (slice pairs) Swap(i, j int) {
	slice[i], slice[j] = slice[j], slice[i]
}

/* sort */
type Int64Slice []int64

func (slice Int64Slice) Len() int {
	return len(slice)
}

func (slice Int64Slice) Less(i, j int) bool {
	return slice[i] < slice[j]
}

func (slice Int64Slice) Swap(i, j int) {
	slice[i], slice[j] = slice[j], slice[i]
}
func Int64s(a []int64)                    { sort.Sort(Int64Slice(a)) }
func Int64sSliceAreSorted(a []int64) bool { return sort.IsSorted(Int64Slice(a)) }

const (
	initialBufSize = 1e4
	maxBufSize     = 1e8
	INF            = 1e8
)

var (
	scanner = bufio.NewScanner(os.Stdin)
	writer  = bufio.NewWriter(os.Stdout)
	di      = []int64{-1, 0, 1, 0}
	dj      = []int64{0, -1, 0, 1}
	di8     = []int64{-1, -1, 0, 1, 1, 1, 0, -1}
	dj8     = []int64{0, -1, -1, -1, 0, 1, 1, 1}
)

func main() {
	buf := make([]byte, initialBufSize)
	scanner.Buffer(buf, maxBufSize)
	scanner.Split(bufio.ScanWords)
	A, op, B := readInt(), readString(), readInt()
	if op == "+" {
		fmt.Println(A + B)
	} else {
		fmt.Println(A - B)
	}
}

/*==========================================
 *             Library
 *==========================================*/
func NextPermutation(x sort.Interface) bool {
	n := x.Len() - 1
	if n < 1 {
		return false
	}
	j := n - 1
	for ; !x.Less(j, j+1); j-- {
		if j == 0 {
			return false
		}
	}
	l := n
	for !x.Less(j, l) {
		l--
	}
	x.Swap(j, l)
	for k, l := j+1, n; k < l; {
		x.Swap(k, l)
		k++
		l--
	}
	return true
}
func doubleAry(h int64, w int64, init int64) (res [][]int64) {
	res = make([][]int64, h)
	for i := int64(0); i < h; i++ {
		res[i] = make([]int64, w)
		for j := int64(0); j < w; j++ {
			res[i][j] = init
		}
	}
	return
}

func aryEq(a []int64, b []int64) bool {
	return reflect.DeepEqual(a, b)
}

func clone(n []int64) (r []int64) {
	r = make([]int64, len(n))
	for i := 0; i < len(n); i++ {
		r[i] = n[i]
	}
	return
}
func write(s string) {
	writer.WriteString(s)
}

func print() {
	writer.Flush()
}

// scanner.Split(bufio.ScanWords) をコメントアウトしないと使用不可
func readLine() (s string) {
	if scanner.Scan() {
		s = scanner.Text()
	}
	return s
}

func readInt() (read int64) {
	scanner.Scan()
	read, err := strconv.ParseInt(scanner.Text(), 10, 64)
	if err != nil {
		panic(err)
	}
	return
}

func readFloat() (read float64) {
	scanner.Scan()
	read, err := strconv.ParseFloat(scanner.Text(), 64)
	if err != nil {
		panic(err)
	}
	return
}

func readRunes() (read []rune) {
	scanner.Scan()
	for _, v := range scanner.Text() {
		read = append(read, v)
	}
	return
}

func readString() (read string) {
	scanner.Scan()
	read = scanner.Text()
	return
}

func readStrings() (read []string) {
	scanner.Scan()
	for _, v := range scanner.Text() {
		read = append(read, string(v))
	}
	return
}

func s2i(s string) int64 {
	var intVal, e = strconv.ParseInt(s, 10, 64)
	if e != nil {
		panic(e)
	}
	return intVal
}

func i2s(i int64) string {
	var strVal = strconv.FormatInt(i, 10)
	return strVal
}

func s2f(s string) float64 {
	var floatVal, e = strconv.ParseFloat(s, 64)
	if e != nil {
		panic(e)
	}
	return floatVal
}

func abs(i int64) int64 {
	return int64(math.Abs(float64(i)))
}

func max(a ...int64) int64 {
	ans := int64(0)
	for i, v := range a {
		if i == 0 {
			ans = v
		}
		if ans < v {
			ans = v
		}
	}
	return ans
}
func min(a ...int64) int64 {
	ans := int64(0)
	for i, v := range a {
		if i == 0 {
			ans = v
		}
		if ans > v {
			ans = v
		}
	}
	return ans
}

func sum(i []int64) int64 {
	sum := int64(0)
	for _, val := range i {
		sum += val
	}
	return sum
}

func split(s string) []string {
	return strings.Fields(s)
}

func strAry2intAry(strs []string) []int64 {
	var ret = make([]int64, 0, len(strs))
	for _, str := range strs {
		var intVal = s2i(str)
		ret = append(ret, intVal)
	}
	return ret
}

func intAry2strAry(nums []int64) []string {
	var ret = make([]string, 0, len(nums))
	for _, num := range nums {
		var strVal = i2s(num)
		ret = append(ret, strVal)
	}
	return ret
}

func ary2str(strs []string) string {
	return strings.Join(strs, " ")
}

func reverse(res []int64) []int64 {
	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}
	return res
}
func reverseStr(res []string) []string {
	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}
	return res
}

func ini(res []int, init int) {
	if len(res) == 0 {
		return
	}
	res[0] = init
	for i := 0; i < len(res); i++ {
		copy(res[i:], res[:i])
	}
}

//
// func regexpExample() {
//     // Your code here!
//     var str = "13:20"
//     r := regexp.MustCompile(`(\d+):(\d+)`)
//     fmt.Println(r.FindStringSubmatch(str))
// }

// type Country struct {
//     gold int
//     silver int
//     blonze int
// }

// // 複数ソートのサンプル
// func stableSortExample() []Country{
//     var country = []Country {
//         {gold:1, silver:2, blonze:3},
//         {gold:1, silver:2, blonze:3},
//         {gold:1, silver:3, blonze:2},
//         {gold:1, silver:3, blonze:3},
//     }
//     sort.SliceStable(country, func(i, j int) bool { return country[i].blonze > country[j].blonze })
//     sort.SliceStable(country, func(i, j int) bool { return country[i].silver > country[j].silver })
//     sort.SliceStable(country, func(i, j int) bool { return country[i].gold > country[j].gold })
//     return country
// }


package main

import "fmt"

func main() {
	var (
		a int
		b string
		c int
	)
	fmt.Scan(&a)
	fmt.Scan(&b)
	fmt.Scan(&c)
	if b == "+" {
		println(a + c)
	}
	if b == "-" {
		println(a - c)
	}
}


package main

import (
	"fmt"
)

func main() {
	var (
		a  int
		op rune
		b  int
	)

	fmt.Scan(&a, &op, &b)

	if op == '+' {
		fmt.Println(a + b)
	} else if op == '-' {
		fmt.Println(a - b)
	}
}


p eval gets


a = gets
puts eval(a)


a, op, b = gets.chomp.split(" ")
a = a.to_i; b = b.to_i
puts op == "+" ? a + b : a - b


a, b, c = gets.chomp.split(" ")
if b == "+"
    puts a + c
else
    puts a - c
end


arr = gets.chomp.split(' ')

if arr[1] == "+"
  puts arr[0].to_i + arr[2].to_i
else
  arr[0].to_i - arr[2].to_i
end


gets.to_i
kekka=gets.chomp.split(" ").map(&:to_i)
m=gets.to_i
m.times{
  p,x=gets.chomp.split(" ").map(&:to_i)
  puts kekka.sum - kekka[p-1] + x
  #kekka_dup=kekka.dup
  #kekka_dup[p-1]=x
  #puts kekka_dup.sum
}


use std::io;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let mut iter = buf.trim().split_whitespace();
	let a:i64 = iter.next().unwrap().parse().ok().unwrap();
	let op = iter.next().unwrap();
	let b:i64 = iter.next().unwrap().parse().ok().unwrap();
	if op == "+" {
		println!("{}", a+b);
	}else{
		println!("{}", a-b);
	}
}


#![allow(non_snake_case)]
#![allow(unused_variables)]
#![allow(dead_code)]

fn main() {
    let (A, op, B): (i64, String, i64) = {
        let mut line: String = String::new();
        std::io::stdin().read_line(&mut line).unwrap();
        let mut iter = line.split_whitespace();
        (
            iter.next().unwrap().parse().unwrap(),
            iter.next().unwrap().to_string(),
            iter.next().unwrap().parse().unwrap()
        )
    };

    let ans = if op.as_str() == "+" {
        A + B
    } else {
        A - B
    };

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


// ref: https://qiita.com/tubo28/items/e6076e9040da57368845
use std::io::{stdin, Read};
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 a: i32 = read();
    let op: String = read();
    let b: i32 = read();

    let ans = match op.chars().next().unwrap() {
        '+' => a + b,
        '-' => a - b,
        _ => unreachable!(),
    };
    println!("{}", ans);
}


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:i128,
        op:char,
        b:i128,
    }
    if op == '+' {
        println!("{}", a + b);
    } else {
        println!("{}", a - b);
    }
}


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:i64,
        op:char,
        b:i64,
    }
    if op == '+' {
        println!("{}", a + b);
    } else {
        println!("{}", a - b);
    }
}


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:i32,
        op:char,
        b:i32,
    }
    if op == '+' {
        println!("{}", a + b);
    } else {
        println!("{}", a - b);
    }
}


let i=readLine()!.characters.split(" ").map{String($0)};print(i[1]=="+" ?Int(i[0])!+Int(i[2])!:Int(i[0])!-Int(i[2])!)


extension String: CollectionType {
    static func getValues(separator: Character = " ") -> [String] {
        return readLine()!.split(separator)
    }
}

let values = String.getValues()
let A = Int64(values[0])!
let op = values[1]
let B = Int64(values[2])!

if op == "+" {
    print("\(A + B)")
} else {
    print("\(A - B)")
}


let i=readLine()!.characters.split(" ").map{String($0)};print(i[1]=="+" ?Int(i[0])!+Int(i[2])!:Int(i[0])!-Int(i[2)!)


let i=readLine()!.characters.split(" ").map{String($0)};print(i[1]=="+" ?Int(i[0])!+Int(i[1])!:Int(i[0])!-Int(i[1])!)


import * as fs from 'fs'

const input = fs.readFileSync('/dev/stdin', 'utf8').split('\n')
const [a, op, b] = input[0].split(' ')
console.log(op === '+' ? +a + +b : +a - +b)


const main = (input) => {
  input = input.split(' ');
  const icon = input[1];
  const A = parseInt(input[0], 10);
  const B = parseInt(input[2], 10);

  if (icon=="+") {
    console.log(A+B);
  }else{
    console.log(A-B);
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


import { Hash } from "crypto";
import { access } from "fs";

class Input {
    private lines: string[];
    constructor(lines: string[]) {
        this.lines = lines;
    }

    public string(): string { return this.lines.shift() as string; }
    public int(): number { return parseInt(this.string()); }
    public intArray(): number[] { return this.string().split(" ").map(n => parseInt(n)); }
    public stringArray(): string[] { return this.string().split(" "); }

    public allLines(): string[] { return this.lines; }
    public allLinesInt(): number[] { return this.lines.map(s => parseInt(s)); }
    public allLinesIntArray(): number[][] { return this.lines.map(s => s.split(" ").map(n => parseInt(n))); }
    public allLinesStringArray(): string[][] { return this.lines.map(s => s.split(" ")); }
}

function calc(stdin: Input) {
    return eval(stdin.string())
}

function main(stdin: string) {
    console.log(calc(new Input(stdin.split("\n"))));
}

if (require.main && require.main.filename.indexOf("Main") >= 0) {
    main(require('fs').readFileSync('/dev/stdin', 'utf8'));
} else {
    main(require('fs').readFileSync('input.txt', 'utf8').trim());
}


import * as fs from 'fs';

const input = fs.readFileSync("/dev/stdin", "utf8").split('\n');
const a:number = +input[0];
const op:string =input[1];
const b:number = +input[2];
if(op == '+'){
	console.log(a+b);
}else{
	console.log(a-b);
}


const main = (input) => {
  input = input.split(' ');
  const icon = input[0];
  const A = parseInt(input[1], 10);
  const B = parseInt(input[2], 10);

  if (icon=="+") {
    console.log(A+B);
  }else{
    console.log(A-B);
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


const main = (input) => {
  input = input.split(' ');
  const icon = "+";
  const A = parseInt(input[0], 10);
  const B = parseInt(input[1], 10);

  if (icon=="+") {
    console.log(A+B);
  }else{
    console.log(A-B);
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));


a,b=map(int,input().split())
print(a*b)


a, b = map(str, input().split())
A = int(a)
B = round(float(b) * 100)
print(A * B // 100)


def main():
    a, b = map(int, input().split())
    ans = a * b
    print(f'{ans}')

if __name__ == '__main__':
    main()


n = int(input())

def solve(n):
    res = 0
    for i in range(2, int(n ** 0.5) + 2):
        cnt = 0
        while n % pow(i, cnt + 1) == 0:
            n /= pow(i, cnt + 1)
            cnt += 1
            if n % pow(i, cnt + 1) != 0:
                res += cnt
                break

    if n != 1:
            res = 1

    return res

print(solve(n))


a, b = int(input())
print(a*b)


a, b = map(input().split())
print(a * b)


/*****Author: Satyajeet Singh, Delhi Technological University************************************/
    import java.io.*;
    import java.util.*;
    import java.text.*;
    import java.lang.*;
    import java.math.*;
public class Main{
/*********************************************Constants******************************************/
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static long mod=(long)1e9+7;
    static long mod1=998244353;
    static ArrayList<Integer> graph[];
    static int pptr=0,pptrmax=0;
    static String st[];
/*****************************************Solution Begins***************************************/
    public static void main(String args[]) throws Exception{
        out.println(pi()*pi());
/****************************************Solution Ends**************************************************/
        out.flush();
        out.close();
    }
/****************************************Template Begins************************************************/
    static void nl() throws Exception{
        pptr=0;
        st=br.readLine().split(" ");
        pptrmax=st.length;
    }
    static void nls() throws Exception{
        pptr=0;
        st=br.readLine().split("");
        pptrmax=st.length;
    }
    static int pi() throws Exception{
        if(pptr==pptrmax)
            nl();
        return Integer.parseInt(st[pptr++]);
    }
    static long pl() throws Exception{
        if(pptr==pptrmax)
            nl();
        return Long.parseLong(st[pptr++]);
    }
    static double pd() throws Exception{
        if(pptr==pptrmax)
            nl();
        return Double.parseDouble(st[pptr++]);
    }
    static String ps() throws Exception{
        if(pptr==pptrmax)
            nl();
        return st[pptr++];
    }
/***************************************Precision Printing**********************************************/
    static void printPrecision(double d){
        DecimalFormat ft = new DecimalFormat("0.0000000000");
        out.println(ft.format(d));
    }
/**************************************Bit Manipulation**************************************************/
    static int countBit(long mask){
        int ans=0;
        while(mask!=0){
            mask&=(mask-1);
            ans++;
        }
        return ans;
    }
/******************************************Graph*********************************************************/
    static void Makegraph(int n){
        graph=new ArrayList[n];
        for(int i=0;i<n;i++)
            graph[i]=new ArrayList<>();
    }
    static void addEdge(int a,int b){
        graph[a].add(b);
    }
    // static void addEdge(int a,int b,int c){
    //     graph[a].add(new Pair(b,c));
    // }
/*********************************************PAIR********************************************************/
    static class Pair{
        int u;
        int v;
        public Pair(int u, int v) {
            this.u = u;
            this.v = v;
        }
        public int hashCode() {
            int hu = (int) (u ^ (u >>> 32));
            int hv = (int) (v ^ (v >>> 32));
            return 31 * hu + hv;
        }
        public boolean equals(Object o) {
            Pair other = (Pair) o;
            return u == other.u && v == other.v;
        }
        public String toString() {
            return "[u=" + u + ", v=" + v + "]";
        }
    }
/******************************************Long Pair*******************************************************/
    static class Pairl{
        long u;
        long v;
        public Pairl(long u, long v) {
            this.u = u;
            this.v = v;
        }
        public int hashCode() {
            int hu = (int) (u ^ (u >>> 32));
            int hv = (int) (v ^ (v >>> 32));
            return 31 * hu + hv;
        }
        public boolean equals(Object o) {
            Pairl other = (Pairl) o;
            return u == other.u && v == other.v;
        }
        public String toString() {
            return "[u=" + u + ", v=" + v + "]";
        }
    }
/*****************************************DEBUG***********************************************************/
    public static void debug(Object... o){
        System.out.println(Arrays.deepToString(o));
    }
/************************************MODULAR EXPONENTIATION***********************************************/
    static long modulo(long a,long b,long c){
        long x=1,y=a%c;
        while(b > 0){
            if(b%2 == 1)
                x=(x*y)%c;
            y = (y*y)%c;
            b = b>>1;
        }
        return  x%c;
    }
/********************************************GCD**********************************************************/
    static long gcd(long x, long y){
        if(x==0)
            return y;
        if(y==0)
            return x;
        long r=0, a, b;
        a = (x > y) ? x : y;
        b = (x < y) ? x : y;
        r = b;
        while(a % b != 0){
            r = a % b;
            a = b;
            b = r;
        }
        return r;
    }
}


import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {

	public static void main(String[] args){
		FastScanner sc = new FastScanner();
		int i = sc.nextInt();
		int j = sc.nextInt();

		System.out.println(i * j);
	}

}

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


/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
			PrintWriter out=new PrintWriter(System.out);
	FastScanner fs=new FastScanner();
		int a=fs.nextInt();
		int b=fs.nextInt();
		int ans=a*b;
		out.println(ans);
		out.close();

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


import java.util.Scanner;						  double(少数)
public class{								  string(文字)
	public static void main(String[] args) {
	    Scanner stdIn= new Scanner(System.in);
	    int x = stdIn.nextInt();
	    int y = stdIn.nextInt();

	    System.out.println(x*y);
    }
}


import java.util.*;

public class Main{
  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();
    long[] a = new long[n];
    long ans = 1;

    for(int i = 0; i < n; i++){
      a[i] = sc.nextLong();
      ans *= a[i];
        if(ans > Math.pow(10, 18)){
          ans = -1;
          break;
        }
    }

    System.out.println(ans);
  }
}


public class Main {
  public static void main(String[] args) {
    int A = new java.util.Scanner(System.in).nextInt();
    int B = new java.util.Scanner(System.in).nextInt();
    int C = A * B;
    System.out.println(C);
  }
}


#include <stdio.h>
int main(){
	int a,b;
	scanf("%d%d",&a,&b);
	printf("%d\n",a*b);
	return 0;
}


#include <cstdio>
#include <cctype>
using namespace std;
typedef long long ll;
void Read(int &x){
    static char c;
    while(!isdigit(c=getchar()));
    x=(c^48);
    while(isdigit(c=getchar()))
        x=x*10+(c^48);
    return;
}
void Print(int x){
    static int i;
    for(i=1;i*10LL<=x;i*=10);
    for(;i;i/=10)
        putchar(x/i%10|48);
    putchar('\n');
    return;
}
int main(){
    int a,b;
    Read(a);
    Read(b);
    Print(a*b);
    return 0;
}


#include<cstdio>
using namespace std;
int main()
{
	int a,b;
	scanf("%d%d",&a,&b);
	printf("%d\n",a*b);
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
int main(){
  int a, b;
  cout << a*b;
}


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

int main() {
int64_t a,c,d;
c=0;
d=0;
char b;
cin>>a;
vector<char> vec(3);
for(int64_t i=0;i<4;i++){
cin>>b;
if(b!='.'){vec.at(d)=b;
           d++;}
}
c=(int64_t)((vec.at(0)-'0')*100+(vec.at(1)-'0')*10+vec.at(2)-'0');
cout<<a*c/100<<endl;
}


#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
int main()
{
  int N;
  cin>>N;
  int A[N];
  for (int i=0;i<N;i++)
    cin>>A;
  int ans=1;
  for(int i=0;i<=A[N];i++)
  {
    ans*=A[N];
  }
  if(ans>pow(10,18))
    cout<<"-1"<<endl;
  else
    cout<<ans<<endl;
  return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define SIZE 100005
#define PI acosl(-1) //3.14159265358979323846264338327950L
#define rep(i, N) for (i = 0; i < N; i++) //制御変数iを用いてN回転
#define array(N, t) (t*)calloc(N, sizeof(t)) //t型N要素の1次元配列を動的確保後0クリア(freeを忘れずに)
#define zero(a); {int iter; rep(iter, sizeof(a)/sizeof((a)[0])) (a)[iter]=0;} //1次元配列aのゼロ初期化?

typedef long long ll; typedef long double ld;
typedef struct node { int data; struct node *next; } Node;

Node *list[SIZE];
int queue[SIZE]; int q_head = 0, q_tail = 0;

void print_log(); //とりあえず文字を出力してどこまで実行できているか確認(for debug)
void printa_int(int *a, int size); //int型の1次元配列aを出力(for debug)
void printl_int(int size); //リンクリストを出力(for debug)
Node* add_node(int i, int data); void free_list(Node* head);
int queue_empty(); int queue_full();
void enqueue(int data); int dequeue();

int main() {
    int A, B;
    scanf("%d %d", &A, &B);
    printf("%d\n", A * B);
    return 0;
}

void print_log() {
    printf("=== print log ===\n");
}
void printa_int(int *a, int size) {
    int i;
    printf("[");
    for (i = 0; i < size; i++)
        printf("%d, ", a[i]);
    printf("]\n");
}
void printl_int(int size) {
    int i;
    Node *t;
    rep(i, size) {
        printf("[%d] ", i);
        for (t = list[i]; t; t = t->next) printf("%d, ", t->data);
        printf("\n");
    }
}
Node* add_node(int i, int data) {
    if (!list[i]) {
        list[i] = (Node*)malloc(sizeof(Node*));
        list[i]->data = data;
    } else {
        Node *t;
        t = list[i];
        list[i] = (Node*)malloc(sizeof(Node*));
        list[i]->data = data;
        list[i]->next = t;
    }
    return list[i];
}
void free_list(Node* head) {
    Node *prev = NULL, *t = head;
    while (t) {
        prev = t;
        t = t->next;
        free(prev);
    }
}
int queue_empty() {
    return q_head == q_tail;
}
int queue_full() {
    return (q_head - 1) % SIZE == q_tail % SIZE;
}
void enqueue(int data) {
    if (queue_full()) {
        printf("full!\n");
        return;
    }
    queue[q_tail++] = data;
    q_tail %= SIZE;
}
int dequeue() {
    if (queue_empty()) {
        printf("empty!\n");
        return -444444;
    }
    int data = queue[q_head++];
    q_head %= SIZE;
    return data;
}


#include <stdio.h>
int main(void){
	int a;
	int b;
	scanf("%d", &a);
	scanf("%d", &b);
	printf("%d\n", a*b);
	return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define rep(i,k,n) for(int (i)=(k);(i)<(n);(i)++)
#define max(a,b) (a)>(b)?(a):(b)
#define min(a,b) (a)<(b)?(a):(b)
#define abs(a) (a)>0 ?(a):-(a)
#define llong long long

int main(){
	int A,B; scanf("%d %d",&A,&B);
	printf("%d",A*B);
	return 0;
}


#include <stdio.h>
int main(){
  int a,b;
  scanf("%d %d",&a,&b);
  printf(a*b);
}


#include <stdio.h>
int main(){
  int a,b;
  scanf("%d %d",a,b);
  printf(a*b);
}


#include<stdio.h>

int main(){

 unsigned long long int a,ans;
 double b;

  (void) scanf("%llu %lf",&a,&b);
  printf("%llu %lf\n",a,b);

  ans=a*(b*100);
  ans=ans/100;

 printf("%llu",ans);

 return 0;
}


function Main(input){
  const values = input.trim().split(' ').map((str)=> parseInt(str));
  const A = values[0];
  const B = values[1];

  console.log(A*B);
}

//固定
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
	input = input.split(" ");
	//文字列から10進数に変換するときはparseIntを使います
	var a = parseInt(input[0], 10);
	var b = parseInt(input[1], 10);
	//出力
	console.log('%d',a*b);
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));