#include<bits/stdc++.h>
//#include<atcoder/all>
using namespace std;
//using namespace atcoder;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define all(x) (x).begin(),(x).end()
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
using Graph = vector<vector<int>>;

// dijkstra
struct edge{ll to, cost;};
typedef pair<ll,ll> P;
struct graph{
  ll V;
  vector<vector<edge> > G;
  vector<ll> d;

  graph(ll n){
    init(n);
  }

  void init(ll n){
    V = n;
    G.resize(V);
    d.resize(V);
    rep(i,V){
      d[i] = INF;
    }
  }

  void add_edge(ll s, ll t, ll cost){
    edge e;
    e.to = t, e.cost = cost;
    G[s].push_back(e);
  }

  void dijkstra(ll s){
    rep(i,V){
      d[i] = INF;
    }
    d[s] = 0;
    priority_queue<P,vector<P>, greater<P> > que;
    que.push(P(0,s));
    while(!que.empty()){
      P p = que.top(); que.pop();
      ll v = p.second;
      if(d[v]<p.first) continue;
      for(auto e : G[v]){
        if(d[e.to]>d[v]+e.cost){
          d[e.to] = d[v]+e.cost;
          que.push(P(d[e.to],e.to));
        }
      }
    }
  }
};
// dijkstra end

class UnionFind
{
public:
  ll par[100005];
  ll depth[100005];
  ll nGroup[100005];

  UnionFind(ll n) {
    init(n);
  }

  void init(ll n) {
    for(ll i=0; i<n; i++) {
      par[i] = i;
      depth[i] = 0;
      nGroup[i] = 1;
    }
  }

  ll root(ll x) {
    if(par[x] == x) {
      return x;
    } else {
      return par[x] = root(par[x]);
    }
  }

  bool same(ll x, ll y) {
    return root(x) == root(y);
  }

  void unite(ll x, ll y) {
    x = root(x);
    y = root(y);
    if(x == y) return;

    if(depth[x] < depth[y]) {
      par[x] = y;
      nGroup[y] += nGroup[x];
      nGroup[x] = 0;
    } else {
      par[y] = x;
      nGroup[x] += nGroup[y];
      nGroup[y] = 0;
      if(depth[x] == depth[y])
        depth[x]++;
    }
  }
};
// unionfind end

// nCr
const ll MAX = 500010;
ll fac[MAX], finv[MAX], inv[MAX];

void COMinit() {
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (ll i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i % MOD;
        inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
        finv[i] = finv[i - 1] * inv[i] % MOD;
    }
}

// nCr end

// tree DP
vector<ll> depth;
vector<ll> f;
vector<ll> g;
void dfs(const Graph &G, ll v, ll p, ll d) {
    depth[v] = d;
    for (auto nv : G[v]) {
        if (nv == p) continue;
        dfs(G, nv, v, d+1);
    }

    f[v] = 1;
    g[v] = 1;
    for (auto c : G[v]) {
        if (c == p) continue;
        f[v]*=g[c];
        f[v]%=MOD;
        g[v]*=f[c];
        g[v]%=MOD;
        }
    f[v]+=g[v];
    f[v]%=MOD;
}
// tree DP end

template<ll MOD> struct Fp {
    ll val;
    constexpr Fp(ll v = 0) noexcept : val(v % MOD) {
        if (val < 0) val += MOD;
    }
    constexpr ll getmod() { return MOD; }
    constexpr Fp operator - () const noexcept {
        return val ? MOD - val : 0;
    }
    constexpr Fp operator + (const Fp& r) const noexcept { return Fp(*this) += r; }
    constexpr Fp operator - (const Fp& r) const noexcept { return Fp(*this) -= r; }
    constexpr Fp operator * (const Fp& r) const noexcept { return Fp(*this) *= r; }
    constexpr Fp operator / (const Fp& r) const noexcept { return Fp(*this) /= r; }
    constexpr Fp& operator += (const Fp& r) noexcept {
        val += r.val;
        if (val >= MOD) val -= MOD;
        return *this;
    }
    constexpr Fp& operator -= (const Fp& r) noexcept {
        val -= r.val;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr Fp& operator *= (const Fp& r) noexcept {
        val = val * r.val % MOD;
        return *this;
    }
    constexpr Fp& operator /= (const Fp& r) noexcept {
        ll a = r.val, b = MOD, u = 1, v = 0;
        while (b) {
            ll t = a / b;
            a -= t * b; swap(a, b);
            u -= t * v; swap(u, v);
        }
        val = val * u % MOD;
        if (val < 0) val += MOD;
        return *this;
    }
    constexpr bool operator == (const Fp& r) const noexcept {
        return this->val == r.val;
    }
    constexpr bool operator != (const Fp& r) const noexcept {
        return this->val != r.val;
    }
    friend constexpr ostream& operator << (ostream &os, const Fp<MOD>& x) noexcept {
        return os << x.val;
    }
    friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, ll n) noexcept {
        if (n == 0) return 1;
        auto t = modpow(a, n / 2);
        t = t * t;
        if (n & 1) t = t * a;
        return t;
    }
};
using mint = Fp<MOD>;

mint calc(ll N, ll K) {
    mint res = 1;
    for (ll n = 0; n < K; ++n) {
        res *= (N - n);
        res /= (n + 1);
    }
    return res;
}
mint COM(ll n, ll k){
    if (k == 0) return 1;
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}

int main(){
  string s;
   cin>>s;
  if(s=='Sunny'){
    cout << "Cloudy" << endl;}
  else if(s=='Rainy'){
    cout << "Sunny" << endl;}
  else
    cout << "Rainy" << endl;
}


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <math.h>
#include <limits.h>
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) > (b) ? (b) : (a))
#define abs(x) ((x) > 0 ? (x) : -(x))
#define MOD (ll)1000000007 //10^9 + 7
#define endl printf("\n")
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, n, m) for (int i = (n), i < (m); i++)

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

int
main(int argc, char *argv[])
{

  char s[100];
  scanf("%s", s);
  if (s[0] == 'S') printf("Cloudy\n");
  if (s[0] == 'C') printf("Rainy\n");
  if (s[0] == 'R') printf("Sunny\n");

  return 0;
}


/*
	submission # - User: herp_sy
	https://atcoder.jp/contests/

	coding: utf-8
	lang: C (GCC 5.4.1)
*/

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

#define _CRT_SECURE_NO_WARNINGS
#define TLong long long
#define TBMod 1000000007

int main(int argc, char const *argv[])
{
	char we[10];
	scanf("%s",we);

	if(strcmp(we, "Sunny") == 0){
		puts("Cloudy");
	}
	else if(strcmp(we, "Cloudy") == 0){
		puts("Rainy");
	}
	else puts("Sunny");
	return 0;
}


#include <stdio.h>

int main(){
        char n;
        scanf("%c",&n);
        switch(n){
                case 'S':
                        puts("Cloudy");
                        break;
                case 'C':
                        puts("Rainy");
                        break;
                case 'R':
                        puts("Sunny");
        }
        return 0;
}


#include<stdio.h>

int main(void){
  char d[10];
  if(strcmp(d,"Sunny")==0){
    printf("Cloudy\n");
  }else if(strcmp(d,"Cloudy")==0){
    printf("Rainy\n");
  }else{
    printf("Sunny\n");
  }
  return 0;
}


#include<stdio.h>

int main(void){
  char d[10];
  if(d[0]=='S'){
    printf("Cloudy\n");
  }else if(d[0]=='C'){
    printf("Rainy\n");
  }else{
    printf("Sunny\n");
  }
  return 0;
}


#include <stdio.h>

int main(){
  int N,K,Q,T;
  int A[100002]={};
  scanf("%d %d %d",&N,&K,&Q);
  for(int i=1;i<=N;i++)
    A[i]=0;
  for(int i=1;i<=Q;i++){
    scanf("%d",&T);
    A[T]++;
  }
  for(int i=1;i<=N;i++){
    if(Q-A[i]<K) printf("Yes\n");
    else printf("No\n");
  }
  return 0;
}


"use strict"

function Main(input) {
  input = input.trim();
  if(input === 'Sunny') console.log('Cloudy');
  if(input === 'Rainy') console.log('Sunny');
  if(input === 'Cloudy') console.log('Rainy');
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


// inputに入力データ全体が入る
function Main(input) {
  switch(input.split('\n')[0]){
    case 'Sunny':
      process.stdout.write("Cloudy");
      break;
    case 'Cloudy':
      process.stdout.write("Rainy");
      break;
    case 'Rainy':
      process.stdout.write("Sunny");
      break;
  }
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
  "use strict"
	const temp = input.split("\n");

	const s = temp.shift();
  switch(s){
    case 'Sunny':
      console.log('Cloudy');
      break;
    case 'Cloudy':
      console.log('Rainy');
      break;
    case 'Rainy':
      console.log('Sunny');
      break;
  }
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


const main = input => {
    const S = input;
    if (S === 'Sunny') {
        console.log('Cloudy');
    } else if (S === 'Cloudy') {
        console.log('Rainy');
    } else {
        console.log('Sunny');
    }
};

// 標準入力
main(require("fs").readFileSync("/dev/stdin", "utf8"));
// main(require("fs").readFileSync("input.txt", "utf8"));


function main (input) {
  const weather = ['Sunny', 'Cloudy', 'Rainy']
  console.log(weather[(weather.findIndex(i => i === input) + 1) % 3])
}

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


package main

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

const (
	defaultBufferSize = 1024
	maxBufferSize     = 1e6
	Mod               = 1e9 + 7
)

var sc = bufio.NewScanner(os.Stdin)

// sc.Buffer(make([]byte, defaultBufferSize), maxBufferSize)

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

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

func readInt64() int64 {
	sc.Scan()
	i, err := strconv.ParseInt(sc.Text(), 10, 64)
	if err != nil {
		panic(err)
	}
	return int64(i)
}

func readfloat64() float64 {
	sc.Scan()
	f, err := strconv.ParseFloat(sc.Text(), 64)
	if err != nil {
		panic(err)
	}
	return f
}

func abs(a int) int {
	if a < 0 {
		return a * -1
	}
	return a
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func gcd(x, y int) int {
	if y == 0 {
		return x
	}
	return gcd(y, x%y)
}

func ModComb(n, k int) int {
	if k == 0 {
		return 1
	}
	x, y := n, k
	for i := 1; i < k; i++ {
		x = x * (n - i) % Mod
		y = y * (k - i) % Mod
	}
	inv := ModInv(y)
	return x * inv % Mod
}

func ModFact(x int) int {
	fact := 1
	for i := 1; i <= x; i++ {
		fact = fact * i % Mod
	}
	return fact
}

func ModInv(x int) int {
	return ModPow(x, Mod-2)
}

func ModPow(a, n int) int {
	res := 1
	for n > 0 {
		if n%2 != 0 {
			res = res * a % Mod
		}
		a = a * a % Mod
		n /= 2
	}
	return res
}

func pow(a, n int) int {
	if n == 0 {
		return 1
	}

	ans := 0
	if n%2 == 0 {
		ans = pow(a*a, n/2)
	} else {
		ans = a * pow(a*a, (n-1)/2)
	}
	return ans
}

func intSliceReverse(slice []int) []int {
	for i, j := 0, len(slice)-1; i < j; i, j = i+1, j-1 {
		slice[i], slice[j] = slice[j], slice[i]
	}
	return slice
}

func stringReverse(str string) string {
	runes := []rune(str)
	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 primeFactorization(x int) map[int]int {
	result := make(map[int]int, 0)
	for i := 2; i*i <= x; i++ {
		for x%i == 0 {
			result[i]++
			x /= i
		}
	}
	if x != 1 {
		result[x]++
	}
	return result
}

func isPrime(x int) bool {
	if x == 1 {
		return false
	}
	for i := 2; i*i <= x; i++ {
		if i == x {
			continue
		}
		if x%i == 0 {
			return false
		}
	}
	return true
}

func main() {
	sc.Split(bufio.ScanWords)

	s := readString()
	switch s {
	case "Sunny":
		fmt.Println("Cloudy")
	case "Cloudy":
		fmt.Println("Rainy")
	case "Rainy":
		fmt.Println("Sunny")
	default:
		panic("err")
	}
}


package main

import "fmt"

func main() {
	var s string
	fmt.Scan(&s)
	switch s {
	case "Sunny":
		fmt.Println("Cloudy")
	case "Cloudy":
		fmt.Println("Rainy")
	case "Rainy":
		fmt.Println("Sunny")
	}
}


package main

import "fmt"

func main() {
	var s string
	fmt.Scan(&s)
	m := map[string]string{"Sunny": "Cloudy", "Cloudy": "Rainy", "Rainy": "Sunny"}
	fmt.Println(m[s])
}


package main

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

func main() {
	S := getStdin()
	if S == "Sunny" {
		fmt.Printf("Cloudy\n")
	} else S == "Cloudy" {
		fmt.Printf("Rainy")
	} else {
		fmt.Printf("Sunny")
	}
}

var sc = bufio.NewReaderSize(os.Stdin, 1024*1024*10)

func getStdin() string {
	return readLine()
}
func getStdinInt() int {
	str := getStdin()
	rtn, _ := strconv.Atoi(str)
	return rtn
}
func getStdinInt2() (int, int) {
	list := getStdinIntArr()
	return list[0], list[1]
}
func getStdinInt3() (int, int, int) {
	list := getStdinIntArr()
	return list[0], list[1], list[2]
}
func getStdinInt64() int64 {
	str := getStdin()
	rtn, _ := strconv.ParseInt(str, 10, 64)
	return rtn
}
func getStdinIntU64() uint64 {
	str := getStdin()
	rtn, _ := strconv.ParseInt(str, 10, 64)
	return uint64(rtn)
}
func getStdinInt64_2() (int64, int64) {
	list := getStdinIntArr64()
	return list[0], list[1]
}
func getStdinInt64_3() (int64, int64, int64) {
	list := getStdinIntArr64()
	return list[0], list[1], list[2]
}
func getStdinIntArr() []int {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]int, len(list))
	for idx, val := range list {
		rtn[idx], _ = strconv.Atoi(val)
	}
	return rtn
}
func getStdinIntArr64() []int64 {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]int64, len(list))
	for idx, val := range list {
		rtn[idx], _ = strconv.ParseInt(val, 10, 64)
	}
	return rtn
}
func getStdinIntArrU64() []uint64 {
	str := getStdin()
	list := strings.Split(str, " ")
	rtn := make([]uint64, len(list))
	for idx, val := range list {
		r, _ := strconv.ParseInt(val, 10, 64)
		rtn[idx] = uint64(r)
	}
	return rtn
}
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}
func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}
func max(a, b int) int {
	if a < b {
		return b
	}
	return a
}
func max64(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}
func abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}
func abs64(n int64) int64 {
	if n < 0 {
		return -n
	}
	return n
}
func readLine() string {
	buf := make([]byte, 0, 0)
	for {
		l, p, _ := sc.ReadLine()
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}


package main

import (
	"fmt"
)

func main() {
	var s string
	w := []string{"Sunny", "Cloudy", "Rainy"}
	n := 0
	for i, v := range w {
		if v == s {
			n = i
		}
	}
	if n == 2 {
		fmt.Println(w[0])
	} else {
		fmt.Println(w[n+1])
	}
}


package main

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

func main() {
	switch readLine() {
	case "Sunny":
		fmt.Println("Cloudy")
	case "Cloudy":
		fmt.Println("Rainy")
	case "Rainy":
		fmt.Println("Sunny")
	}
}

/////////////////////////////////////////
//func readBigLineInt() []int {
//	result := make([]int, 0)
//	for _, v := range strings.Split(readBigLine(), " ") {
//		i, _ := strconv.Atoi(v)
//		result = append(result, i)
//	}
//	return result
//}
//
//var reader = bufio.NewReaderSize(os.Stdin, 1e6)
//
//func readBigLine() string {
//	result := make([]byte, 0, 1e6)
//	for {
//		line, remains, e := reader.ReadLine()
//		if e != nil {
//			panic(e)
//		}
//		result = append(result, line...)
//		if !remains {
//			break
//		}
//	}
//	return string(result)
//}

var scanner = bufio.NewScanner(os.Stdin)

func init() {
	//scanner.Split(bufio.ScanWords)
}
func readLine() string {
	scanner.Scan()
	return scanner.Text()
}


S = gets.chomp
W = {'Sunny' => 'Cloudy', 'Cloudy' => 'Rainy', 'Rainy' => 'Sunny'}
puts W[S]


S = gets.chomp.to_s
puts 'Sunny' if S=='Rainy'
puts 'Cloudy' if S=='Sunny'
puts 'Rainy' if S=='Cloudy'


str = gets.chomp

if str == 'Sunny'
  puts 'Cloudy'
elsif str == 'Cloudy'
  puts 'Rainy'
elsif str == 'Rainy'
  puts 'Sunny'
end


Weather = gets

if (Weather == "Sunny")
  print "Cloudy"
elsif (Weather == "Cloudy")
  print "Rainy"
else
  print "Sunny"
end


Weather = gets

if Weather == "Sunny" then
  print "Cloudy"
elsif Weather == "Cloudy" then
  print "Rainy"
else
  print "Sunny"
end


print "Cloudy"


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! {
    	n:chars
    }
    let nn = n.into_iter().collect::<String>();

    println!("{}", match nn.trim() {
    "Sunny" => "Cloudy",
    "Cloudy" => "Rainy",
    "Rainy" => "Sunny",
    _ => "NOT"
    });
}


fn main() {
    let s = read::<String>();
    if s == "Sunny" {
        println!("Cloudy");
    } else if s == "Cloudy" {
        println!("Rainy");
    } else {
        println!("Sunny");
    }
}

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


/* {{{ */
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

fn main() {
    input! {
        s: String
    }
    println!("{}",
        match &s[..] {
            "Sunny" => "Cloudy",
            "Cloudy" => "Rainy",
            "Rainy" => "Sunny",
            _ => panic!()
        });
}
/* vim:set foldmethod=marker: */


#[macro_use]
extern crate custom_derive;
#[macro_use]
extern crate enum_derive;

fn main() {
    custom_derive! {
        #[derive(EnumFromStr, EnumDisplay)]
        enum Weather {
            Sunny,
            Cloudy,
            Rainy,
        }
    }
    proconio::input! {
        s: Weather,
    }
    let ans = match s {
        Weather::Sunny => Weather::Cloudy,
        Weather::Cloudy => Weather::Rainy,
        Weather::Rainy => Weather::Sunny,
    };
    println!("{}", ans);
}


fn main() {
    custom_derive! {
        #[derive(EnumFromStr, EnumDisplay)]
        enum Weather {
            Sunny,
            Cloudy,
            Rainy,
        }
    }
    proconio::input! {
        s: Weather,
    }
    let ans = match s {
        Weather::Sunny => Weather::Cloudy,
        Weather::Cloudy => Weather::Rainy,
        Weather::Rainy => Weather::Sunny,
    };
    println!("{}", ans);
}


use proconio::{input, fastout};

#[fastout]
fn main() {
    input!{
        s: String
    };
    let w = ["Sunny", "Cloudy", "Rainy"];
    for i in 0..w.len() {
        if s == w[i] {
            println!("{}", w[i + 1 % 3]);
            break
        }
    }

}


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

let today=readLine()!
if today=="Sunny"{
  print("Cloudy")
}else if today=="Cloudy"{
  print("Rainy")
}else if today=="Rainy"{
  print("Sunny")
}


var tenki = readLine()!
if tenki=="Sunny" {
  print("Cloudy") }
else if tenki=="Cloudy" {
  print("Rainy") }
else if tenki=="Rainy" {
  print("Sunny")
}


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

func main() {
    let s = readLine()!

    if s == "Sunny" {
        print("Cloudy")
    } else if s == "Cloudy" {
        print("Rainy")
    } else {
        print("Sunny")
    }
}

main()


let s=readLine()!
if s=="Sunny"{
  print("Cloud")
}else if s=="Cloud"{
  print("Rainy")
}else{
  print("Sunny")
}


s=readLine()!
if s=="Sunny"{
  print("Cloud")
}else if s=="Cloud"{
  print("Rainy")
}else{
  print("Sunny")
}


let c=readLine()!.characters.map{$0}[0]
print(c=="S" ?"Cloudy":c=="C" ?"Rainy":c=="R" ?"Sunny")


const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<a.length;i+=2){if(op==='=='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,a))};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};let ssinteger=-1;const ssin=()=>{ssinteger++;return input[0][ssinteger]};
const main = ()=>{
  let a=sin()
  if(a == "Sunny") {
    out("Cloudy");
  }else if(a == "Cloudy") {
    out("Rainy");
  }else if(a == "Rainy") {
    out("Sunny");
  }
}
main()


import * as fs from 'fs'

function Main(input: string) {
  const S = input.trim()
  const weather = ['Sunny', 'Cloudy', 'Rainy']

  switch (S) {
    case weather[0]:
      console.log(weather[1])
      break
    case weather[1]:
      console.log(weather[2])
      break
    case weather[2]:
      console.log(weather[0])
      break
  }
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))


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

const input = stdin.split('\n')

const s = input[0]

const t = ['Sunny', 'Cloudy', 'Rainy', 'Sunny', 'Cloudy', 'Rainy']

const ans = () => {
  const i = t.indexOf(s)
  console.log(t[i + 1])
}

ans()


import * as fs from 'fs'

function Main(S: string) {
  const weather = ['Sunny', 'Cloudy', 'Rainy']

  switch (S) {
    case weather[0]:
      console.log(weather[1])
      break
    case weather[1]:
      console.log(weather[2])
      break
    case weather[2]:
      console.log(weather[0])
      break
  }
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))


import * as fs from 'fs'

function Main(S: string) {
  const weather = ['Sunny', 'Cloudy', 'Rainy']

  const num = weather.indexOf(S)
  const index = num === weather.length - 1 ? 0 : num + 1
  console.log(weather[index])
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))


import * as fs from 'fs'

function Main(S: string) {
  const weather = ['Sunny', 'Cloudy', 'Rainy']

  const num = weather.indexOf(S)
  console.log(weather[num === weather.length - 1 ? 0 : num + 1])
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))


A, B, C = map(int,input().split())
if A == B == C:
    print('No')
elif B == C:
    print('Yes')
elif A == C:
    print('Yes')
elif A == B:
    print('Yes')
else:
    print('No')


A = map(int, input().split())
if len(set(A) ) == 2:
    print("Yes")
else:
    print("No")


a, b, c = map(int, input().split())
ans = 'No'
if (a == b and b != c) or (b == c and c != a) or (c == a and a != b):
    ans = 'Yes'
print(ans)


a, b, c = map(int, input().split())

if a == b and a == c:
    print("No")
elif a == b or a == c or b == c:
    print("Yes")
else:
    print("Yes")


a, b, c = map(int, input().split())

if a == b:
    if b == c:
        print("No")
    else:
        print("Yes")
else:
    if a == c:
        print("Yes")
    else:
        print("No")


print(["No","Yes"][len(set(input().split()))==3])


	import java.io.ByteArrayInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.PrintWriter;
	import java.util.*;
	import java.io.*;
	public class Main {
	InputStream is;
		PrintWriter out;
		String INPUT = "";
	//class  Declaration

	static class pair implements Comparable<pair>{
		int x;
		int y;

		pair (int i,int j)
		{ x=i; y=j;

		}
		public int compareTo(pair p){
			if(this.x!=p.x) { return this.x-p.x;}
			else { return this.y-p.y;}
		}
		public int hashCode() { return (x+" "+y).hashCode();}
		public String toString(){ return x+" "+y;}
		public boolean equals(Object o){
			pair x = (pair) o ;
			return (x.x==this.x&&x.y==this.y);}
	}

	long mod  = (long)1e9 + 7 ;

	void solve() throws Exception{
	HashSet<Integer> hs = new HashSet<>();
	hs.add(ni());
	hs.add(ni());
	hs.add(ni());

	if(hs.size()==2) pn("Yes");
	else{
		pn("No");
	}

	}

	long pow(long a,long b){
		long result = 1;
		while(b>0){
		if(b%2==1) result = (result * a) % mod;
			b/=2;
			a=(a*a)%mod;
		}
		return result;
	}

	void print(Object o){
	System.out.println(o);
	System.out.flush();
	}

	int gcd(int a, int b)
	{
	if (b == 0)
	return a;
	return gcd(b, a % b);
	}
	void run() throws Exception{
			is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
	out = new PrintWriter(System.out);

			long s = System.currentTimeMillis();
			solve();
			out.flush();
			if(!INPUT.isEmpty())tr(System.currentTimeMillis()-s+"ms");
	}

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

	//output methods
	private void pn(Object o)
	{
		out.println(o);
	}
	private void p(Object o)
	{
		out.print(o);
	}

	//input methods
			private byte[] inbuf = new byte[1024];
		public int lenbuf = 0, ptrbuf = 0;

		private int readByte()
		{
			if(lenbuf == -1)throw new InputMismatchException();
			if(ptrbuf >= lenbuf){
				ptrbuf = 0;
				try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
				if(lenbuf <= 0)return -1;
			}
			return inbuf[ptrbuf++];
		}

		private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
		private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

		private double nd() { return Double.parseDouble(ns()); }
		private char nc() { return (char)skip(); }

		private String ns()
		{
			int b = skip();
			StringBuilder sb = new StringBuilder();
			while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}

		private char[] ns(int n)
		{
			char[] buf = new char[n];
			int b = skip(), p = 0;
			while(p < n && !(isSpaceChar(b))){
				buf[p++] = (char)b;
				b = readByte();
			}
			return n == p ? buf : Arrays.copyOf(buf, p);
		}

		private char[][] nm(int n, int m)
		{
			char[][] map = new char[n][];
			for(int i = 0;i < n;i++)map[i] = ns(m);
			return map;
		}

		private int[] na(int n)
		{
			int[] a = new int[n];
			for(int i = 0;i < n;i++)a[i] = ni();
			return a;
		}

		private int ni()
		{
			int num = 0, b;
			boolean minus = false;
			while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
			if(b == '-'){
				minus = true;
				b = readByte();
			}

			while(true){
				if(b >= '0' && b <= '9'){
					num = num * 10 + (b - '0');
				}else{
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		private long nl()
		{
			long num = 0;
			int b;
			boolean minus = false;
			while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
			if(b == '-'){
				minus = true;
				b = readByte();
			}

			while(true){
				if(b >= '0' && b <= '9'){
					num = num * 10 + (b - '0');
				}else{
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		private void tr(Object... o) { if(INPUT.length() > 0)System.out.println(Arrays.deepToString(o)); }
		void watch(Object ... a) throws Exception{
			int i=1;
			print("watch starts :");
			for(Object o : a ) {
				//print(o);
				boolean notfound = true;
				if(o.getClass().isArray()){

					String type = o.getClass().getName().toString();
					//print("type is "+type);
					switch (type) {
						case "[I":{
							int[] test = (int[])o ;
							print(i+" "+Arrays.toString(test));
							break;
						}
						case "[[I":{
							int[][] obj = (int[][])o;

							print(i+" "+Arrays.deepToString(obj));
							break;
						}
						case "[J" : {

							long[] obj  = (long[])o ;
							print(i+" "+Arrays.toString(obj));
							break;
						}
						case "[[J": {

							long[][] obj = (long[][])o;
							print(i+" "+Arrays.deepToString(obj));
							break;
						}
						case "[D" :{

							double[] obj= (double[])o;
							print(i+" "+Arrays.toString(obj));
							break;
						}
						case "[[D" :{

							double[][] obj = (double[][])o;
							print(i+" "+Arrays.deepToString(obj));
							break;
						}
						case "[Ljava.lang.String": {

							String[] obj = (String[])o ;
							print(i+" "+Arrays.toString(obj));
							break;
						}
						case "[[Ljava.lang.String": {

							String[][] obj = (String[][])o ;
							print(i+" "+Arrays.deepToString(obj));
							break ;
						}
						case "[C" :{
							char[] obj = (char[])o ;
							print(i+" "+Arrays.toString(obj));
							break;
						}
						case "[[C" :{

							char[][] obj = (char[][])o;
							print(i+" "+Arrays.deepToString(obj));
							break;
						}

						default:{
							print(i+" type not identified");
							break;
						}
					}
					notfound = false;

				}
				if(o.getClass() == ArrayList.class){
					print(i+" al: "+o);
					notfound = false;
				}
				if(o.getClass() == HashSet.class){
					print(i+" hs: "+o);
					notfound = false;
				}
				if(o.getClass() == TreeSet.class){
					print(i+" ts: "+o);
					notfound = false;
				}
				if(o.getClass() == TreeMap.class){
					print(i+" tm: "+o);
					notfound = false;
				}
				if(o.getClass() == HashMap.class){
					print(i+" hm: "+o);
					notfound = false;
				}
				if(o.getClass() == LinkedList.class){
					print(i+" ll: "+o);
					notfound = false;
				}
				if(o.getClass() == PriorityQueue.class){
					print(i+" pq : "+o);
					notfound = false;
				}
				if(o.getClass() == pair.class){
					print(i+" pq : "+o);
					notfound = false;
				}

				if(notfound){
					print(i+" unknown: "+o);
				}
				i++;
			}
			print("watch ends ");
		}

	}


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

public class Main
{
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

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

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

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    public static void main(String args[])
    {
        FastReader obj = new FastReader();
        int a = obj.nextInt(),b = obj.nextInt(),c = obj.nextInt();
        if((a==b && a!=c) || (b==c && b!=a) || (a==c && c!=b))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}


import java.io.*;
import java.util.*;
public class Main{
public static void main(String[]args) throws IOException{
BufferedReader cin = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(cin.readLine());
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
int c = Integer.parseInt(st.nextToken());
boolean ret = false;
if(a == b)
if(b==c) ret = false;
else ret = true;
if(b==c)
if(a==b) ret = false;
else ret = true;
if(a==c)
if(a==b) ret = false;
else ret = true;
if(ret) System.out.println("Yes");
else System.out.println("No");
}
}


public class Main{
	public static void main(String[] args){
    	int A = 1;
        int B = 1;
        int C = 1;

      if((A == B && B != C )||(A == C && C != B)||(B == C && C!=A)){
        System.out.println("Yes");
      }else{
         System.out.println("No");

      }
    }
}


public class Main{
	public static void main(String[] args){
    	int A = 1;
        int B = 1;
        int C = 1;

      if((A == B && B != C )||(A == C && C != B)||(B == C && C!=A))
        System.out.println("Yes");
    }else{
    System.out.println("No");
    }
}


public class Main{
	public static void main(String[] args){
    	int A = 1;
        int B = 1;
        int C = 1;
      if(A==B){
      	if(B==C){
        	System.out.println("No");
        }else{
          	System.out.println("Yes");
        }

      }
      if(A!=B){
        if(B==C){
          System.out.println("Yes");
        }else{
          System.out.println("No");
        }
      }

    }
}


#include <cstdio>
#include <utility>

const char* solve() {
  int a, b, c;
  scanf("%d %d %d", &a, &b, &c);
  if (a == b && a != c) { return "Yes"; }
  if (a == c && a != b) { return "Yes"; }
  if (b == c && b != a) { return "Yes"; }
  return "No";
}

int main() {
  printf("%s\n", solve());
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin >> a >> b >> c;
if(a == b && a != c){
    cout << "Yes" << endl;
}else if(a == c && a != b){
    cout << "Yes" << endl;
}else if (b==c && b != a){
    cout << "Yes" << endl;
}else{
    cout << "No" << endl;
}

// cout << ans << endl;
return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
  vector<int>V(3);
  for (int i=0; i<3; i++) cin >> V[i];
  sort(V.begin(), V.end());
  V.erase(unique(V.begin(), V.end()), V.end());
  if (V.size()==2) cout << "Yes" << endl;
  else cout << "No" << endl;
}


#include<iostream>
using namespace std;
int main(){
	int a,b,c;
	cin>>a>>b>>c;
	if(a==b&&b!=b||a==c&&b!=c||b==c&&a!=b){
		cout<<"Yes";
	}else{
		cout<<"No";
	}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	int a,b,c;
	if(a==b&&b!=b||a==c&&b!=c||b==c&&a!=b){
		cout<<"Yes";
	}else{
		cout<<"No";
	}
	return 0;
}


#include <stdio.h>

int main(){

	int A, B, C;
	scanf("%d %d %d", &A, &B, &C);

	 ((A == B == C) || (A != B != C)) ? puts("Yes") : puts("No");

	return 0;

}


#include<stdio.h>
int main(){
  int a,b,c;

  scanf("%d %d %d",&a,&b,&c);

  if(a==b && a!=c)
    printf("Yes");
  else if(a==c && b!=a)
    printf("Yes");
  else if(b==c && a!=b)
    printf("Yes");
  else
    printf("No");

  return 0;
}


#include <stdio.h>

int main()
{
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    if (a == b && a == c) {
        printf("No\n");
    }
    else if (a != b && b != c && a != c) {
        printf("No\n");
    }
    else {
        printf("Yes\n");
    }
}


#include <stdio.h>

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

  scanf("%d %d %d", &a, &b, &c);

  if((a == b || a == c ) && b != c){
    printf(" Yes");
  } else if((b == a || b == c ) && a != c){
    printf(" Yes");
  }else if((c == a || c == b ) && a != b){
    printf(" Yes");
  }else {
   printf("No");
  }

  return 0;
}


#include<iostream>
using namespace std;
int main()
{
	int a,b,c;
	cin>>a>>b>>c;
	if((a==b&&c!=a)||(a==c&&b!=a)||(b==c&&a!=b)){
		cout<<"Yes"<<endl;
		return 0;
	}
	cout<<"No"<<endl;
	return 0;
}


#include <stdio.h>
int main(){
	int x,y,z;
	scanf("%d %d %d",&x,&y,&z);
	getchar();
	577
	if(x==y && y!=z){
		printf("Yes\n");
	}
	else if (x==z && y!=x){
		printf("Yes\n");
	}
	else if (y==z && x!=y){
		printf("Yes\n");
	}
	else{
		printf("No\n");
	}
	return 0;
}


#include <stdio.h>

int main()
{
	int A, B, C;
	scanf("%d %d %d",&A, &B, &C);
	if (A==B && A==C && B==C){
		printf("No\n");
	}
	else if (A!=B && B!=C && C!=A){
		printf("Yes\n");
	}

	return 0;
}


function main(input) {
  var map = {};
  input[0].split(" ").forEach(v=>{
    map[v] = (map[v]||0)+1;
  });
  console.log(Object.keys(map).length == 2?"Yes":"No")

}

main(require('fs').readFileSync('/dev/stdin', 'utf8').split("\n"))


// inputに入力データ全体が入る
function Main(input) {
  // input = input.split(" ");
  N = input.split('\n')[0].split(" ");
  A = N[0]
  B = N[1]
  C = N[2]
  f = false
  if(A == B && B != C)f =true
  if(B == C && C != A)f =true
  if(C == A && A != B)f =true
  if(f){
    console.log('Yes')
  }else{
    console.log('No')
  }
}

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


const n_list = require('fs').readFileSync('/dev/stdin', 'utf8').split(' ').map(s => parseInt(s, 10));

var ans = false;

if (n_list[0] === n_list[1] && n_list[0] !== n_list[2] ||
  n_list[0] === n_list[2] && n_list[0] !== n_list[1] ||
  n_list[1] === n_list[2] && n_list[0] !== n_list[1]) {
	ans = true;
}

if (ans) {
	console.log('Yes');
} else {
	console.log('No');
}


const main = stdin => {
  const input = stdin.trim().split('\n')
  const [a, b, c] = input[0].split(' ').map(x => parseInt(x))
  if (a === b && b === c || a !== b && a !== c) {
    console.log('No')
  } else {
    console.log('Yes')
  }
}

// 標準入力
main(require("fs").readFileSync("/dev/stdin", "utf8"))


'use strict';
const main = (input) => {
const inputData = input.split(' ');
const a = inputData[0];
  const b = inputData[1];
  const c = inputData[2];
  if((a == b || b == c || c == a) && (a !== b || b !== c || c !== a)){
  console.log('Yes');
  } else {
  console.log('No');
  }
}

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


'use strict';
const main = (input) => {
const inputData = input.split(' ');
const a = inputData[0];
  const b = inputData[1];
  const c = inputData[2];
  if(a == b || b == c || c == a){
  console.log('Yes');
  } else {
  console.log('No');
  }
}

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


package main

import (
	"fmt"
)

func main() {
	var a,b,c int
	fmt.Scan(&a,&b,&c)

	var ans string
	if a == b && a == c {
		ans = "No"
	} else if a != b && a != c && b != c{
		ans = "No"
	} else {
		ans = "Yes"
	}

	fmt.Println(ans)
}


package main

import "fmt"

func main(){
	var A, B, C int
	fmt.Scan(&A, &B, &C);

	if A == B && A != C || A == C && A != B || B == C && A != B || B == C && A != C {
		fmt.Println("Yes");
	}else {
		fmt.Println("No");
	}

}


package main

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

var stdInScanner = bufio.NewScanner(os.Stdin)

func nextInt() int {
	stdInScanner.Scan()
	i, _ := strconv.Atoi(stdInScanner.Text())
	return i
}

func main() {
	stdInScanner.Split(bufio.ScanWords)

	A := nextInt()
	B := nextInt()
	C := nextInt()

	if A == B && A != C {
		fmt.Println("Yes")
	} else if A == C && A != B {
		fmt.Println("Yes")
	} else if B == C && B != A {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}


package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)

	if (a == b && b != c) || (a == c && c != b){
		fmt.Println("Yes")
	}else{
		fmt.Println("No")
	}
}


package main

import (
	"fmt"
)

func main() {
	var a,b,c int
	fmt.Scan(&a,&b,&c)

	var ans string
	if a == b && a == c {
		ans = "No"
	} else if a != b && a != c{
		ans = "No"
	} else {
		ans = "Yes"
	}

	fmt.Println(ans)
}


package main

import (
  "fmt"
)

func main() {
  res := make(map[int]int)
  for i := 0; i < 3; i++ {
    var a int
    fmt.Scan(&a)
    res[a]++
  }
  ans := "Yes"
  if len(res) == 1 {
    ans = "No"
  }
  fmt.Println(ans)

}


puts gets.split.map(&:to_i).uniq.size == 2 ? :Yes : :No


a,b,c = gets.split(' ').map(&:to_i)
if a == b && a == c && b == c || a != b && a != c && b != c
  puts 'No'
else
  puts 'Yes'
end


n = gets.split.map(&:to_i)
puts n.uniq.size == 2 ? 'Yes':'No'


a,b,c = gets.split.map(&:to_i)

if a == b || b == c || a == c
  puts "Yes"
else
  puts "No"
end


x,y,z=gets.split.map!{|i| i.to_i}
if x==y && y==z
  puts "No"
elsif x!=y && y!=z && a!=z
  puts "No"
else
  puts "Yes"
end


x,y,z=gets.split.map!{|i| i.to_i}
if x==y && y==z
  puts "No"
elsif x!=y && y!=z
  puts "No"
else
  puts "Yes"
end


use std::io;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let mut iter = buf.split_whitespace();
	let a:i32 = match iter.next().unwrap().parse() {
		Ok(n) => n,
		Err(_) => panic!(""),
	};
	let b:i32 = match iter.next().unwrap().parse() {
		Ok(n) => n,
		Err(_) => panic!(""),
	};
	let c:i32 = match iter.next().unwrap().parse() {
		Ok(n) => n,
		Err(_) => panic!(""),
	};
	if a == b && c != a && c != b {
		println!("Yes");
	}else if a == c && b != a && b != c {
		println!("Yes");
	}else if b == c && a != b && a != c {
		println!("Yes");
	}else{
		println!("No");
	}
}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

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

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

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

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

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

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

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

fn main() {
    input!{
        A: usize,
        B: usize,
        C: usize,
    }

    if (A == B && A != C)||(A != B && A == C)||(C == B && A != C)  {
        println!("Yes");
    } else {
        println!("No");
    }
    }


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

fn read<T: FromStr>() -> Option<T> {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok()
}

fn main() {
    let a: usize = read().unwrap();
    let b: usize = read().unwrap();
    let c: usize = read().unwrap();

    if (a == b) | (a == c) | (b == c) {
        if (a == b) & (b == c) {
            println!("No");
        } else {
            println!("Yes");
        }
    } else {
        println!("No");
    }
}


use proconio::input;

fn main() {

let mut _a : i128 ;
let mut _b : i128 ;
let mut _c : i128 ;

    input! {

       a : i128 ,
       b : i128 ,
       c : i128 ,

    }

if a == b && b == c  {
    println!("No");
}else if a != b && b != c{
    println!("No");
}else {
    println!("Yes");
}

}


use proconio::input;

fn main() {

let mut _a : i128 ;
let mut _b : i128 ;
let mut _c : i128 ;

    input! {

       a : i128 ,
       b : i128 ,
       c : i128 ,

    }

if a == b && b == c  {
    println!("No");
}else {
    println!("Yes");
}

}


use proconio::input;

fn main() {

let  a : i128 ;
let  b : i128 ;
let  c : i128 ;

    input! {

       a : i128 ,
       b : i128 ,
       c : i128 ,

    }

if a == b && b == c  {
    println!("No");
}else {
    println!("Yes");
}

}


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

func main() {
    if Set(readInts()).count == 2 {
        print("Yes")
    } else {
        print("No")
    }
}

main()


import Foundation

extension String {
    @inlinable
    func wordsMap<T>(_ f: (Substring) -> T?) -> [T] {
        return self.split(separator: " ").compactMap(f)
    }
}

@inlinable
func 📜<T>(_ f: (Substring) -> T?) -> [T] {
    return readLine()!.wordsMap(f)
}

prefix operator ✂
extension Array {
    typealias E = Array.Element
    static prefix func ✂ (a: Array) -> (E, E) { return (a[0], a[1]) }
    static prefix func ✂ (a: Array) -> (E, E, E) { return (a[0], a[1], a[2]) }
    static prefix func ✂ (a: Array) -> (E, E, E, E) { return (a[0], a[1], a[2], a[3]) }
    static prefix func ✂ (a: Array) -> (E, E, E, E, E) { return (a[0], a[1], a[2], a[3], a[4]) }
}

// ✂📜

func main() {
    let (a, b, c) = ✂📜 { Int($0)! }
    if a == b && b != c || a == c && a != b || b == c && a != c {
        print("Yes")
    } else {
        print("No")
    }
}

main()


import Foundation

let array = readLine()!.componentsSeparatedByString(" ").map { Int($0)! }

var answer = "No"
if array[0] == array[1] || array[0] == array[2] {
    if array[1] != array[2] {
    	answer = "Yes"
    }
}

if array[1] == array[2] {
    if array[0] != array[1] {
    	answer = "Yes"
    }
}
print(answer)


import Foundation

let N = Int(readLine()!)!
var array = [String]()
var dictionary = [String: Int]()
var max = 0
for i in 0..<N {
  var key = readLine()!
  let value = dictionary[key] ?? 0
  dictionary[key] = value + 1
  if max < value + 1 {
    max = value + 1
  }
}
let answer = dictionary.filter { $0.1 == max }
answer.map { print($0.0) }


import Foundation

let array = readLine()!.componentsSeparatedByString(" ").map { Int($0)! }

var answer = false
for i in array {
	if i != array[0] {
    	answer = true
    }
}
print(answer ? "Yes" : "No")


import Foundation

let array = readLine()!.componentsSeparatedByString(" ").map { Int($0)! }

var answer = false
for i in array {
	if i != array[0] {
    	answer = true
    }
}
print(answer ? "YES" : "NO")


import * as fs from "fs";

const split = (str: string): string[] =>
  str.split(" ").map((v: string) => v.trim());
const split_number = (str: string): number[] =>
  split(str).map((v: string) => +v);

export function main(input: string) {
  const lines = input.split("\n");
  const n = split_number(lines[0]);

  n.sort();

  if (n[0] === n[1] && n[1] === n[2]) {
    return "No";
  } else if (n[0] === n[1] || n[1] === n[2]) {
    return "Yes";
  } else {
    return "No";
  }
}

if (!process.env.LOCAL_DEBUG) {
  console.log(main(fs.readFileSync("/dev/stdin", "utf8")));
}


import * as fs from 'fs';

const input = (fs.readFileSync('/dev/stdin', 'utf8') as string).split('\n');

const [a, b, c] = input[0].split(' ').map((x: string): number => +x);

if(a===b && b===c){
    console.log('No');
}else if(a!==b && a!==c && b!==c){
    console.log('No');
}else{
    console.log('Yes');
}


function Main(input) {
  const lines = input.split("\n");
  const [a, b, c] = lines[0].split(' ');
  const isPoor = a == b && b != c || a == c && b != c || b == c && a != b;

  console.log(isPoor ? 'Yes' : 'No');
}

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


  class NormalInput{
    input: string[];
    pointer: number;
    constructor(raw:string){
      this.input=raw.split(/ |\n/);
      this.pointer=0;
    }
    int():number{
      const ret= parseInt(this.input[this.pointer], 10);
      this.pointer++;
      return ret;
    }
    str():string{
      const ret= this.input[this.pointer];
      this.pointer++;
      return ret;
    }
    strs(length:number):string[]{
      let ret:string[]=[];
      for(let i=0;i<length;i++){
        ret.push(this.str());
      }
      return ret;
    }
    ints(length:number):number[]{
      let ret:number[]=[];
      for(let i=0;i<length;i++){
        ret.push(this.int());
      }
      return ret;
    }
  }
  function Main(_: NormalInput) {
    const [a,b,c]=[_.int(),_.int(),_.int()];
    console.log((a==b||b==c||c==a)&&!(a==b&&b==c&&c==a))
  }

  //DO NOT EDIT
  Main(new NormalInput(require("fs").readFileSync("/dev/stdin", "utf8"));


import * as fs from 'fs';

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

const [a, ...rest] = input.replace(/\r?\n/g, '').split(" ")
const n = rest.filter(x => x === a).length

console.log(n === 1 ? "Yes" : "No")


import * as fs from 'fs'

//in
// 7
// beat
// vet
// beet
// bed
// vet
// bet
// beet
//out
// beet
// vet

let input: string[] = fs.readFileSync('/dev/stdin', 'utf8').split('\n');
const n: number = parseInt(input[0]);
input.shift();
let s:string[] = input.sort();

let counts: any = {};
let maxCnt: number = 0;

for (let i: number = 0; i < n; i++) {
    let key = s[i];
    counts[key] = (counts[key]) ? counts[key] + 1 : 1;
    if (maxCnt < counts[key]) {
        maxCnt = counts[key];
    }
}

// for (let i: number = 0; i < Object.keys(counts).length; i++) {
//     if (parseInt(counts[i]) === maxCnt) {
//
//     }
// }

for (let key in counts) {
    if (counts[key] === maxCnt) {
        console.log(key);
    }
}


import math

X = int(input())
print(1 if math.ceil((X - (X // 100) * 100) / 5) <= X // 100 else 0)


X = int(input())

max_num = X // 100 + 1

for i in range(max_num):
    if X >= 100 * i and X <= 105 * i:
        print("1")
        exit()

print("0")


x = int(input())
n = x // 100

if n * 100 <= x <= n * 105:
    print('1')
else:
    print('0')


import math
from math import gcd,pi,sqrt
INF = float("inf")
MOD = 10**9 + 7

import sys
sys.setrecursionlimit(10**6)
import itertools
import bisect
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]

def main():
    X = i_input()

    Y = X//100
    L = []
    a = [0,1,2,3,4,5]

    for i in range(1,min(100,Y)+1):
        c = list(itertools.combinations_with_replacement(a, i))
        for i in c:
            L.append(sum(i))
    Z = X%100

    if Z in L:
        print(1)
    else:
        print(0)

if __name__=="__main__":
    main()


import math
from math import gcd,pi,sqrt
INF = float("inf")
MOD = 10**9 + 7

import sys
sys.setrecursionlimit(10**6)
import itertools
import bisect
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]

def main():
    X = i_input()

    Y = X//100
    L = []
    a = [0,1,2,3,4,5]

    for i in range(1,Y+1):
        c = list(itertools.combinations_with_replacement(a, i))
        for i in c:
            L.append(sum(i))
    Z = X%100

    if Z in L:
        print(1)
    else:
        print(0)

if __name__=="__main__":
    main()


import math
from math import gcd,pi,sqrt
INF = float("inf")
MOD = 10**9 + 7

import sys
sys.setrecursionlimit(10**6)
import itertools
import bisect
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]

def main():
    X = i_input()

    Y = X//100
    L = []
    if Y >= 6:
        y = 6
    else:
        y = Y
    a = [0,1,2,3,4,5]

    for i in range(1,y+1):
        c = list(itertools.combinations_with_replacement(a, i))
        for i in c:
            L.append(sum(i))
    Z = X%100
    if Z in L:
        print(1)
    else:
        print(0)

if __name__=="__main__":
    main()


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

public class Main {
	public static void main(String[] args) throws Exception {

		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		String str = reader.readLine();
		int X = Integer.parseInt(str);
		int amari = X % 100;
		int kosuu = X / 100;
		if (amari > 5 * kosuu) {
			System.out.println("0");
			return;
		}
		System.out.println("1");

	}
}


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

public class Main {

	static PrintWriter out;
	static InputReader ir;

	static void solve() {
		int x = ir.nextInt();
		for (int i = 0; i <= x / 100; i++) {
			int y = x - i * 100;
			if (y >= 0 && y <= 5 * i) {
				out.println(1);
				return;
			}
		}
		out.println(0);
	}

	public static void main(String[] args) {
		ir = new InputReader(System.in);
		out = new PrintWriter(System.out);
		solve();
		out.flush();
	}

	static class InputReader {

		private InputStream in;
		private byte[] buffer = new byte[1024];
		private int curbuf;
		private int lenbuf;

		public InputReader(InputStream in) {
			this.in = in;
			this.curbuf = this.lenbuf = 0;
		}

		public boolean hasNextByte() {
			if (curbuf >= lenbuf) {
				curbuf = 0;
				try {
					lenbuf = in.read(buffer);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return false;
			}
			return true;
		}

		private int readByte() {
			if (hasNextByte())
				return buffer[curbuf++];
			else
				return -1;
		}

		private boolean isSpaceChar(int c) {
			return !(c >= 33 && c <= 126);
		}

		private void skip() {
			while (hasNextByte() && isSpaceChar(buffer[curbuf]))
				curbuf++;
		}

		public boolean hasNext() {
			skip();
			return hasNextByte();
		}

		public String next() {
			if (!hasNext())
				throw new NoSuchElementException();
			StringBuilder sb = new StringBuilder();
			int b = readByte();
			while (!isSpaceChar(b)) {
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}

		public int nextInt() {
			if (!hasNext())
				throw new NoSuchElementException();
			int c = readByte();
			while (isSpaceChar(c))
				c = readByte();
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res = res * 10 + c - '0';
				c = readByte();
			} while (!isSpaceChar(c));
			return (minus) ? -res : res;
		}

		public long nextLong() {
			if (!hasNext())
				throw new NoSuchElementException();
			int c = readByte();
			while (isSpaceChar(c))
				c = readByte();
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res = res * 10 + c - '0';
				c = readByte();
			} while (!isSpaceChar(c));
			return (minus) ? -res : res;
		}

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

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

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

		public char[][] nextCharMap(int n, int m) {
			char[][] map = new char[n][m];
			for (int i = 0; i < n; i++)
				map[i] = next().toCharArray();
			return map;
		}
	}

	static void tr(Object... o) {
		out.println(Arrays.deepToString(o));
		out.flush();
	}
}


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

public class Main {
    public void solve(BufferedReader stdin, PrintWriter stdout) throws NumberFormatException, IOException {
        int x = Integer.parseInt(stdin.readLine());

        int a = x / 100;
        int b = x % 100;

        int c = 0;
        for (int i = 5; i >= 1; i--) {
            c += b / i;
            b %= i;
        }

        if (c <= a) {
            stdout.println(1);
        } else {
            stdout.println(0);
        }
    }

    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter stdout = new PrintWriter(System.out, false);
        new Main().solve(stdin, stdout);
        stdout.flush();
    }
}


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        if(x < 100 || (x > 105 && x < 200)) {
            System.out.println(0);
            return;
        }
        String xx = Integer.toString(x);
        xx = xx.substring(xx.length() -2, xx.length());
        x = Integer.parseInt(xx);
        ArrayList<Integer> list = new ArrayList<>
            (Arrays.asList(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15));
        if(list.contains(Integer.valueOf(x))) {
            System.out.println(1);
        } else {
            System.out.println(0);
        }
    }
}


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        if(x < 100) {
            System.out.println(0);
            return;
        }
        String xx = Integer.toString(x);
        xx = xx.substring(xx.length() -2, xx.length());
        x = Integer.parseInt(xx);
        ArrayList<Integer> list = new ArrayList<>
            (Arrays.asList(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15));
        if(list.contains(Integer.valueOf(x))) {
            System.out.println(1);
        } else {
            System.out.println(0);
        }
    }
}


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        if(x < 100) {
            System.out.println(0);
        }
        String xx = Integer.toString(x);
        xx = xx.substring(xx.length() -2, xx.length());
        x = Integer.parseInt(xx);
        ArrayList<Integer> list = new ArrayList<>
            (Arrays.asList(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15));
        if(list.contains(Integer.valueOf(x))) {
            System.out.println(1);
        } else {
            System.out.println(0);
        }
    }
}


#include <iostream>
#include <cstring>
#include <map>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <set>
#include <vector>
#include <queue>
#include <list>
#include <numeric>
#include <stdio.h>
#include <string>
#include <cstdlib>
#include <math.h>
#include <stack>
#include <climits>
#include <bitset>
#include <utility>

using namespace std;
typedef long long ll;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
// const ll INF = 1LL <<60;
// const int INF = 10000;

//最大公約数
ll gcd(ll x, ll y) {
  ll tmp = 0;
  if (x < y){
    tmp=x;
    x=y;
    y=tmp;
  }
  while (y > 0) {
    ll r = x % y;
    x = y;
    y = r;
  }
  return x;
}

//最大公倍数
ll lcm(ll x,ll y){
  return x/gcd(x,y)*y;
}

const int MAX = 1e6+1;
const int MOD = 1e9+7;

long long fac[MAX], finv[MAX], inv[MAX];

// テーブルを作る前処理
void COMinit() {
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i % MOD;
        inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
        finv[i] = finv[i - 1] * inv[i] % MOD;
    }
}

// 二項係数計算
long long COM(int n, int k){
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}

//階乗
ll kaijo(ll k){
    ll sum = 1;
    for (ll i = 1; i <= k; ++i)
    {
        sum *= i;
        sum%=1000000000+7;
    }
    return sum;
}

//for(int i = ; i < ; i++){}

ll lmax(ll s,ll t){
  if(s>t){
    return s;
  }
  else{
    return t;
  }
}

ll lmin(ll s,ll t){
  if(s<t){
    return s;
  }
  else{
    return t;
  }
}

long long modpow(long long res,long long a, long long n, long long mod) {
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}

//sieve(MAX);でベクトルIsPrimeに「MAXまでの数値の素数の真偽」を格納する。
vector<bool> IsPrime;
void sieve(size_t max){
    if(max+1 > IsPrime.size()){     // resizeで要素数が減らないように
        IsPrime.resize(max+1,true); // IsPrimeに必要な要素数を確保
    }
    IsPrime[0] = false; // 0は素数ではない
    IsPrime[1] = false; // 1は素数ではない

    for(size_t i=2; i*i<=max; ++i) // 0からsqrt(max)まで調べる
        if(IsPrime[i]) // iが素数ならば
            for(size_t j=2; i*j<=max; ++j) // (max以下の)iの倍数は
                IsPrime[i*j] = false;      // 素数ではない
}
// ここから開始

int main(){
    int x;
    cin>>x;
    int n = x/100;//回数
    int r = x%100;//余り
    int ansflg = 1;
    // 最低限必要な回数
    int count = r/5;
    if(r%5>0) count+=1;
    if(count>n) ansflg = 0;
    cout<<ansflg<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);

    int x; cin >> x;
    int a = x / 100;
    x %= 100;

    for(int i = 0; i <= a; i++){
        for(int j = 0; j <= a - i; j++){
            for(int k = 0; k <= a - i - j; k++){
                for(int l = 0; l <= a - i - j - k; l++){
                    for(int m = 0; m <= a - i - j - k - l; m++){
                        if(i*5 + j*4 + k*3 + l*2 + m == x){
                            cout << 1; return 0;
                        }
                    }
                }
            }
        }
    }cout << 0;
}


#include<iostream>
using namespace std;
int main() {
	int N;
	cin >> N;
	int m;
	m = N / 100;
	if (N - m * 100 <= 5 * m)
		cout << 1;
	else
		cout << 0;
	return 0;
}


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

using ll = long long;
constexpr ll mod = 1e9 + 7;
#define endl '\n'

template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;

struct Scanner {
  int fd = -1;
  char line[(1 << 15) + 1];
  size_t st = 0, ed = 0;
  void reread() {
    memmove(line, line + st, ed - st);
    ed -= st;
    st = 0;
    ed += ::read(fd, line + ed, (1 << 15) - ed);
    line[ed] = '\0';
  }
  bool succ() {
    while (true) {
      if (st == ed) {
        reread();
        if (st == ed) return false;
      }
      while (st != ed && isspace(line[st])) st++;
      if (st != ed) break;
    }
    if (ed - st <= 50) {
      bool sep = false;
      for (size_t i = st; i < ed; i++) {
        if (isspace(line[i])) {
          sep = true;
          break;
        }
      }
      if (!sep) reread();
    }
    return true;
  }
  template <class T, enable_if_t<is_same<T, string>::value, int> = 0>
  bool read_single(T& ref) {
    if (!succ()) return false;
    while (true) {
      size_t sz = 0;
      while (st + sz < ed && !isspace(line[st + sz])) sz++;
      ref.append(line + st, sz);
      st += sz;
      if (!sz || st != ed) break;
      reread();
    }
    return true;
  }
  template <class T, enable_if_t<is_integral<T>::value, int> = 0>
  bool read_single(T& ref) {
    if (!succ()) return false;
    bool neg = false;
    if (line[st] == '-') {
      neg = true;
      st++;
    }
    ref = T(0);
    while (isdigit(line[st])) {
      ref = 10 * ref + (line[st++] & 0xf);
    }
    if (neg) ref = -ref;
    return true;
  }
  template <class T> bool read_single(V<T>& ref) {
    for (auto& d : ref) {
      if (!read_single(d)) return false;
    }
    return true;
  }
  void read() {}
  template <class H, class... T> void read(H& h, T&... t) {
    bool f = read_single(h);
    assert(f);
    read(t...);
  }
  Scanner(FILE* fp) : fd(fileno(fp)) {}
};

struct Printer {
public:
  template <bool F = false> void write() {}
  template <bool F = false, class H, class... T>
  void write(const H& h, const T&... t) {
    if (F) write_single(' ');
    write_single(h);
    write<true>(t...);
  }
  template <class... T> void writeln(const T&... t) {
    write(t...);
    write_single('\n');
  }

  Printer(FILE* _fp) : fp(_fp) {}
  ~Printer() { flush(); }

private:
  static constexpr size_t SIZE = 1 << 15;
  FILE* fp;
  char line[SIZE], small[50];
  size_t pos = 0;
  void flush() {
    fwrite(line, 1, pos, fp);
    pos = 0;
  }
  void write_single(const char& val) {
    if (pos == SIZE) flush();
    line[pos++] = val;
  }
  template <class T, enable_if_t<is_integral<T>::value, int> = 0>
  void write_single(T val) {
    if (pos > (1 << 15) - 50) flush();
    if (val == 0) {
      write_single('0');
      return;
    }
    if (val < 0) {
      write_single('-');
      val = -val; // todo min
    }
    size_t len = 0;
    while (val) {
      small[len++] = char(0x30 | (val % 10));
      val /= 10;
    }
    for (size_t i = 0; i < len; i++) {
      line[pos + i] = small[len - 1 - i];
    }
    pos += len;
  }
  void write_single(const string& s) {
    for (char c : s) write_single(c);
  }
  void write_single(const char* s) {
    size_t len = strlen(s);
    for (size_t i = 0; i < len; i++) write_single(s[i]);
  }
  template <class T> void write_single(const V<T>& val) {
    auto n = val.size();
    for (size_t i = 0; i < n; i++) {
      if (i) write_single(' ');
      write_single(val[i]);
    }
  }
};

Scanner sc = Scanner(stdin);
Printer pr = Printer(stdout);
#define int ll

int32_t main() {
  ios::sync_with_stdio(0); cin.tie(0);

  ll X;
  sc.read(X);
  ll n100 = X/100;
  X = X%100;
  ll n_extra = X/6;
  X -= n_extra*6;
  if (X) ++n_extra;
  if (n_extra > n100) {
    pr.writeln(0);
  } else {
    pr.writeln(1);
  }

}


#include<bits/stdc++.h>
using namespace std;
int main(){
  int X;
  cin>>X;
  int q=X%100,p=X/100,count=0;
  for(int i=5;i>0;i--){
    while(q>i){
      q-=i;
      count++;
    }
  }
  if(count<=p)
    cout<<1<<endl;
  else
    cout<<0<<endl;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
  int X;
  cin >> X;
  for(int i=0;i<X;i++){
    int A=i+1;
    if(100*A<=X && A<=105){
      cout << 1 << endl;
      return 0;
    }
  }
  cout << 0 << endl;
}


#include <stdio.h>

int main(){
    int a[1];
    int C;
    int ans;

    if(scanf("%d", &a[0])==1){}

    C = (int)((double)a[0]/100);
    if(100*C <= a[0] && a[0]<=105*C){
        ans = 1;
    }else{
        ans = 0;
    }

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

}


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

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

	int x = X / 100;
	if (X / 100 * 5 >= X % 100) printf("1\n");
	else printf("0\n");
	fflush(stdout);
	return 0;
}


#include <stdio.h>

int main(){
  int x;  scanf("%d", &x);
  int ans;
  if(x%100 > (x/100)*5)
    ans = 0;
  else
    ans = 1;

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


#include <stdio.h>

int main(void) {
	int X;
	int i;
	if (scanf("%d", &X) != 1) return 1;
	for (i = 0; 101 * i <= X; i++) {
		int kitaeri = X - 100 * i;
		if(i <= kitaeri && kitaeri <= 5 * i) {
			puts("1");
			return 0;
		}
	}
	puts("0");
	return 0;
}


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

int main(){
  int X;
  int c=0;
  scanf("%d",&X);
  int q=X/100;
  int r=X%100;
  if(r<=q*6) c=1;
  printf("%d\n",c);
  return 0;
}


#include<stdio.h>
int main(void)
{
  int x;
  scanf("%d",&x);
  int num=x/100;
  printf("%d\n",num);
  if(x>=num*100&&x<=num*105){
    puts("1");
  }else{
    puts("0");
  }
  return 0;
}


function Main(input) {
    const n = input.split("\n")[0];
    var ans = 0
    for(var i = 1; i <= n; i++){
        if (n >= i * 100 && n <= i* 105) {
            ans = 1
            break;
        }
    }
    console.log(ans)
    }
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(X) {
var up =  Math.floor(X/100)*5;
var down = X%100
if(up>=down){
  console.log(1);
}else{
  console.log(0);
}
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
   	var inputArray = input.split("\n");
	var X=inputArray[0];

	var amari=X%100;
	var kaisu=0;

	for(var i=5;i>=1;i--){
		kaisu=kaisu+parseInt(amari/i);
		amari=amari%i;
		//console.log(i);
	}

	if(kaisu<=parseInt(X/100)){
		console.log("1");
	}else{
		console.log("0")
	}
}

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


// inputに入力データ全体が入る

function Main(input) {
  for (let a = 100; a <= 105; a++) {
    for (let b = 100; b <= 105; b++) {
      for (let c = 100; c <= 105; c++) {
        for (let d = 100; d <= 105; d++) {
          for (let e = 100; e <= 105; e++) {

            if (a + b + c + d + e == input) {
              console.log(1);
              return;
            } else if(e == 105){
              console.log(0);
              return

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


function Main(input) {
  input = input.split('\n');
	var n = Number(input[0]);
	var k = Math.floor(n/100);
  if(100*k<=n || n<=105*k){
  console.log('1');
  }else{
  console.log('0');
  }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


function Main(input) {
	var n = Number(input);
	var k = n/100;
  if(100*k<=n || n<=105*k){
  console.log('1');
  }else{
  console.log('0');
  }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


package main

import "fmt"

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

	c := x / 100
	if 100*c <= x && x <= 105*c {
		fmt.Println(1)
	} else {
		fmt.Println(0)
	}
}


package main

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

func out(x ...interface{}) {
	fmt.Println(x...)
}

var sc = bufio.NewScanner(os.Stdin)

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

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

// min, max, asub, absなど基本関数
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func asub(a, b int) int {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

func main() {
	sc.Split(bufio.ScanWords)

	X := getInt()

	Y := X % 100
	X /= 100
	//out(Y, X)
	if X*5 >= Y {
		out(1)
		return
	}
	out(0)
}


package main

import (
	"fmt"
)

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

	if x < 100 {
		fmt.Println(0)
		return
	}

	last := x % 100

	c5 := 0
	if last/5 > 0 {
		c5 = last / 5
		last %= 5
	}
	c4 := 0
	if last/4 > 0 {
		c4 = last / 4
		last %= 4
	}
	c3 := 0
	if last/3 > 0 {
		c3 = last / 3
		last %= 3
	}
	c2 := 0
	if last/2 > 0 {
		c5 = last / 2
		last %= 2
	}
	c1 := 0
	if last == 1 {
		c1 = 1
	}

	recalc := 0
	recalc += 105 * c5
	recalc += 104 * c4
	recalc += 103 * c3
	recalc += 102 * c2
	recalc += 101 * c1

	if recalc > x {
		fmt.Println(0)
		return
	}

	c0 := (x - recalc) / 100
	recalc += 100 * c0

	if recalc == x {
		fmt.Println(1)
	} else {
		fmt.Println(0)
	}
}


package main

import "fmt"

func main() {
	// Code for C - 100 to 105
	var X int
	fmt.Scanf("%d", &X)

	var flag int = 0
	for i := 0; 100*i <= X; i++ {
		for j := 0; 100*i+101*j <= X; j++ {
			for k := 0; 100*i+101*j+102*k <= X; k++ {
				for l := 0; 100*i+101*j+102*k+103*l <= X; l++ {
					for m := 0; 100*i+101*j+102*k+103*l+104*m <= X; m++ {
						for n := 0; 100*i+101*j+102*k+103*l+104*m+105*n <= X; n++ {
							if X == 100*i+101*j+102*k+103*l+104*m+105*n {
								flag = 1
								break
							}
						}
					}
				}
			}
		}
	}

	if flag == 1 {
		fmt.Println("1")
	} else {
		fmt.Println("0")
	}
}


package main

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

func out(x ...interface{}) {
	fmt.Println(x...)
}

var sc = bufio.NewScanner(os.Stdin)

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

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

// min, max, asub, absなど基本関数
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func asub(a, b int) int {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

func main() {
	sc.Split(bufio.ScanWords)

	X := getInt()

	Y := X % 100
	X /= 100
	//out(Y, X)
	if X*5 = Y {
		out(1)
		return
	}
	out(0)
}


package main

import (
	"fmt"
)

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

	if x < 100 {
		fmt.Println(0)
		return
	}

	last := x % 100

	c5 := 0
	if last/5 > 0 {
		c5 = last / 5
		last %= 5
	}
	c4 := 0
	if last/4 > 0 {
		c4 = last / 4
		last %= 4
	}
	c3 := 0
	if last/3 > 0 {
		c3 = last / 3
		last %= 3
	}
	c2 := 0
	if last/2 > 0 {
		c5 = last / 2
		last %= 2
	}
	c1 := 0
	if last == 1 {
		c1 = 1
	}

	recalc := 0
	recalc += 105 * c5
	recalc += 104 * c4
	recalc += 103 * c3
	recalc += 102 * c2
	recalc += 101 * c1

	c0 := (x - recalc) / 100
	recalc += 100 * c0

	if recalc == x {
		fmt.Println(1)
	} else {
		fmt.Println(0)
	}
}


x = gets.chomp.to_i
s = x.to_s

if x < 100
  puts 0
  exit
end

head = s[0...-2].to_i
tail = s[-2..-1].to_i

cnt = (tail / 5.0).ceil

if head >= cnt
  puts 1
else
  puts 0
end


x = gets.to_i

if 1.upto(x / 100).any? { |c| 100 * c <= x && x <= 105 * c }
  puts 1
else
  puts 0
end


x = gets.to_i
c = x / 100

if 100 * c <= x && x <= 105 * c
  puts 1
else
  puts 0
end


x = gets().chomp.to_i

max_cnt = x / 100
base_rem = x % 100

puts base_rem <= 5 * max_cnt ? 'Yes' : 'No'


dp = [true]
n = gets.to_i
(1..n).each do |i|
  dp[i] = dp[i-105] || dp[i-104] || dp[i-103] || dp[i-102] || dp[i-101] || dp[i-100]
end
p dp[n] ? 1 : 0


dp = [true]
n = gets.to_i
(1..n).each do |i|
  dp[i] = dp[i-105] || dp[i-104] || dp[i-103] || dp[i-102] || dp[i-101]
end
p dp[n] ? 1 : 0


#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::io::{stderr, stdin, stdout, BufRead, BufWriter, Read, StdoutLock, Write};
#[allow(unused_imports)]
use std::iter::FromIterator;
#[allow(unused_imports)]
use std::{i64, u64, usize};
#[allow(unused_macros)]
/// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules !input {(source =$s :expr ,$($r :tt ) *) =>{let mut iter =$s .split_whitespace () ;input_inner !{iter ,$($r ) *} } ;($($r :tt ) *) =>{let mut s ={use std ::io ::Read ;let mut s =String ::new () ;std ::io ::stdin () .read_to_string (&mut s ) .unwrap () ;s } ;let mut iter =s .split_whitespace () ;input_inner !{iter ,$($r ) *} } ;}
#[allow(unused_macros)]
macro_rules !input_inner {($iter :expr ) =>{} ;($iter :expr ,) =>{} ;($iter :expr ,$var :ident :$t :tt $($r :tt ) *) =>{let $var =read_value !($iter ,$t ) ;input_inner !{$iter $($r ) *} } ;}
#[allow(unused_macros)]
macro_rules !read_value {($iter :expr ,($($t :tt ) ,*) ) =>{($(read_value !($iter ,$t ) ) ,*) } ;($iter :expr ,[$t :tt ;$len :expr ] ) =>{(0 ..$len ) .map (|_ |read_value !($iter ,$t ) ) .collect ::<Vec <_ >>() } ;($iter :expr ,chars ) =>{read_value !($iter ,String ) .chars () .collect ::<Vec <char >>() } ;($iter :expr ,usize1 ) =>{read_value !($iter ,usize ) -1 } ;($iter :expr ,$t :ty ) =>{$iter .next () .unwrap () .parse ::<$t >() .expect ("Parse error" ) } ;}
#[allow(unused_macros)]
macro_rules !dbg {($($a :expr ) ,*) =>{writeln !(&mut stderr () ,concat !($(stringify !($a ) ," = {:?}, " ) ,*) ,$($a ) ,*) .unwrap () ;} }
#[allow(non_snake_case)]
#[allow(dead_code)]
fn main() {
    input! {
        x: u64
    }
    let div100 = x / 100;
    if x % 100 <= div100 * 5 {
        println!("1");
    } else {
        println!("0");
    }
}


use std::cmp::*;
use std::io::*;
use std::num::*;
use std::str::*;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}

fn string() -> String {
    read()
}

fn int() -> i64 {
    read()
}

fn char() -> char {
    read::<String>().pop().unwrap()
}

fn vecchar() -> Vec<char> {
    string().chars().collect()
}

fn vecint(n: i64) -> Vec<i64> {
    let mut vec = Vec::new();
    for i in 0..n {
        vec.push(int())
    }
    vec
}

fn main() {
    let x = int();
    let c = (x + 104) / 105;
    let sum = 105 * c;
    println!("{}", if sum - c * 5 <= x { "1" } else { "0" });
}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

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

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

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

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

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

#[allow(unused_imports)]
use std::io::{stdout, Write, BufWriter};
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
//#[allow(unused_imports)]
//use proconio::marker::{Isize1, Usize1, Bytes, Chars};

//#[proconio::fastout]

fn main() {
    input!{
        x: i32,
    }
    if ((x % 100) + 4) / 5 > x / 100 {
        println!("0");
    } else { println!("1"); }
}


use proconio::{fastout, input};

#[allow(unused_mut)]
#[fastout]
fn main() {
    input! {
        x: usize
    }
    let num = x / 100;
    let x = x % 100;
    let mut res = false;
    solve(0, x, num, &mut res);
    println!("{}", if res { 1 } else { 0 });
}

fn solve(sum: usize, target: usize, time: usize, can: &mut bool) {
    if time == 0 {
        if target == sum {
            *can = true;
        }
        return;
    }

    solve(sum, target, time - 1, can);
    solve(sum + 1, target, time - 1, can);
    solve(sum + 2, target, time - 1, can);
    solve(sum + 3, target, time - 1, can);
    solve(sum + 4, target, time - 1, can);
    solve(sum + 5, target, time - 1, can);
}


use whiteread::parse_line;

fn calc(n: usize, dp: &mut Vec<bool>, price: &[usize; 6]) -> bool {
    if !dp[n] && n > 105 {
        for &p in price {
            if dp[n] {
                break;
            }
            dp[n] = dp[n] | calc(n - p, dp, price);
        }
    }
    dp[n]
}

fn main() {
    let x: usize = parse_line().unwrap();
    let price: [usize; 6] = [100, 101, 102, 103, 104, 105];
    let mut dp: Vec<bool> = vec![false; x + 1];

    dp[0] = true;
    for &p in &price {
        let mut idx = 0;
        while idx <= x {
            dp[idx] = true;
            idx += p;
        }
    }

    calc(x, &mut dp, &price);
    if dp[x] {
        println!("1");
    } else {
        println!("0");
    }
}


use whiteread::parse_line;

fn calc(n: usize, dp: &mut Vec<bool>, price: &[usize; 6]) -> bool {
    if !dp[n] && n > 105 {
        for &p in price {
            if dp[n] {
                break;
            }
            dp[n] = dp[n] || calc(n - p, dp, price);
        }
    }
    dp[n]
}

fn main() {
    let x: usize = parse_line().unwrap();
    let price: [usize; 6] = [100, 101, 102, 103, 104, 105];
    let mut dp: Vec<bool> = vec![false; x + 1];

    dp[0] = true;
    for &p in &price {
        dp[p] = true;
    }

    calc(x, &mut dp, &price);
    if dp[x] {
        println!("1");
    } else {
        println!("0");
    }
}


import CoreFoundation
let n=Int(readLine()!)!

if n < 100  {
  print("0")
  exit(0)
}

var min =  ( n / 100 ) * 100
var max =  min + ( ( n / 100 ) * 5 )

if( n <= max ) {
  print("1")
} else {
  print("0")
}


var N : Int = (Int)(readLine()!)!
let data : [Int]  = [100,101,102,103,104,105]
let size = 1000000 + 1;
var dp = [Int](count: size, repeatedValue: -1)
dp[0] = 0;

for idx in 0..<size{
    if dp[idx] == -1{
        continue;
    }
    for value in data{
        if idx + value  < size {
            dp[idx + value] = 1;
        }
    }
}

if dp[N] == -1 {
    print(0)
} else {
    print(1)
}


import CoreFoundation
let n=Int(readLine()!)!

if n < 100  {
  print("0")
  exit(0)
}

var min =  ( n / 100 ) * 100
var max =  min + ( ( n / 100 ) * 5 )

if( ( min >= n ) && ( n <= max ) ) {
  print("1")
} else {
  print("0")
}


function main(input: string) {
  const X = parseInt(input);
  if (X >= 2000) { // 2000円以上はどうやったってできる
    console.log(1);
    return;
  }
  const num = Math.floor(X / 100); // 個数は上2桁に依存
  const hasuu = X - num * 100; // 端数
  console.log(hasuu / 5 <= num ? 1 : 0);
}

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


import * as fs from 'fs'

const reader = (data: string) =>
  data
    .split('\n')
    .join(' ')
    .split(' ')
    .map(t => parseInt(t, 10))

function Main(input) {
  const [X] = reader(input)
  const num = Math.floor(X / 100)
  const hasuu = X % 100
  if (X < 100) {
    console.log('0')
  } else {
    console.log(hasuu < num * 5 + 1 ? '1' : '0')
  }
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))


const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))}
const main=()=>{
  let n=tn()
  if(n<100){
    to(0)
    return
  }
  let ar=String(n).split('')
  let r=Number(ar[ar.length-2]+ar[ar.length-1])
  ar.pop()
  ar.pop()
  let l=Number(ar.join(''))
  to(l*5>=r?1:0)
}
main()


function main(input: string) {
  const X = parseInt(input);
  if (X >= 2000) { // 2000円以上はどうやったってできる
    console.log(1);
    return;
  }
  const num = Math.floor(X / 100); // 個数は上2桁に依存
  const hasuu = X - num * 100; // 端数
  console.log(hasuu / 5 <= num ? 1 : 0);
  //console.log(`X:${X}, num:${num}, h:${hasuu}`)
}

function debug() {
  for (let i = 0 ; i< 2000; i++) {
    main(i.toString();)
  }
}

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

debug();


function main(input: string) {
  const X = parseInt(input);
  if (X >= 2000) { // 2000円以上はどうやったってできる
    console.log(1)
  }
  const num = Math.floor(X / 100); // 個数は上2桁に依存
  const hasuu = X - num * 100; // 端数
  console.log(hasuu / 5 <= num ? 1 : 0);
}

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


function main(input: string) {
  const X = parseInt(input);
  if (X >= 2100) { // 2100円以上はどうやったってできる
    console.log(1)
  }
  const num = Math.floor(X / 100); // 個数は上2桁に依存
  const hasuu = X - num * 100; // 端数
  console.log(hasuu / 5 <= num ? 1 : 0);
}

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


k = int(input())
print((k // 2 ) *((k + 1) // 2))


k = int(input())
a = k//2
b = k -a

ans = a * b
print(ans)


n=int(input())

even=int(n/2)
if n%2==0:
    odd=even
else:
    odd=even+1

print(odd*even)


n=int(input())
if n%2==0:
    print((n//2)*(n//2+1))
else:
    print((n//2)**2)


n=int(input())
if n%2==0:
    print((n//2)*(n//2+1)
else:
    print((n//2)**2)


s = int(input())
print(s/2 * (s+1)/2)


// 20/02/19 18:15

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

class Main{
    final static long MOD = 1000000007;
    final static long INF = Long.MAX_VALUE / 2;
    FastScanner sc = new FastScanner();

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

    void solve(){

        int n = sc.nextInt();
        int a = 0;
        int b = 0;

        for(int i = 0; i < n; i++){
            if((i + 1) % 2 == 0) a++;
            else b++;
        }

        System.out.println(a * b);

    }

    long mod_pow(long a, long r){ // return a^r (mod MOD)
        long sum = 1;
        while(r > 0){
            if((r & 1) == 1){
                sum *= a;
                sum %= MOD;
            }
            a *= a;
            a %= MOD;
            r >>= 1;
        }
        return sum;
    }

    long mod_inv(long a){ // return aの逆元 (mod MOD)
        return mod_pow(a, MOD - 2);
    }

    long fact(long n){ // return n!
        if(n == 0){
            return 1;
        }
        return n * fact(n - 1);
    }

    long mod_fact(long n){ // retur n! (mod MOD)
        if(n == 0){
            return 1;
        }
        return n * mod_fact(n - 1) % MOD;
    }

    int numOfCombination(int n, int r){ // return nCr
        int num = 1;
        for(int i = 1; i <= r; i++){
            num = num * (n - i + 1) / i;
        }
        return num;
    }

    long gcd(long a, long b){ // return aとbの最大公約数
        if(b == 0){
          return a;
        }
        return gcd(b, a % b);
    }

    boolean is_prime(long a){ // aの素数判定
        if(a <= 1) return false;
        for(int i = 2; i * i <= a; i++){
            if(a % i == 0) return false;
        }
        return true;
    }

    String nextPermutation(String s){ // return sの次の順列
        ArrayList<Character> list = new ArrayList<>();
        for(int i = 0; i < s.length(); i++) list.add(s.charAt(i));

        int pivotPos = -1;
        char pivot = 0;
        for(int i = list.size() - 2; i >= 0; i--){
            if(list.get(i) < list.get(i+1)){
    			pivotPos = i;
    			pivot = list.get(i);
    			break;
    		}
    	}

        if(pivotPos == -1 && pivot == 0) return null;

        int L = pivotPos + 1;
        int R = list.size() - 1;
    	int minPos = -1;
    	char min = Character.MAX_VALUE;
    	for(int i = R; i >= L; i--){
    		if(pivot < list.get(i)){
    			if(list.get(i) < min){
    				min = list.get(i);
    				minPos = i;
    			}
    		}
    	}

    	Collections.swap(list, pivotPos, minPos);
    	Collections.sort(list.subList(L, R + 1));

    	StringBuilder sb = new StringBuilder();
    	for(int i=0; i<list.size(); i++) sb.append(list.get(i));

    	return sb.toString();
    }

}

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

class Pair implements Comparable<Pair>{
    long a, b;
    public Pair(long i, long j){
        a = i;
        b = j;
    }

    @Override
    public int compareTo(Pair p){
        if(this.b < p.b) return -1;
        else if(this.b > p.b) return 1;
        else return 0;
    }
}


import java.io.*;
class Main {
 public static void main(String[] args) throws IOException{
	try ( BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ){
		final int target = Integer.parseInt( br.readLine() );
        int result = (target%2 == 0) ? target*target/4 : (target/2+1)*(target/2);
		System.out.println(result);
	}
 }
}