jiahuimbzuai/CoQuIR huggingface dataset:
//  [cpp]
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <string>
#include <queue>
#include <cmath>
#include <set>
#include <map>
const int oo=2139063143;
const int N=1010000;
const int P=1000000007;
using namespace std;
typedef long long LL;
typedef double db;
//char buf[1<<24],*p1=buf,*p2=buf,obuf[1<<23],*O=obuf;
//#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
template <typename T>
inline void sc (T &x)
{
    x=0; static int p; p=1; static char c; c=getchar();
    while (!isdigit(c)) { if (c=='-') p=-1; c=getchar(); }
    while ( isdigit(c)) { x=(x<<1)+(x<<3)+(c-48); c=getchar(); }
    x*=p;
}
template <typename T>
inline void print (T x)
{
	if (x< 0) putchar('-'),x=-x;
	if (x>=10) print(x/10);
	putchar(x%10+'0');
}
template <typename T>
inline void pr (T x) { print(x),putchar('\n'); }
char s[N];
int main ()
{
	// freopen (".in","r",stdin);
	// freopen (".out","w",stdout);
	scanf ("%s",s+1);
	if (s[1]=='S') puts("Cloudy");
	else if (s[1]=='C') puts("Rainy");
	else puts("Sunny");

	return 0;
}
//  [cpp]
#include<cstdio>
#include<algorithm>
#include<cstring>
#define ll long long
#define abs(a) (a>0?a:(-(a)))
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
using namespace std;
char s[1000];
int main(){
	scanf("%s",s);
	if (s[0]=='S') printf("Cloudy");else
	if (s[0]=='C') printf("Rainy");else
		printf("Sunny");
	return 0;
}
//  [cpp]
#include<stdio.h>
#include<string.h>
int main(void)
{
  char sun[]="Sunny";
  char rei[]="Rainy";
  char cro[]="Cloudy";
  char s[100000];
  scanf("%s",s);
  if(strcmp(s,sun)==0){
	printf("%s\n",cro);
  }
  else if(strcmp(s,rei)==0){
    printf("%s\n",sun);
  }
  else{
    printf("%s\n",rei);
  }
  return 0;
}
//  [cpp]
#include<bits/stdc++.h>
int main(){
string s;
  cin>>s;
  s=="Sunny"?cout<<"Cloudy":(s=="Cloudy"?cout<<"Rainy":cout<<"Sunny");
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

int main() {
    string s;
    cin >> s;
    if (s == "Sunny")
        cout << "Cloudy" << endl;
    else if (s == "Cloudy") {
        cout << "Rainy" << ednl;
    } else {
        cout << "Sunny" << endl;
    }
    return 0;
}
//  [c]
#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;
}
//  [c]
/*
	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;
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [javascript]
"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"));
//  [javascript]
// 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"));
//  [javascript]
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"));
//  [javascript]
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"));
//  [javascript]
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'))
//  [go]
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")
	}
}
//  [go]
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")
	}
}
//  [go]
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])
}
//  [go]
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)
}
//  [go]
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])
	}
}
//  [go]
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()
}
//  [ruby]
S = gets.chomp
W = {'Sunny' => 'Cloudy', 'Cloudy' => 'Rainy', 'Rainy' => 'Sunny'}
puts W[S]
//  [ruby]
S = gets.chomp.to_s
puts 'Sunny' if S=='Rainy'
puts 'Cloudy' if S=='Sunny'
puts 'Rainy' if S=='Cloudy'
//  [ruby]
str = gets.chomp

if str == 'Sunny'
  puts 'Cloudy'
elsif str == 'Cloudy'
  puts 'Rainy'
elsif str == 'Rainy'
  puts 'Sunny'
end
//  [ruby]
Weather = gets

if (Weather == "Sunny")
  print "Cloudy"
elsif (Weather == "Cloudy")
  print "Rainy"
else
  print "Sunny"
end
//  [ruby]
Weather = gets

if Weather == "Sunny" then
  print "Cloudy"
elsif Weather == "Cloudy" then
  print "Rainy"
else
  print "Sunny"
end
//  [ruby]
print "Cloudy"
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

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

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

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

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

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

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

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

fn main() {
    input! {
    	n:chars
    }
    let nn = n.into_iter().collect::<String>();
    
    println!("{}", match nn.trim() {
    "Sunny" => "Cloudy",
    "Cloudy" => "Rainy",
    "Rainy" => "Sunny",
    _ => "NOT"
    });
}
//  [rust]
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()
}
//  [rust]
/* {{{ */
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

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

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

fn main() {
    input! {
        s: String
    }
    println!("{}",
        match &s[..] {
            "Sunny" => "Cloudy",
            "Cloudy" => "Rainy",
            "Rainy" => "Sunny",
            _ => panic!()
        });
}
/* vim:set foldmethod=marker: */
//  [rust]
#[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);
}
//  [rust]
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);
}
//  [rust]
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
        }
    }

}
//  [swift]
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")
}
//  [swift]
var tenki = readLine()!
if tenki=="Sunny" {
  print("Cloudy") }
else if tenki=="Cloudy" {
  print("Rainy") }
else if tenki=="Rainy" {
  print("Sunny")
}
//  [swift]
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()
//  [swift]
let s=readLine()!
if s=="Sunny"{
  print("Cloud")
}else if s=="Cloud"{
  print("Rainy")
}else{
  print("Sunny")
}
//  [swift]
s=readLine()!
if s=="Sunny"{
  print("Cloud")
}else if s=="Cloud"{
  print("Rainy")
}else{
  print("Sunny")
}
//  [swift]
let c=readLine()!.characters.map{$0}[0]
print(c=="S" ?"Cloudy":c=="C" ?"Rainy":c=="R" ?"Sunny")
//  [typescript]
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()
//  [typescript]
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'))
//  [typescript]
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()
//  [typescript]
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'))
//  [typescript]
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'))
//  [typescript]
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'))
//  [python]
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')
//  [python]
A = map(int, input().split())
if len(set(A) ) == 2:
    print("Yes")
else:
    print("No")
//  [python]
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)
//  [python]
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")
//  [python]
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")
//  [python]
print(["No","Yes"][len(set(input().split()))==3])
//  [java]
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");
    }
}
//  [java]
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");
}
}
//  [java]
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");
    
      }
    }
}
//  [java]
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");
    }
}
//  [java]
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");
        }
      }
		
    }
}
//  [cpp]
#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;
}
//  [cpp]
#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;
}
//  [cpp]
#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;
}
//  [cpp]
#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;
}
//  [cpp]
#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;
}
//  [cpp]
#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;
	
}
//  [c]
#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;
}
//  [c]
#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");
    }
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [c]
#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;
}
//  [javascript]
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"))
//  [javascript]
// 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"));
//  [javascript]
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');
}
//  [javascript]
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"))
//  [javascript]
'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"));
//  [javascript]
'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"));
//  [go]
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)
}
//  [go]
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");
	}

	
}
//  [go]
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")
	}
}
//  [go]
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")
	}
}
//  [go]
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)
}
//  [go]
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)

}
//  [ruby]
puts gets.split.map(&:to_i).uniq.size == 2 ? :Yes : :No
//  [ruby]
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
//  [ruby]
n = gets.split.map(&:to_i)
puts n.uniq.size == 2 ? 'Yes':'No'
//  [ruby]
a,b,c = gets.split.map(&:to_i)

if a == b || b == c || a == c
  puts "Yes"
else
  puts "No"
end
//  [ruby]
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
//  [ruby]
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
//  [rust]
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");
	}
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

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

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

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

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

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

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

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

fn main() {
    input!{
        A: usize,
        B: usize,
        C: usize,
    }
    
    if (A == B && A != C)||(A != B && A == C)||(C == B && A != C)  {
        println!("Yes");
    } else {
        println!("No");
    }
    }
//  [rust]
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");
    }
}
//  [rust]
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");
}


}
//  [rust]
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");
}


}
//  [rust]
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");
}


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

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

main()
//  [swift]
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()
//  [swift]
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)
//  [swift]
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) }
//  [swift]
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")
//  [swift]
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")
//  [typescript]
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")));
}
//  [typescript]
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');
}
//  [typescript]
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"));
//  [typescript]
  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"));
//  [typescript]
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")
//  [typescript]
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);
    }
}
//  [python]
import math

X = int(input())
print(1 if math.ceil((X - (X // 100) * 100) / 5) <= X // 100 else 0)
//  [python]
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")
//  [python]
x = int(input())
n = x // 100

if n * 100 <= x <= n * 105:
    print('1')
else:
    print('0')
//  [python]
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()
//  [python]
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()
//  [python]
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()
//  [java]
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");
		
	}
}
//  [java]
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();
    }
}
//  [java]
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);
        }
    }
}