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

public class Main {

	public static void main(String[] args) throws Exception{
		// TODO 自動生成されたメソッド・スタブ
		 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	        String[] line = br.readLine().split(" ");
	        int a = Integer.parseInt(line[0]);
	        int b = Integer.parseInt(line[1]);

	        if(a+b==15){
	            System.out.println("+");
	        }else if(a*b==15){
	            System.out.println("*");
	        }else{
	            System.out.println("x");
	        }
	}

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

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

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

        if (a+b==15) {
            System.out.println('+');
            return;
        }

        if (a*b==15) {
            System.out.println('*');
            return;
        }

        System.out.println('x');
    }
}
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author mikit
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        AF solver = new AF();
        solver.solve(1, in, out);
        out.close();
    }

    static class AF {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int a = in.nextInt(), b = in.nextInt();
            if (a * b == 15) {
                out.println("*");
            } else if (a + b == 15) {
                out.println("+");
            } else {
                out.println("x");
            }
        }

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

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        if(a + b == 15)System.out.println("+");
        else if(a * b == 15) System.out.println("*");
        else System.out.println("x");
    }
}
//  [cpp]
#include <cstdio>

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

    if (a + b == 15) {
        printf("+\n");
    } else if (a * b == 15) {
        printf("*\n");
    } else {
        printf("x\n");
    }

    return 0;
}
//  [cpp]
#include <cstdio>
#include <algorithm>
using namespace std;
int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
    if(a+b==15) printf("+");
    else if(a*b==15) printf("*");
    else printf("x");
return 0;
}
//  [cpp]
#include<cstdio>
using namespace std;
int main(){
	int a, b;
	scanf("%d %d", &a, &b);
	if(a+b == 15) printf("+");
	else if(a*b == 15) printf("*");
	else printf("x");
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

#define fastio 			ios::sync_with_stdio(0);	cin.tie(0); cout.tie(0);  cout<<fixed;  cout<<setprecision(12);
#define randomINT 		mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define	newl 			cout<<"\n"
#define DISP(as)		for(auto it : as) cout<<it<<" ";newl;
#define all(x)         	(x).begin(),(x).end()
#define mset(x,val)    	memset(x,val,sizeof(x))
#define newl           	cout<<"\n"
#define pb             	push_back
#define mp             	make_pair
#define f 				first
#define s 				second
#define dline          cerr<<"///REACHED///\n";
#define deb1(x)        cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y)      cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z)    cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';

typedef long long 				ll;
typedef long double 			ld;
typedef vector<ll> 				vll;
typedef pair<ll , ll> 			pll;
typedef pair<ld, ld> 			pld;
typedef unordered_map<ll, ll> 	um;
typedef vector<pll> 			vpll;

const ll 	MAX5 	= 	1e+5 + 7;
const ll 	MAX7 	= 	1e+7 + 7;
const ll 	MAXN 	= 	MAX7;
const ll   	INF   	=  	0x7f7f7f7f7f7f7f7f;
const int  	INFi 	=  	0x7f7f7f7f;
const ll 	MOD		=  	1e+9 + 7;

vll adj[MAXN]; ll visit[MAXN] = {};
int dx8[] = {0, 1, 1, 1, 0, -1, -1, -1}, dy8[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dx4[] = {0, 1, 0, -1}, dy4[] = {1, 0, -1, 0};

// <------------- Declare Variables Here ------------> //

ll T = 1;
ll n, x, m, y, k;
string s;

// <------------- Implement Functions Here ----------> //



// <------------- Start of main() -------------------> //

void MAIN() {
	ll a,b;
	cin >> a >> b;
	if(a+b == 15) cout<<"+";
	else if(a*b == 15) cout<<"*";
	else cout<<"x";
}

int main() {
	fastio; randomINT;
	//cin>>T;
	while (T--) {
		MAIN();
	}
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

int main(){
	int a, b;
	char temp;
	
	cin>>a>>b;
	
	if(a + b == 15)temp = '+';
	else if(a*b == 15) temp = '*';
	else temp = 'x';
	cout<<temp;
	
	return 0;
}
//  [cpp]
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <numeric>
#include <utility>
#include <cmath>
#include <vector>
#include <list>
#include <set>
#include <stack>
#include <functional>
#include <ctime>
#include <queue>
#include <string>
#include <map>
#include <sstream>
#define MAX_U   10
#define MIN_U   0
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
#define form(i,a,b) for(int i=(a);i<(b);i++)
#define sz(x) ((int)(x).size())
#define CLR(a) memset((a), 0 ,sizeof(a))
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<char> vc;
typedef vector<string> vs;
typedef queue<int> qi;
const int INF=numeric_limits<int>::infinity();
void printa(){cout<<"\n";}
template<class T, class... A>void printa(const T&first,const A&... rest){cout<<first;printa(rest...);}
template<class... A>void printa(const A&... rest){printa(rest...);}
void prints(){cout<<" ";}
template<class T, class... A>void prints(const T&first,const A&... rest){cout<<first;prints(rest...);}
template<class... A>void prints(const A&... rest){prints(rest...);}
int factorial(int x){int f=1;for(int i=1;i<x+1;i++)f=f*i;return f;}
int sigma(int x){int s;for(int i=1;i<x+1;i++)s=s+i;return s;}
int middle(int x){if(x%2==0)return x/2;else return x/2+1;}
double heron(int a,int b,int c){double s;s=(a+b+c)/2;return sqrt(s*(s-a)*(s-b)*(s-c));}
double trapezium(int a,int b,int h){return (a+b)*h/2;}
double triangle(int a,int h){return a*h/2;}
void sorm(vector<int> vec){sort(vec.begin(),vec.end());}
void sorg(vector<int> vec){sort(vec.begin(),vec.end(),greater<int>());}
int cmp( const void *p, const void *q ) {if( *(double*)p > *(double*)q ) return 1;if( *(double*)p < *(double*)q ) return -1;return 0;}

int main(void){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int a,b,c,d,e;
    //int f=0;
    string st,tt,nt;
    vi ad,bd,cd,dd;
    //vs as,bs,cs,ds;
    //a=0;
    e=0;d=0;
    cin>>a>>b;
    if(a*b==15)printa("*");
    else if(a+b==15)printa("+");
    else printa("x");
    return 0;
}
//  [c]
#include<stdio.h>
int main(void){

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

if(a+b == 15){
printf("+");
}
else if(a*b == 15){
printf("*");
}
else{
printf("x");
}


return 0;
}
//  [c]
#include <stdio.h>
int main (void){
  int a = 0,b = 0;
  
  scanf("%d %d", &a, &b);
  
  if(a+b == 15){
    printf("+\n");
  }else if(a*b == 15){
    printf("*\n");
  }else{
    printf("x\n");
  }
  
  return 0;
}
//  [c]
#include<stdio.h>
int main(){
	int a,b;
	scanf("%d%d",&a,&b);
	if(a+b==15)puts("+");
	else if(a*b==15)puts("*");
	else puts("x");
}
//  [c]
#include <stdio.h>

int main(){
  int a,b;
  scanf("%d %d",&a,&b);
  if(a+b==15) printf("+\n");
  else if(a*b==15) printf("*\n");
  else printf("x\n");
  return 0;
}
//  [c]
#include<stdio.h>

int main(){
  int a,b;
  scanf("%d %d",&a,&b);
  if (a+b==15) printf("%c",'+');
  else if (a*b==15) printf("%c",'*');
  else printf("%c",'x');
}
//  [c]
#include <stdio.h>

int main(void) {
	int a, b;
	if (scanf("%d%d", &a, &b) != 2) return 1;
	if (a + b == 15) puts("+");
	else if (a * b == 15) puts("*");
	else puts("x");
	return 0;
}
//  [javascript]
"use strict";
    
const main = arg => {
    arg = arg.trim().split("\n");
    const A = ~~arg[0].split(" ")[0];
    const B = ~~arg[0].split(" ")[1];
    
    if(A + B === 15) {
        console.log("+");
    } else if(A * B === 15) {
        console.log("*");
    } else {
        console.log("x");
    }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
	input = input.split(" ").map((input)=>Number(input));
  if(input[0] + input[1] == 15){
     console.log("+");
     }else if(input[0] * input[1] == 15){
    console.log("*");
  }else{
    console.log("x");
  }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	input = input.split(" ").map(Number);
  if(input[0]*input[1]==15){
    console.log("*")
  }else if(input[0]+input[1]==15){
  console.log("+")
  }else{
  console.log("x")
  }
}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
var toInt = x=>parseInt(x,10);
var toIntArr = arr=>arr.map(x=>toInt(x));
var abs = x=>x>0?x:-x;
function min(){var rest = arguments,val=rest[0];for(var i=1;i<rest.length;i++)if(rest[i]<val)val = rest[i];return val}
function max(){var rest = arguments,val=rest[0];for(var i=1;i<rest.length;i++)if(rest[i]>val)val = rest[i];return val}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
 
function Main(input){
	var input = input.split(' ');
	var a = toInt(input[0]);
	var b = toInt(input[1]);
	var ans = (a+b===15)? '+': (a*b===15)? '*': 'x';

	console.log(ans);
}
//  [javascript]
'use strict'

function Main(input) {
  const a = Number(input.split(' ')[0]);
  const b = Number(input.split(' ')[1]);

  if(a + b === 15) {
    console.log('+');
  } else if(a * b === 15) {
    console.log('*');
  } else {
    console.log('x');
  }

}

Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
"use strict";

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

var g_input = '';
process.stdin.on('data', function(chunk) {
    g_input += chunk;
});

process.stdin.on('end', function() {
    Main(g_input.split(/\r?\n/));
});

function Main(input) {

    const ab = input[0].split(' ').map(function(value) { return parseInt(value, 10); });
    const a = ab[0];
    const b = ab[1];

    let ans = '';
    if (a + b === 15) {
        ans = '+';
    } else if (a * b === 15) {
        ans = '*';
    } else {
        ans = 'x';
    }

    console.log(ans);

    return 0;
}
//  [go]
package main

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

func main() {
	sc.Split(bufio.ScanWords)
	a, b := nextInt(), nextInt()
	if a+b == 15 {
		puts("+")
	} else if a*b == 15 {
		puts("*")
	} else {
		puts("x")
	}
	wt.Flush()
}

var (
	sc  = bufio.NewScanner(os.Stdin)
	rdr = bufio.NewReaderSize(os.Stdin, 1000000)
	wt  = bufio.NewWriter(os.Stdout)
)

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

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

func nextFloat64() float64 {
	f, _ := strconv.ParseFloat(next(), 64)
	return f
}

func nextInts(n int) []int {
	slice := make([]int, n)
	for i := 0; i < n; i++ {
		slice[i] = nextInt()
	}
	return slice
}

func nextFloat64s(n int) []float64 {
	slice := make([]float64, n)
	for i := 0; i < n; i++ {
		slice[i] = nextFloat64()
	}
	return slice
}

func nextMega() string {
	buf := make([]byte, 0, 1000000)
	for {
		l, p, _ := rdr.ReadLine()
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}

func putf(format string, a ...interface{}) {
	fmt.Fprintf(wt, format, a...)
}

func puts(a ...interface{}) {
	fmt.Fprintln(wt, a...)
}
//  [go]
package main

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

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1000005), 1000005)
	return scanner
}

func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}

func getNextInt64(scanner *bufio.Scanner) int64 {
	i, _ := strconv.ParseInt(getNextString(scanner), 10, 64)
	return i
}

func getNextUint64(scanner *bufio.Scanner) uint64 {
	i, _ := strconv.ParseUint(getNextString(scanner), 10, 64)
	return i
}

func getNextFloat64(scanner *bufio.Scanner) float64 {
	i, _ := strconv.ParseFloat(getNextString(scanner), 64)
	return i
}

func main() {
	fp := os.Stdin
	wfp := os.Stdout
	cnt := 0

	if os.Getenv("MASPY") == "ますピ" {
		fp, _ = os.Open(os.Getenv("BEET_THE_HARMONY_OF_PERFECT"))
		cnt = 2
	}
	if os.Getenv("MASPYPY") == "ますピッピ" {
		wfp, _ = os.Create(os.Getenv("NGTKANA_IS_GENIUS10"))
	}

	scanner := getScanner(fp)
	writer := bufio.NewWriter(wfp)
	solve(scanner, writer)
	for i := 0; i < cnt; i++ {
		fmt.Fprintln(writer, "-----------------------------------")
		solve(scanner, writer)
	}
	writer.Flush()
}

func solve(scanner *bufio.Scanner, writer *bufio.Writer) {
	a := getNextInt(scanner)
	b := getNextInt(scanner)
	if a+b == 15 {
		fmt.Fprintln(writer, "+")
		return
	}
	if a*b == 15 {
		fmt.Fprintln(writer, "*")
		return
	}
	fmt.Fprintln(writer, "x")
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scanf("%d%d", &a, &b)
	if a+b == 15 {
		fmt.Printf("+\n")
		return
	}
	if a*b == 15 {
		fmt.Printf("*\n")
		return
	}
	fmt.Printf("x\n")
	return
}
//  [go]
package main

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

var (
	readString func() string
	stdout     *bufio.Writer
)

func init() {
	readString = newReadString(os.Stdin)
	stdout = bufio.NewWriter(os.Stdout)
}

func newReadString(ior io.Reader) func() string {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), int(1e+11))
	r.Split(bufio.ScanWords)

	return func() string {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Text()
	}
}

func readInt() int {
	return int(readInt64())
}

func readInt64() int64 {
	i, err := strconv.ParseInt(readString(), 0, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

func readIntSlice(n int) []int {
	b := make([]int, n)
	for i := 0; i < n; i++ {
		b[i] = readInt()
	}
	return b
}

func readLengthAndSlice() []int {
	n := readInt()
	return readIntSlice(n)
}

func printf(f string, args ...interface{}) (int, error) {
	return fmt.Fprintf(stdout, f, args...)
}

func println(args ...interface{}) (int, error) {
	return fmt.Fprintln(stdout, args...)
}

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

func minUint(a, b uint) uint {
	if a < b {
		return a
	}
	return b
}

func minInt64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func minUint64(a, b uint64) uint64 {
	if a < b {
		return a
	}
	return b
}

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

func maxUint(a, b uint) uint {
	if a < b {
		return b
	}
	return a
}
func maxInt64(a, b int64) int64 {
	if a < b {
		return b
	}
	return a
}

func maxUint64(a, b uint64) uint64 {
	if a < b {
		return b
	}
	return a
}

func absInt(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

func absInt64(a int64) int64 {
	if a < 0 {
		return -a
	}
	return a
}

// readString() string
// readInt() int
// readIntSlice(n int) []int
// readLengthAndSlice() []int
func main() {
	defer stdout.Flush()
	a := readInt()
	b := readInt()
	if a+b == 15 {
		println("+")
	} else if a*b == 15 {
		println("*")
	} else {
		println("x")
	}
}
//  [go]
package main

import "fmt"

func main() {
	// Code for A - F
	var a, b int
	fmt.Scanf("%d %d", &a, &b)

	if a+b == 15 {
		fmt.Println("+")
	} else if a*b == 15 {
		fmt.Println("*")
	} else {
		fmt.Println("x")
	}
}
//  [ruby]
# frozen_string_literal: true

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

if a + b == 15
  puts '+'
else
  puts a * b == 15 ? '*' : 'x'
end
//  [ruby]
a, b = gets.split(" ").map(&:to_i)
if a + b == 15
  puts "+"
elsif a * b == 15
  puts "*"
else
  puts "x"
end
//  [ruby]
a, b = gets.chomp.split.map(&:to_i)
if a + b == 15
  puts "+"
elsif a * b == 15
  puts "*"
else
  puts "x"
end
//  [ruby]
a, b = gets.split.map(&:to_i)
if a+b==15
  puts '+'
elsif a*b == 15
  puts '*'
else
  puts 'x'
end
//  [ruby]
a,b=gets.split.map &:to_i
puts a+b==15 ? ?+ : a*b==15 ? ?* : ?x
//  [ruby]
class Problem
  attr_accessor *(?a..?z).to_a.map(&:to_sym)
  def initialize
    @a, @b = gets.split.map(&:to_i)
  end

  def solve
    return "+" if a + b == 15
    return "*" if a * b == 15
    return "x"
  end

  def show(ans)
    puts ans
  end
end

Problem.new.instance_eval do
  show(solve)
end
//  [rust]
use std::str::FromStr;
fn main() {
    let mut ab = String::new();
    std::io::stdin().read_line(&mut ab).ok();
    let mut it = ab.split_whitespace().map(|n| usize::from_str(n).unwrap());
    let (a,b) = (it.next().unwrap(),it.next().unwrap());
    if a + b == 15 {
        println!("+");
    } else if a * b == 15 {
        println!("*");
    } else {
        println!("x");
    }
}
//  [rust]
fn main() {
	let v: Vec<i32> = read_vec();
	if v[0]+v[1] == 15 {
		println!("+");
	} else if v[0]*v[1] == 15 {
		println!("*");
	} else {
		println!("x");
	}
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    let mut buf = String::new();
    std::io::stdin().read_line(&mut buf).unwrap();
    buf.trim().split_whitespace().map(|e|
        e.parse().ok().unwrap()
    ).collect()
}
//  [rust]
use std::io::*;
use std::str::FromStr;
use utils::*;

pub fn main() {
    let i = stdin();
    let mut o = Vec::new();
    run(i.lock(), &mut o);
    stdout().write_all(&o).unwrap();
}

fn run<R: BufRead, W: Write>(i: R, o: &mut W) {
    let mut i = CpReader::new(i);
    let (a, b) = i.read2::<usize, usize>();
    let r = if a + b == 15 {
        "+"
    } else if a * b == 15 {
        "*"
    } else {
        "x"
    };
    writeln!(o, "{}", r).unwrap();
}

mod utils {
    use super::*;

    pub struct CpReader<R: BufRead> {
        r: R,
        s: String,
    }

    macro_rules! fn_read {
        {$f:ident($($v:ident: $t:ident),*)} => {
            pub fn $f<$($t: FromStr),*>(&mut self) -> ($($t),*) {
                let i = &mut self.read_line().split(' ');
                $(
                    let $v = i.next().unwrap().parse().ok().unwrap();
                )*
                ($($v),*)
            }
        };
    }

    impl<R: BufRead> CpReader<R> {
        pub fn new(r: R) -> Self {
            CpReader {
                r: r,
                s: String::new(),
            }
        }
        pub fn read_line(&mut self) -> &str {
            self.s.clear();
            self.r.read_line(&mut self.s).unwrap();
            self.s.trim()
        }

        fn_read! { read2(v1: T1, v2: T2) }
    }
}
//  [rust]
#![allow(unused_imports)]

use text_io::*;
use proconio::*;
use std::collections::*;
use itertools::Itertools;
use std::process::exit;
use std::cmp::*;
use num::*;
use num::integer::Roots;

fn main() {
    input! {
    a:usize,
    b:usize,
    }
    println!("{}",if a+b==15{"+"}else if a*b==15{"*"}else{"x"})
}
//  [rust]
use std::io;

fn main() {
    let mut input_string = String::new();
    io::stdin()
        .read_line(&mut input_string)
        .unwrap();
    let input_ints: Vec<u8> = input_string.trim().split(" ")
        .map(|s| s.parse::<u8>().unwrap())
        .collect();
    let (a, b) = (input_ints[0], input_ints[1]);

    let output = if a+b == 15 { "+" }
                 else if a*b == 15 { "*" }
                 else { "x" };
    println!("{}", output);
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!},a=i[0],b=i[1]
print(a+b==15 ?"+":a*b==15 ?"*":"x")
//  [typescript]
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
/* eslint-env es6, mocha, node */
/* eslint-extends: eslint:recommended */
'use strict';



// Import modules
import fs = require("fs");


// Read stdin
const data = fs.readFileSync("/dev/stdin", "utf-8");


// Main
const [a, b] = data.split(" ").map((v) => Number(v));


// Output
if (a + b === 15) {
    console.log("+");
} else if (a * b === 15) {
    console.log("*");
} else {
    console.log("x");
}



/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * c-hanging-comment-ender-p: nil
 * End:
 */
//  [python]
import numpy as np
a=np.array(list(map(int, input().split())))

def main():
  for i in range(3):
    if (a[i]==a).sum()==2:
      print('Yes')
      return
  print('No')
main()
//  [python]
import numpy as np

A = [int(x) for x in input().split()]
A = np.array(A)
t = 0

if A[0] == A[1]:
  t += 1
else:
  pass

if A[0] == A[2]:
  t += 1
else:
  pass

if A[1] == A[2]:
  t += 1
else:
  pass

if t == 1:
  print("Yes")
else:
  print("No")
//  [python]

import re
import numpy as np
import math

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

a, b, c = map(int, input().split())
if a==b:
  if a==c:
    print('No')
  else:
    print('Yes')
else:
  if a==c:
    print('Yes')
  else:
    if b==c:
      print('Yes')
    else:
      print('No')
//  [java]
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		try(Scanner sc = new Scanner(System.in)) {
			
			int a = sc.nextInt();
			int b = sc.nextInt();
			int c = sc.nextInt();
			
			List<Integer> lst = new ArrayList<Integer>();
			lst.add(a);
			lst.add(b);
			lst.add(c);
			
			long count = lst.stream().distinct().count();
			
			System.out.println(count == 2 ? "Yes" : "No");
			
		}
	}
}
//  [java]
import java.util.*;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        List<Integer> list = new ArrayList<>();
        list.add(scanner.nextInt());
        list.add(scanner.nextInt());
        list.add(scanner.nextInt());
        List<Integer> newList = list.stream().distinct().collect(Collectors.toList());
        if (newList.size() == 2) {
            System.out.println("Yes");
        } else {
            System.out.println("No");
        }
    }
}
//  [cpp]
// This file is a "Hello, world!" in C++ language by GCC for wandbox.
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    int a, b, c;
    
    cin >> a >> b >> c;
    
    if (a == b && b == c) {
        cout << "No" << endl;
    } else if (a == b || b == c || c == a) {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }        
    return 0;
}

// GCC reference:
//   https://gcc.gnu.org/

// C++ language references:
//   https://cppreference.com/
//   https://isocpp.org/
//   http://www.open-std.org/jtc1/sc22/wg21/

// Boost libraries references:
//   https://www.boost.org/doc/
//  [c]
#include <stdio.h>
int main(void){
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    if(a == b && b == c){
        printf("No");
    }else if(a == b || b == c || a == c){
        printf("Yes");
    }else{
        printf("No");
    }
  
}
//  [c]
#include <stdio.h>
	int main()
	{
	int num1, num2, num3;
	scanf("%d %d %d", &num1, &num2, &num3);
	if (num1 == num2 && num2 == num3 && num1 == num3){
		printf("No");
	}
	else if (num1!=num2 && num1!=num3 && num2!=num3){
		printf("No");
	} 
	else {
		printf("Yes");
	}
	return 0;
	}
//  [c]
#include <stdio.h>
int main(void) {
   int A, B, C;
   scanf("%d%d%d", &A, &B, &C);
   if((A == B && B == C) || (A != B && B != C && C != A)) {
      printf("No\n");
   } else {
      printf("Yes\n");
   }
   return 0;
}
//  [javascript]
"use strict"
function Main(input) {
  input = input.trim().split(' ').map(Number);
  const A = input[0];
  const B = input[1];
  const C = input[2];

  let ret = 'No';

  if(A === B && A !== C){
    ret = 'Yes';
  } else if ( A === C && A !== B){
    ret = 'Yes';
  }  else if ( B === C && B !== A){
    ret = 'Yes';
  }

  console.log(ret);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
var input = require("fs").readFileSync("/dev/stdin", "utf8").trim().split("\n");
var obj = {
  "list" : input,
  "index" : 0,
  "max" : input.length,
  "next" : function(){
    if(!this.hasNext()){throw "NoSuchElementException:次に要素は無いよ";}
    var returnObj = this.list[this.index];
    this.index++;
    return returnObj;
  },
  "hasNext" : function(){return (this.index < this.max);}
}
Main();
function next(){return obj.next();}
function hasNext(){return obj.hasNext();}
function myout(t){console.log(t);}//standard output
function myerr(t){console.error(t);}//standard error
//[no]要素の扱い。数値型
//不明値、異常時:引数そのまま返す　1:数値へ変換
//2:半角SPで分割 4:半角SPで分割し、数値配列へ
//6:1文字で分割  7:1文字で分割し、数値配列へ
//8:半角SPで結合 9:改行で結合 0:文字なしで結合
function myconv(i,no){try{switch(no){case 1:return parseInt(i);case 2:return i.split(" ");case 4:return i.split(" ").map((a)=>Number(a));case 6:return i.split("");case 7:return i.split("").map((a)=>Number(a));case 8:return i.join(" ");case 9:return i.join("\n");case 0:return i.join("");default:return i;}}catch(e){return i;}}
function Main(){
  var one = myconv(next(),4);
  var a = one[0];
  var b = one[1];
  var c = one[2];
  if(a == b && a != c ||
    a == c && b != c ||
    b == c && a != c){
     myout("Yes");
  }else{
    myout("No");
  }
}
//  [go]
package main

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

func main() {
	a, b, c := readI(), readI(), readI()
	if (a == b && b == c) || (a != b && b != c && c != a) {
		fmt.Println("No")
		return
	}
	fmt.Println("Yes")
}

/*-----------Input utils-----------*/

var sc = bufio.NewScanner(os.Stdin)

func init() {
	if len(os.Args) >= 2 {
		if os.Args[1] == "debug" {
			debug()
		}
	}
	const buf = 200100
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, buf), buf)
}

func debug() {
	testFile, err := os.Open("./test/sample-1.in")
	if err != nil {
		fmt.Fprintln(os.Stderr, "There is no testfile.")
		os.Exit(1)
	}
	sc = bufio.NewScanner(testFile)
}

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

func readR() []rune {
	return []rune(readS())
}

func readI() int {
	i, _ := strconv.Atoi(readS())
	return i
}

func readF() float64 {
	f, _ := strconv.ParseFloat(readS(), 64)
	return f
}
//  [go]
package main

import (
	"fmt"
)

func main() {
  var a, b, c int
  fmt.Scanf("%d %d %d", &a, &b, &c)

  cnt := map[int]int{}
  cnt[a]++
  cnt[b]++
  cnt[c]++
  ans := "No"
  
  for _, v := range cnt {
    if v == 2 {
      ans ="Yes"
    }
  }
  fmt.Printf("%s\n", ans)
}
//  [ruby]
require 'set'

class Hash
  def push(key, value)
    self[key] = [] if self[key] == nil
    self[key].push(value)
  end
end

class Array
  def lower_bound(value)
    left = -1;
    right = self.length;
    while left + 1 < right
      mid = left + (right - left) / 2;
      if self[mid] >= value
        right = mid
      else
        left = mid
      end
    end
    right
  end

  def unique
    res = [self.first]
    each_cons(2) do |a, b|
      if a != b
        res.push(b)
      end
    end
    res
  end
end

def get_ints
  gets.split.map(&:to_i)
end

def get_ints_minus_one
  get_ints.map { |x| x - 1 }
end

def get_int
  gets.chomp.to_i
end

A, B, C = get_ints

set = Set.new
set.add(A)
set.add(B)
set.add(C)

if set.length == 2
  puts 'Yes'
else
  puts 'No'
end
//  [ruby]
S = gets.split(" ").map(&:to_i)

if S.uniq.length == 2 then
    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 && x!=z
  puts "No"
else
  puts "Yes"
end
//  [typescript]
import * as fs from 'fs';
// main
function main(input: string[]) {
    // param
    let a, b, c;
    let ans;
    // init
    [a, b, c] = input.shift().split(" ").map(x => Number(x));
    // solve
    ans = "No";
    if (a == b && b != c) ans = "Yes";
    if (b == c && c != a) ans = "Yes";
    if (c == a && a != b) ans = "Yes";
    // answer
    console.log(ans);
}
// entrypoint
function entrypoint() {
    try {
        // linux
        let input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
        console.debug = function () { };
        main(input);
    }
    catch (ex) {
        // windows
        const lines: string[] = [];
        // @ts-ignore
        const reader = require('readline').createInterface({
            // @ts-ignore
            input: process.stdin,
            // @ts-ignore
            output: process.stdout
        });
        reader.on('line', function (line: string) {
            lines.push(line);
        });
        reader.on('close', function () {
            let input = lines;
            main(input);
        });
    }
}
entrypoint();
//  [typescript]
class AtCoder {
  // 入力系
  input=[];
  input_i=-1;
  n(){
    this.input_i++;
    return Number(this.input[this.input_i]);
  }
  nn(n){
    const a=[];
    for(let i=0;i<n;i++){
      a.push(this.n());
    }
    return a;
  }
  s(){
    this.input_i++;
    return String(this.input[this.input_i]);
  }
  ss(n){
    const a=[];
    for(let i=0;i<n;i++){
      a.push(this.s());
    }
    return a;
  }
 
  // コンソール
  o(...a:any){
    console.log(...a);
  }
 
  // Math
  abs(a:number){
    return Math.abs(a);
  }
  min(...a:number[]){
    return Math.min(...a);
  }
  max(...a:number[]){
    return Math.max(...a);
  }
  floor(a:number){
    return Math.floor(a);
  }
  ceil(a:number){
    return Math.ceil(a);
  }
  round(a:number){
    return Math.round(a);
  }
 
  // ソート
  asc(ar:number[]){
    const t=[...ar];
    ar.sort((a,b)=>{return a-b});
  }
  desc(ar:number[]){
    const t=[...ar];
    ar.sort((a,b)=>{return b-a});
  }
 
  // 自作
  gcd(...arr):number{
    for(let i=0;i<arr.length-1;i++){
      let [x,y]=[arr[i],arr[i+1]];
      while(y){
        [x,y]=[y,x%y];
      }
      arr[i+1]=x;
    }
    return arr[arr.length-1];
  };
  lcm(...arr):number{
    for(let i=0;i<arr.length-1;i++){
      let [x,y]=[arr[i],arr[i+1]];
      while(y){
        [x,y]=[y,x%y];
      }
      arr[i+1]=arr[i]*arr[i+1]/x;
    }
    return arr[arr.length-1];
  };
  isPrime(n:number):boolean{
    if(n < 2) return false;
    const suq=Math.sqrt(n);
    for(let i=2;i<=suq;i++){
      if(n%i==0){
        return false;
      }
    }return true;
  };
  deduplicate(a:any[]):any[]{
    return Array.from(new Set(a));
  };
}
const o = new AtCoder()
var reader = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on('line',(line:any)=> {
  o.input.push(...line.split(/[\s]/));
});

process.stdin.on('end', ()=> {
  let obj={}
  obj[o.s()] = 1;
  obj[o.s()] = 1;
  obj[o.s()] = 1;
  console.log(Object.keys(obj).length == 2 ? 'Yes' : 'No')
});
//  [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))?"Yes":"No")
  }
  
  //DO NOT EDIT
  Main(new NormalInput(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
import sys
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

N = I()
a = [100,101,102,103,104,105]
dp = [[False]*(N+1) for i in range(6+1)]
dp[0][0] = True

for i in range(1,6+1):
  for j in range(N+1):
    if dp[i - 1][j] == True:
      k = 0
      while 0 <= (j + a[i - 1]*k) < N+1:
        dp[i][j + a[i - 1]*k] = True
        k += 1
print(int(dp[-1][-1]))
//  [python]
X = int(input())

Data = [0]*(X+1)
Data[0] = 1

for c in range(100,106):
    for i in range(X+1):
        if Data[i] == 1:
            n = 1
            while c*n + i <= X:
                Data[c*n+i] = 1
                n+=1
if Data[X] == 1:
    print(1)
else:
    print(0)
//  [python]
import sys
N=int(input())

if 100<=N<=105:
    print(1)
    sys.exit()

min_=N//105
max_= N//100 + 1
#print(min_,max_)
count=0
for m in range(min_,max_):
    X = N - 100*m
    for i in range(0,X+1):
        for j in range(0,(X-i)//2 +1):
            for k in range(0,(X-i-2*j)//3 +1):
                for l in range(0,(X-i-2*j-3*k)//4 +1):
                    count+=1
                    if count >= 5*10**7:
                        print(1)
                        sys.exit()
                    temp = (X-i-2*j-3*k-4*l)
                    if (temp % 5 == 0) and (m-i-j-k-l-temp//5>=0):
                        a=m-i-j-k-l-temp//5
                        t=temp // 5
                        print(1)
                        #print(N,m,a,i,j,k,l,t,100*a+101*i+102*j+103*k+104*l+105*t)
                        sys.exit()
else:
    print(0)
//  [java]
import java.util.Scanner;

public class Main {

	private static int[] gs = new int[]{100,101,102,103,104,105};

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int X = sc.nextInt();
		sc.close();

		if(X < 100){
			System.out.println(0);
			return;
		}

		for(int i0 = 0;i0 <= X/100;i0++){
			for(int i1 = 0;i1 <= X/101;i1++){
				for(int i2 = 0;i2 <= X/102;i2++){
					for(int i3 = 0;i3 <= X/103;i3++){
						for(int i4 = 0;i4 <= X/104;i4++){
							for(int i5 = 0;i5 <= X/105;i5++){
								if(gs[0]* i0 + gs[1] * i1 + gs[2] * i2 + gs[3] * i3 + gs[4] * i4 + gs[5] * i5 == X){
									System.out.println(1);
									return;
								}
							}
						}
					}
				}
			}
		}
		System.out.println(0);
	}
}
//  [java]
import java.util.*;
import java.util.stream.*;

public class Main {

    public static void main(String[] args) {
	// write your code here
        Scanner sc = new Scanner(System.in);
        int target = sc.nextInt();
        List<Integer> products = new ArrayList<>(Arrays.asList(100, 101, 102, 103, 104, 105));
        List<Integer> p = IntStream.rangeClosed(0, target).map(e -> e == 0 ? e : -1).boxed().collect(Collectors.toList());
        for (int product : products) {
            for (int j = 0; j <= target; j++) {
                if (p.get(j) >= 0) p.set(j, 1000000);
                else if (j < product || p.get(j - product) <= 0) p.set(j, -1);
                else p.set(j, p.get(j - product) - 1);
            }
        }

        System.out.println(p.get(target) >= 0 ? 1 : 0);
    }
}
//  [cpp]
/*
    Author:zeke
    
    pass System Test!
    GET AC!!
*/
#include <iostream>
#include <queue>
#include <vector>
#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include <algorithm>
#include <functional>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <map>
#include <iomanip>
#include <utility>
#include <stack>
using ll = long long;
using ld = long double;
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define rep3(var, min, max) for (ll(var) = (min); (var) < (max); ++(var))
#define repi3(var, min, max) for (ll(var) = (max)-1; (var) + 1 > (min); --(var))
#define Mp(a, b) make_pair((a), (b))
#define F first
#define S second
#define Icin(s) \
    ll(s);      \
    cin >> (s);
#define Scin(s) \
    ll(s);      \
    cin >> (s);
template <class T>
bool chmax(T &a, const T &b)
{
    if (a < b)
    {
        a = b;
        return 1;
    }
    return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
    if (b < a)
    {
        a = b;
        return 1;
    }
    return 0;
}
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef vector<V> VV;
typedef vector<P> VP;
ll MOD = 1e9 + 7;
ll INF = 1e18;

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    vector<bool> dp(1e6, false);
    dp[0]=true;
    rep(i,1001){
        rep(j,100001){
            if(dp[j]){
                dp[j + 100] = true;
                dp[j + 101] = true;
                dp[j + 102] = true;
                dp[j + 103] = true;
                dp[j + 104] = true;
                dp[j + 105] = true;
            }
        }
    }
    ll n;
    cin >> n;
    if(dp[n]){
        cout << 1 << endl;
    }else{
        cout << 0 << endl;
    }
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

#define REP(i, m, n) for (int i = (m); i < (int)(n); i++)
#define REPS(i, m, n) for (int i = (m); i <= (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define reps(i, n) for (int i = 0; i <= (int)(n); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define rreps(i, x) for (int i = (int)(x); i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb push_back
#define fi first
#define se second
typedef long long ll;
typedef pair<int, int> P;
const int inf = INT_MAX;
const ll INF = 1LL << 60;
const ll mod = 1e9 + 7;
const double EPS = 1e-10;
const double PI = acos(-1.0);
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; }
template<typename A, size_t N, typename T> void Fill(A (&array)[N], const T &val) { fill( (T*)array, (T*)(array+N), val ); }

ll dp[1000010];
int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);

    ll X; cin >> X;
    REPS(i, 100, 105) dp[i] = 1;
    reps(i, 1000) {
        rep(j, X) {
            REPS(k, 100, 105) {
                chmax(dp[j+k], dp[j]);
            }
        }
    }
    if (dp[X]) cout << 1 << endl;
    else cout << 0 << endl;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
int main()
{
 
    int x;
    cin>>x;
 
    int wk1,wk2;
    wk1=x/100;
    wk2=x%100;
 
    bool flag = false;
    for(int i=0;i<=wk1;i++){
        for(int j=0;j+i<=wk1;j++){
            for(int k=0;i+j+k<=wk1;k++){
                for(int l=0;i+j+k+l<=wk1;l++){
                        int m=(wk2-i*1-j*2-k*3-l*4)/5;
                        if(i*1+j*2+k*3+l*4+m*5==wk2 && i+j+k+l+m<=wk1 ){
                            flag=true;
                            break;
                        }
                }
            }
        }
    }
 
    if(flag)
        cout<<1<<endl;
    else
        cout<<0<<endl;
    
 
    return 0;
}
//  [c]
#include<stdio.h>

int main(void) {

	int x;
	int a, b, c, d, e, f;
	int tmp;  
	
	scanf("%d", &x);

	for (a = 0; a <= (x/100); a++) {
		for (b = 0; b <= (x/100); b++) {
			for (c = 0; c <= (x / 100); c++) {
				for (d = 0; d <= (x / 100); d++) {
					for (e = 0; e <= (x / 100); e++) {
						for (f = 0; f <= (x / 100); f++) {
							tmp = 100*a + 101*b + 102*c + 103*d + 104*e + 105*f;
							if (tmp == x) {
								printf("1");
								return 0;
							}
						}
					}
				}
			}
		}
	}
	
	printf("0\n");

	return 0;
}
//  [c]
#include<stdio.h>
 
int main(void) {
 
	int x;
	int a, b, c, d, e, f;
	int tmp;  
	
	scanf("%d", &x);
 
	for (a = 0; a <= (x/100); a++) {
		for (b = 0; b <= (x/101); b++) {
			for (c = 0; c <= (x / 102); c++) {
				for (d = 0; d <= (x / 103); d++) {
					for (e = 0; e <= (x / 104); e++) {
						for (f = 0; f <= (x / 105); f++) {
							tmp = 100*a + 101*b + 102*c + 103*d + 104*e + 105*f;
							if (tmp == x) {
								
								printf("1\n");
								return 0;
							}
						}
					}
				}
			}
		}
	}
	
	printf("0\n");
 
	return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>




int main(void){
int x;
scanf("%d",&x);
//分類
if(x>=2000){printf("1");return 0;}

//総当たり
int a=0,b=0,c=0,d=0,e=0,f=0;
const int TIME=20;
    for(a=0;a<TIME;a++){
        for(b=0;b<TIME;b++){
            for(c=0;c<TIME;c++){
                for(d=0;d<TIME;d++){
                    for(e=0;e<TIME;e++){
                        for(f=0;f<TIME;f++){
                            if(a*100+b*101+c*102+d*103+e*104+f*105==x){printf("1");return 0;}
                        }
                    }
                }
            }
        }
    }

printf("0");
}
//  [javascript]
"use strict";
var GET=(function(){function f(s){return new g(s);}function g(s){this._s=s.trim().split("\n");this._y=0;}g.prototype.a=function(f){var s=this._s, y=this._y, r;if(typeof s[y]==="string")s[y]=s[y].split(" ").reverse();r=s[y].pop();if(!s[y].length)this._y++;return f?r:+r;};g.prototype.l=function(f){var s=this._s[this._y++].split(" ");return f?s:s.map(a=>+a);};g.prototype.m=function(n,f){var r=this._s.slice(this._y,this._y+=n).map(a=>a.split(" "));return f?r:r.map(a=>a.map(a=>+a));};g.prototype.r=function(n,f){var r=this._s.slice(this._y,this._y+=n);return f?r:r.map(a=>+a);};return f;})();
var o=GET(require("fs").readFileSync("/dev/stdin","utf8"));
function xArray(v){var a=arguments,l=a.length,r="Array(a["+--l+"]).fill(0).map(x=>{return "+v+";})";while(--l)r="Array(a["+l+"]).fill(0).map(x=>"+r+")";return eval(r);}

console.log(main());
function main(){
  var x = o.a();
  var dp = xArray(0,x+150);
  dp[0] = 1;
  var a = [100,101,102,103,104,105];
  for(var i = 0; i < x; i++){
    if(dp[i] === 0)continue;
    for(var j = 0; j < a.length; j++){
      dp[i+a[j]] = 1;
    }
  }
  return dp[x] ? 1 : 0;
}
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').trim().split('\n')
X = inp.shift() * 1
x = ~~(X / 100)
y = X % 100
f = 0
for (i=0; i<=y; i++) {
for (j=0; j<=y; j++) {
for (k=0; k<=y; k++) {
for (l=0; l<=y; l++) {
    m = y-(i*5+j*4+k*3+l*2)
    n = x-(i+j+k+l+m)
    if (m >= 0 && n>=0) {
        f = 1
        break;
    }
}
if (f) break;
}
if (f) break;
}
if (f) break;
}
console.log(f)
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
  input = input.split("\n");
  
  //スペース区切り　input[0] が tmp[0], tmp[1],...
	tmp = input[0].split(" ");
  
  //この時点では全部文字列（数値に変換しないといけない）

	//文字列から10進数に変換するときはparseIntを使います
	var a = parseInt(tmp[0], 10);
    var x = Math.floor(a/100);
    var y = a- (100*x);
    if(5*x >= y){
      console.log('%d', 1);
    }else{
      console.log('%d', 0);
    }
}

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

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

var sc = bufio.NewScanner(os.Stdin)

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

func main() {
	sc.Split(bufio.ScanWords)
	x := nextInt()
	a := make([]int, 6000)

	for i := 0; i < 6; i++ {
		for j := 0; j < 1000; j++ {
			index := i*1000 + j
			a[index] = (100 + i) * (j + 1)
		}
	}
	sort.Ints(a)

	dp := make([][]bool, 6010)
	for i := 0; i < 6010; i++ {
		dp[i] = make([]bool, 100010)
	}
	dp[0][0] = true

	for i := 0; i < 6000; i++ {
		for j := 0; j <= x; j++ {
			if j >= a[i] {
				dp[i+1][j] = dp[i][j] || dp[i][j-a[i]]
			} else {
				dp[i+1][j] = dp[i][j]
			}
		}
	}
	if dp[6000][x] {
		fmt.Println(1)
	} else {
		fmt.Println(0)
	}
}
//  [go]
package main

import "fmt"

func main() {
        var x int
        fmt.Scanf("%d", &x)

        fraction := x % 100
        if fraction == 0 {
                fmt.Println("1")
                return
        }
        num := x / 100

        for one := 0; one < 100; one++ {
                for two := 0; two < 50; two++ {
                        for three := 0; three < 34; three++ {
                                for four := 0; four < 25; four++ {
                                        for five := 0; five < 20; five++ {
                                                if fractionCount(one, two, three, four, five) == fraction && one+two+three+four+five <= num {
                                                        fmt.Println("1")
                                                        return
                                                }
                                        }
                                }
                        }
                }
        }
        fmt.Println("0")
}

func fractionCount(one, two, three, four, five int) int {
        return one + two*2 + three*3 + four*4 + five*5
}
//  [ruby]
price = [*100..105]
dp = [[*100..105]]
n = gets.to_i
if price.include? n
  p 1
  exit
end
(1..1000).each do |k|
  dp[k] = []
  price.each do |p|
    dp[k-1].each do |d|
      if d+p == n
        p 1
        exit
      end
      dp[k] << d+p
    end
  end
  dp[k].uniq!
end
p 0
//  [ruby]
lines = $stdin.read
array = lines.split("\n")
X = array[0].to_i

COINS = [100, 101, 102, 103, 104, 105]

def coin(amount,kind,coins)

  coins = [0].concat(coins)
  dp = Array.new(kind+1).map{Array.new(10**5+1, 0)}
  dp.each{|row| row[0] = 1}

  for i in 1..kind
    for j in 1..amount
      dp[i][j] = dp[i][j - coins[i]] + dp[i-1][j]
    end
  end
  dp
end


dp = coin(X,COINS.length,COINS)
if dp[COINS.length][X] > 0
  puts 1
else
  puts 0
end
//  [ruby]
class Shopping
  def initialize(x)
    @x = x
    @dp = Array.new(x + 1, 0)
    @dp[0] = 1
  end

  def solve
    (100 .. 105).each do |i|
      (0 .. @x).each do |j|
        if @dp[j] == 1 && i + j <= @x
          @dp[i + j] = 1
        end
      end
    end
    @dp[@x]
  end
end

def run
  x = gets.chomp.to_i
  puts Shopping.new(x).solve
end

run
//  [rust]
#![allow(unused_macros)]
#![allow(dead_code)]
#![allow(unused_imports)]

use itertools::Itertools;
use text_io::*;

const U_INF: usize = 1 << 60;
const I_INF: isize = 1 << 60;

fn main() {
    let x: usize = read!();
    let m = f(x % 100);

    let ans = if m * 100 <= x { 1 } else { 0 };
    println!("{}", ans);
}

fn f(n: usize) -> usize {
    if n > 5 {
        f(n - 5) + 1
    } else {
        1
    }
}
//  [rust]
use whiteread::parse_line;

fn calc(n: usize, dp: &mut Vec<bool>, price: &[usize; 6]) -> bool {
    if !dp[n] && n > 105 {
        dp[n] |= match n % 5 {
            x @ 1..=4 => calc(n - price[x], dp, price),
            _ => calc(n - price[0], dp, price) | calc(n - price[5], 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");
    }
}
//  [typescript]
{
  const main = (input: string) => {
    const r = reader(input)
    const X = r.n()
    const a: { [n: number]: boolean } = { 0: true }
    for (let i = 0; i < X; i++) {
      if (!a[i]) {
        continue
      }
      a[i + 100] = true
      a[i + 101] = true
      a[i + 102] = true
      a[i + 103] = true
      a[i + 104] = true
      a[i + 105] = true
    }
    console.log(a[X] ? 1 : 0)
  }

  // const values = obj => Object.keys(obj).map(e => obj[e]);

  const reader = (str: string) => {
    const lines = str.trim().split('\n')
    const s = () => lines.shift() || ''
    const line = s
    const n = () => Number(s())

    const ss = () => s().split(' ')
    const ns = () => ss().map(Number)
    return { lines, line, s, n, ss, ns }
  }

  const getInput = () => require('fs').readFileSync('/dev/stdin', 'utf8')
  main(getInput())
}
//  [python]
#
import sys
import math
import numpy as np
import itertools
# ひとつ入力
k = int(input())

print( (k//2) * ((k+1)//2) )
//  [python]
import numpy


K = int(input())

cnt = 0
for i in range(1, K):
    for j in range(i+1, K+1):
        if (i % 2 == 0 and j % 2 != 0) or (i % 2 != 0 and j % 2 == 0):
            cnt += 1
print(cnt)
//  [python]
N = int(input())
print((N // 2) * ((N + 1) // 2))
//  [java]
import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args)  {
        Scanner sc = new Scanner(System.in);
        int k = sc.nextInt();
        System.out.println((k / 2) * ((k + 1) / 2));
    }


}
//  [java]
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main{
    public static String process(int K) {
        final int sum = IntStream.range(1, K + 1)
                .map(i -> ((K - i) + 1) / 2)
                .sum();

        return String.valueOf(sum);
    }

    // Util Func

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int K = sc.nextInt();

        // process
        final String result = process(K);

        // output
        System.out.println(result);
    }
}