jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.util.*;
import java.io.*;

class Main{
    public static void main(String[] args){
        FastScanner fsc=new FastScanner();
        int a=fsc.nextInt();
        int b=fsc.nextInt();
        int c=fsc.nextInt();
        fsc.close();
        if(a==b && b==c){
            System.out.println(1);
        } else if(a==b || b==c || c==a){
            System.out.println(2);
        } else{
            System.out.println(3);
        }
    }
    static class FastScanner {
        private final InputStream in = System.in;
        private final byte[] buffer = new byte[1024];
        private int ptr = 0;
        private int buflen = 0;
        private boolean hasNextByte(){
            if(ptr<buflen) return true;
            else{
                ptr = 0;
                try{
                    buflen = in.read(buffer);
                }
                catch(IOException e){
                    e.printStackTrace();
                }
                if(buflen<=0) return false;
            }
        return true;
        }
        private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
        private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
        public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
        public String next() {
            if (!hasNext()) throw new NoSuchElementException();
            StringBuilder sb = new StringBuilder();
            int b = readByte();
            while(isPrintableChar(b)) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }
        public long nextLong() {
            if (!hasNext()) throw new NoSuchElementException();
            long n = 0;
            boolean minus = false;
            int b = readByte();
            if (b == '-') {
                minus = true;
                b = readByte();
            }
            if (b < '0' || '9' < b) throw new NumberFormatException();
            while(true){
                if ('0' <= b && b <= '9') {
                    n *= 10;
                    n += b - '0';
                }
                else if(b == -1 || !isPrintableChar(b)) return minus ? -n : n;
                else throw new NumberFormatException();
                b = readByte();
            }
        }
        public int nextInt() {
            long nl = nextLong();
            if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
            return (int) nl;
        }
        public double nextDouble() { return Double.parseDouble(next());}
        public void close(){
            try{in.close();}
            catch(IOException e){e.printStackTrace();}
        }
    }
}
//  [java]
import java.util.Scanner;
import java.util.stream.IntStream;

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

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

        System.out.println(solve(a, b, c));

        sc.close();
    }

    static int solve(int a, int b, int c) {
        return (int) IntStream.of(a, b, c).distinct().count();
    }
}
//  [java]
import java.util.Scanner;
import java.util.stream.IntStream;

public class Main{
	
	static final Scanner s=new Scanner(System.in);
	
	public static void main(String[] __){
		System.out.println(IntStream.of(s.nextInt(),s.nextInt(),s.nextInt()).distinct().count());
	}
}
//  [java]
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        List<Integer> list = new ArrayList<>();
        list.add(s.nextInt());
        list.add(s.nextInt());
        list.add(s.nextInt());
        List<Integer> result = list.stream().distinct().collect(Collectors.toList());

        System.out.println(result.size());
    }

}
//  [cpp]
#include<cstdio>

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

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

  if(a==b&& b==c)
    printf("1\n");
  else if(a==b||b==c||c==a)
    printf("2\n");
  else
    printf("3\n");

  return 0;
}
//  [cpp]
#include <stdio.h>

int main(){
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    int ans;
    if(a==b&&b==c){
        ans=1;
    }else if(a!=b&&b!=c&&c!=a){
        ans=3;
    }else{
        ans=2;
    }
    printf("%d\n",ans);
}
//  [cpp]
#include<cstdio>
using namespace std;
int main(){
  int a,b,c,cnt=1;
  scanf("%d %d %d",&a,&b,&c);
  if(a!=b)
    cnt++;
  if(a!=c&&b!=c)
    cnt++;
  printf("%d\n",cnt);
}
//  [cpp]
#include <iostream>
#include <set>

using namespace std;

int main() {
	int a, b, c;
	set<int> s;

	cin >> a >> b >> c;

	s.insert(a);
	s.insert(b);
	s.insert(c);

	cout << s.size() << endl;

	return 0;
}
//  [cpp]
#include<iostream>
using namespace std;
int main(){
	int a,b,c;
	cin>>a>>b>>c;
	int sum = 3;
	if(a == b)sum--;
	if(a == c)sum--;
	else if(b == c)sum--;
	cout << sum << endl;
	return 0;
}
//  [c]
#include <stdio.h>

int main(){
  int a,b,c,result=0;
  
  scanf("%d %d %d",&a,&b,&c);
  
  if(a!=b) result++;
  if(a!=c) result++;
  if(b!=c) result++;
  if(result==0) result++;
  
  printf("%d",result);
}
//  [c]
#include<stdio.h>
int main(){
  int a,b,c,min,mid,max;
  scanf("%d%d%d",&a,&b,&c);
  min=(a<b)?a:b;
  min=(min<c)?min:c;
  max=(a>b)?a:b;
  max=(max>c)?max:c;
  mid=a+b+c-min-max;
  if(min==mid&&mid==max){
    printf("1");
  }
  else if(min==mid||mid==max){
    printf("2");
  }
  else{
    printf("3");
  }
  return 0;
}
//  [c]
#include<stdio.h>
int main()
{
int a,b,c,i,count=0,j;
int arr[3];
scanf("%d%d%d",&a,&b,&c);
arr[0]=a;
arr[1]=b;
arr[2]=c;
for(i=0;i<3;i++)
    for(j=i+1;j<3;j++)
    if(arr[i]!=arr[j])
        count++;
        if(count==0)
            count=1;
        printf("%d",count);
    return 0;
}
//  [c]
#include <stdio.h>

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

  scanf("%d%d%d",&a,&b,&c);
  
  if(a==b&&a==c&&b==c){
    result=1;
  }
  else if((a==b&&a!=c)
        ||(a==c&&a!=b)
        ||(b==c&&b!=a)
        ||(b==a&&b!=c)
        ||(c==a&&c!=b)
        ||(c==b&&c!=a)){
    result=2;
  }
  else{
    result=3;
  }
  
  printf("%d\n",result);
  
  return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>

int main(void){

    int a, b, c;

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

    if(a == b && b == c){
        printf("1\n");
    }else if((a == b && a != c) || (b == c && c != a) || (c == a && a != b)){
        printf("2\n");
    }else{
        printf("3\n");
    }

    return 0;
}
//  [c]
#include <stdio.h>

int main()
{
	int a, b, c;
	scanf("%d %d %d", &a, &b, &c);
	if (a == b && b == c) printf("1\n");
	else if (a == b || b == c || c == a) printf("2\n");
	else printf("3\n");
	fflush(stdout);
	return 0;
}
//  [javascript]
'use strict';

const lines = require("fs").readFileSync("/dev/stdin", "utf8").trim().split(" ");
const a = lines[0];
const b = lines[1];
const c = lines[2];

if (a===b && b===c) {
  console.log(1);
}
if (a===b && b!==c) {
  console.log(2);
}
if (a===c && a!==b) {
  console.log(2);
}
if (b===c && a!==b) {
  console.log(2);
}
if (a!==b && b!==c && c!==a) {
  console.log(3);
}
//  [javascript]
'use strict'

const main = input => {
	const args = input.split('\n')[0].split(' ')
	let cnt = 1
	if (args[1] !== args[0]) cnt++
	if (args[2] !== args[1] && args[2] !== args[0]) cnt++
	console.log(cnt)
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function Main(input) {
  input = input.trim().split(" ");
  var data = input.map((n) => parseInt(n, 10));

  data = data.filter((v, i) => {
    return data.indexOf(v) === i;
  });
  console.log(data.length);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
const a = input.split(" ").map(Number);
  console.log(a[0]==a[1]&&a[0]==a[2]?"1"
			　:a[0]==a[1]&&a[1]!=a[2]?"2"
			  :a[0]==a[2]&&a[1]!=a[2]?"2"
			  :a[1]==a[2]&&a[0]!=a[2]?"2"
			  :"3");
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').split('\n')[0].split(' ')
o = {}
o[inp.shift()] = 1
o[inp.shift()] = 1
o[inp.shift()] = 1
console.log(Object.keys(o).length)
//  [javascript]
function Main(input) {
    var input = input.split("\n");
    var colors = input[0].split(" ");

    var filteredColors = colors.filter(
	function (x, i, self) {
	    return self.indexOf(x) === i;
	}
    );

    console.log(filteredColors.length);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import "fmt"

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

	xm := make(map[int]bool)
	xm[a] = true
	xm[b] = true
	xm[c] = true
	fmt.Println(len(xm))
}
//  [go]
package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)
	if a == b && b == c {
		fmt.Println(1)
	} else if a == b || b == c || a == c {
		fmt.Println(2)
	} else {
		fmt.Println(3)
	}
}
//  [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]++
  }
  fmt.Println(len(res))
}
//  [go]
package main

import "fmt"

func main() {
	// Code for A - AtCoDeer and Paint Cans
	var a, b, c int
	fmt.Scanf("%d %d %d", &a, &b, &c)

	if a == b && b == c {
		fmt.Println("1")
	} else if a != b && b != c && c != a {
		fmt.Println("3")
	} else {
		fmt.Println("2")
	}
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func intScanner() int {
	n, _ := strconv.Atoi(Scanner())
	return n
}

func floatScanner() float64 {
	n, _ := strconv.ParseFloat(Scanner(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func stringSliceScanner(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scanner()
	}
	return a
}
func intSliceScanner(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = intScanner()
	}
	return a
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}

var mod int = 1000000007

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	d := make(map[int]struct{})
	d[intScanner()] = struct{}{}
	d[intScanner()] = struct{}{}
	d[intScanner()] = struct{}{}
	fmt.Println(len(d))
}
//  [go]
package main

import "fmt"

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

	slice := []int{a, b, c}

	var count int

	if slice[0] != slice[1] {
		count++
	}
	if slice[0] != slice[2] {
		count++
	}
	if slice[1] != slice[2] {
		count++
	}
	if (slice[0] == slice[1]) && (slice[0] == slice[2]) && (slice[1] == slice[2]) {
		count++
	}
	fmt.Println(count)
}
//  [ruby]
puts gets.split.map(&:to_i).uniq.size
//  [ruby]
p gets.split.uniq.size
//  [ruby]
a = gets.split.map(&:to_i)
puts a.uniq.length
//  [ruby]
p gets.split.map(&:to_i).uniq.size
//  [ruby]
a, b, c = gets().chomp.split("\s")

puts [a, b, c].uniq.length
//  [ruby]
puts gets.chomp.split.map(&:to_i).uniq.size
//  [rust]
use std::cmp::*;
use std::io::*;
use std::num::*;
use std::str::*;
use std::collections::HashSet;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}
fn string() -> String {
    read()
}
fn int() -> i64 {
    read()
}
fn char() -> char {
    read::<String>().pop().unwrap()
}
fn vecchar() -> Vec<char> {
    string().chars().collect()
}
fn vecint(n: i64) -> Vec<i64> {
    let mut vec = Vec::new();
    for i in 0..n {
        vec.push(int())
    }
    vec
}

fn main() {
    let a = int();
    let b = int();
    let c = int();
    let mut set = HashSet::new();
    set.insert(a);
    set.insert(b);
    set.insert(c);
    println!("{}", set.len())
}
//  [rust]
use std::collections::HashSet;
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
    }
    let mut a: HashSet<usize> = vec![a, b, c].into_iter().collect();
    println!("{}", a.len())
}
//  [rust]
use std::io;
use std::collections::HashSet;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<i32> = procon_read();
	let mut set = HashSet::new();
	set.insert(v[0]);
	set.insert(v[1]);
	set.insert(v[2]);
	println!("{}", set.len());
}
//  [rust]
use proconio::fastout;
use whiteread::parse_line;

#[fastout]
fn main() {
    let (x, y, z): (usize, usize, usize) = parse_line().unwrap();
    if x == y && y == z {
        println!("1");
    } else if x == y || y == z || z == x {
        println!("2");
    } else {
        println!("3");
    }
}
//  [rust]
#![allow(non_snake_case)]
use proconio::input;
use std::collections::HashSet;

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

    let mut colors = HashSet::new();
    colors.insert(A);
    colors.insert(B);
    colors.insert(C);

    let ans = colors.len();
    println!("{}", ans);
}
//  [rust]
use proconio::{input, fastout};
use proconio::marker::{Chars};
use proconio::marker::Usize1;
use std::cmp::*;

macro_rules! debug {
      ($($a:expr),*) => {
          eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

#[fastout]
fn main() {
    input!{
        mut p: [usize;3],
    }

    p.sort();
    if p[0]==p[1] {
        if p[1]==p[2] {
            println!("1");
        } else {
            println!("2");
        }
    } else if p[1]==p[2] {
        println!("2");
    } else {
        println!("3");
    }

}
//  [swift]
var a=1,i=readLine()!.characters.split(" ").map{Int(String($0))!}.sort();if i[0]<i[1]{a++};if i[1]<i[2]{a++};print(a)
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ")
 
let a = Int(split[0])!
let b = Int(split[1])!
let c = Int(split[2])!

if (a==b && b==c){
    print("1")
}else if (a==b && b != c || a==c && c != b || b==c && a != c){
    print("2")
}else{
    print("3")
}
//  [typescript]
import * as fs from "fs";
 
let input = (fs.readFileSync("/dev/stdin", "utf8") as string).split("\n");
var cList = input[0].split(" ").map(x => parseInt(x));

var result = cList.filter(function (x, i, self) { 
    return self.indexOf(x) === i;
});


console.log(result.length);
//  [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,b,c]=nrin(3)
  out(a==b&&b==c?1:a==b||a==c||b==c?2:3)
}
main()
//  [typescript]
import * as fs from 'fs'
const reader = (s: string) => s.split(' ').map(t => parseInt(t, 10))

function Main(input: string) {
  const N = reader(input)
  const fil = N.filter((x, i, a) => a.indexOf(x) === i)

  console.log(fil.length)
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const colors = input[0].map(Number);

  return new Set(colors).size;
};

console.log(main(read()));
//  [typescript]
var input: string = require('fs').readFileSync('/dev/stdin', 'utf8');
var inputLines: string[] = input.trim().split("\n");
var parts = inputLines[0].split(" ");

var A = parseInt(parts[0]);
var B = parseInt(parts[1]);
var C = parseInt(parts[2]);
var cans = new Set();
cans.add(A);
cans.add(B);
cans.add(C);
console.log(cans.size);
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const arr = stdin
  .split('\n')[0]
  .split(' ')
  .map(Number)

const res = _ => {
  const len = arr.filter((e, i)=>arr.indexOf(e)===i).length
  return len
}

console.log(res())
//  [python]
import numpy as np
C=np.zeros((3,3),dtype=str)
for i in range(3):
  a=list(map(str,input()))
  C[i][0]=a[0]
  C[i][1]=a[1]
  C[i][2]=a[2]
print(C[0][0]+C[1][1]+C[2][2])
//  [python]
a = [raw_input() for _ in range(3)]
print ''.join([a[i][i] for i in range(3)])
//  [java]
import java.util.Scanner;

class Main {

    private static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        System.out.println(String.valueOf(sc.next().charAt(0)) + String.valueOf(sc.next().charAt(1)) + String
                .valueOf(sc.next().charAt(2)));
    }
}
//  [java]
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

	/** 行数 */
	private static final int N = 3;

	public static void main(String[] args) {
		try (Scanner scanner = new Scanner(System.in)) {
			System.out.println(IntStream.range(0, N).mapToObj(i -> scanner.next().substring(i, i + 1))
					.collect(Collectors.joining()));
		}
	}
}
//  [java]
import java.util.Scanner;
import java.util.stream.IntStream;

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

        IntStream.range(0,3)
                .mapToObj(i->scanner.next().toCharArray()[i])
                .forEach(System.out::print);
        System.out.println();
        scanner.close();
    }
}
//  [cpp]
#include<bits/stdc++.h>
typedef long long ll;
using namespace std;

char a[5][5];

int main()
{
	for(int i = 1; i <= 3; i++)
		for(int j = 1; j <= 3; j++){
			cin >> a[i][j];
		}
		cout << a[1][1] << a[2][2] << a[3][3] << endl;
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
typedef long long int lld;
typedef vector<lld> vi;
typedef pair<lld,lld> pi;
#define F first
#define S second
#define MOD 1000000007
#define PB push_back
#define MP make_pair
#define rep(i,a,b) for (lld i = a; i < b; i++)
lld a,c,r,j,l,x,y,m,b,n,s,f,q,i,z,p,k,d,t,u,e,g;string s1,s2,s3,s4;
vi v[10000001];
int main()
{
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cin>>s1>>s2>>s3;
  cout<<s1[0]<<s2[1]<<s3[2];
}
//  [cpp]
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
#define int ll
#define double long double
#define YES {cout<<"YES"<<'\n';}
#define NO {cout<<"NO"<<'\n';}
#define Yes {cout<<"Yes"<<'\n';}
#define No {cout<<"No"<<'\n';}
#define yes {cout<<"yes"<<'\n';}
#define no {cout<<"no"<<'\n';}
void YN(bool flg){cout<<(flg?"YES":"NO")<<'\n';}
void Yn(bool flg){cout<<(flg?"Yes":"No")<<'\n';}
void yn(bool flg){cout<<(flg?"yes":"no")<<'\n';}
#define SORT(a) sort(a.begin(),a.end())
#define REVERSE(a) reverse(a.begin(),a.end())
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define out(n) {cout << n << '\n';}
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<VI> VVI;
const int MOD = 1000000007;
const long long INF = 10e10;
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<class T>auto MAX(const T& a) { return *max_element(a.begin(),a.end()); }
template<class T>auto MIN(const T& a) { return *min_element(a.begin(),a.end()); }
int ABS(int a) {if(a<0) a = -a; return a;}
template<class T, class U>U SUM(const T& a, const U& v) { return accumulate(a.begin(),a.end(), v); }
template<class T, class U>U COUNT(const T& a, const U& v) { return count(a.begin(),a.end(), v); }
template<class T, class U>int LOWER(const T& a, const U& v) { return lower_bound(a.begin(),a.end(), v) - a.begin(); }
template<class T, class U>int UPPER(const T& a, const U& v) { return upper_bound(a.begin(),a.end(), v) - a.begin(); }
int GCD(int a, int b) { return b ? GCD(b, a%b) : a; }
int LCM(int a, int b) { int g = GCD(a, b); return a / g * b; }
int POW(int a, int n) { int r = 1; while (n > 0) { if (n & 1)r *= a; a *= a; n /= 2; }return r; }
int isPrime(int n){if(n<2){return 0;}for(int i=2; i*i<=n; i++){if(n%i==0){return 0;}}return 1;}
/*素因数分解*/map< int, int >prime_factor(int n){map< int, int > ret;for(int i = 2; i * i <= n; i++) {while(n % i == 0) {ret[i]++;n /= i;}}if(n != 1) ret[n] = 1;return ret;}
/*約数の個数*/int divisor_number(int n){auto p = prime_factor(n); int res = 1; for(auto x:p)res*=(x.second+1); return res;}
/*約数列挙*/vector<int> divisor(int n){vector<int> v; for(int i=1; i*i<=n; i++){if(n%i==0){v.push_back(i);if(i!=n/i){v.push_back(n/i);}}}sort(v.begin(),v.end()); return v;}
//----------------ライブラリとか----------------

signed main(){
    cin.tie(0);
    ios::sync_with_stdio(0);
    cout<<fixed<<setprecision(15);

    string a,b,c; cin >> a >> b >> c;
    cout << a[0] << b[1] << c[2] << endl;

    return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

#define rep(i, n) for(int i=0; i<(n); ++i)
#define max  200001

//qsort(str, n, sizeof(int), up_comp);
int up_comp(const void *a, const void *b){return *(int*)a - *(int*)b;}
int down_comp(const void *a, const void *b){return *(int*)b - *(int*)a;}
int int_sort( const void * a , const void * b ) {return strcmp(( char * )a , ( char * )b );}
int count_digit(int a){int i=0;while(a!=0){a=a/10;i++;}return i;}
int euclid( int a, int b ){int temp;if(a<b){temp=a;a=b;b=temp;}if(b<1)return -1;if(a%b==0) return b;return euclid(b,a%b);}

int main(void){
 
    char c[6][6];
    
    rep(i, 3){
        scanf("%s", c[i]);
    }
    
    printf("%c%c%c", c[0][0], c[1][1], c[2][2]);
    
    return 0;
}
//  [c]
#include<stdio.h>

typedef struct {
	char m_aLetter[4];
}Squares;

int main(void) {
	int i;
	//構造体変数の定義
	Squares astSquares[3];

	//変数にアルファベットを入力
	scanf("%c    %c %c", &astSquares[0].m_aLetter[0], &astSquares[0].m_aLetter[1], &astSquares[0].m_aLetter[2]);
	scanf("%*c%c %c %c", &astSquares[1].m_aLetter[0], &astSquares[1].m_aLetter[1], &astSquares[1].m_aLetter[2]);
	scanf("%*c%c %c %c", &astSquares[2].m_aLetter[0], &astSquares[2].m_aLetter[1], &astSquares[2].m_aLetter[2]);

	printf("\n");
	//並んだアルファベットの中で左上、中央、右下の3つを順番に表示
	for (i = 0; i < 3; i++) {
		printf("%c",astSquares[i].m_aLetter[i]);
	}
	printf("\n");

	return 0;
}
//  [c]
#include <stdio.h>
 
int main() {
	
	int i,j;
	char Masu[4][4];
	
	for( i=0; i<3; i++ ){
		for( j=0; j<3; j++ ){
			if( i != 0 && j == 0 ){
				scanf("%*c%c", &Masu[i][j]);
			} else {
				scanf("%c", &Masu[i][j]);
			}
		}
	}
	printf( "%c%c%c\n", Masu[0][0],Masu[1][1],Masu[2][2] );
	return 0;
}
//  [javascript]
function Main(input) {
	input = input.split("\n");
	
	console.log("%s%s%s", input[0][0], input[1][1], input[2][2]);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
    var input = input.split('\n');
    var iti = input[0].split('');
    var ni = input[1].split('');
    var san = input[2].split('');
    console.log(iti[0] + ni[1] + san[2]);

    }
Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
let [a, b, c] = require("fs").readFileSync("/dev/stdin", "utf8").split("\n");
console.log(a[0] + b[1] + c[2]);
//  [go]
package main

import "fmt"

func main() {
	var s [3]string

	fmt.Scan(&s[0], &s[1], &s[2])

	ans := string(s[0][0]) + string(s[1][1]) + string(s[2][2])

	fmt.Println(string(ans))

}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var c1, c2, c3 string
  fmt.Scanf("%s", &c1)
  fmt.Scanf("%s", &c2)
  fmt.Scanf("%s", &c3)
  
  fmt.Printf("%s\n", c1[0:1] + c2[1:2] + c3[2:3])
}
//  [go]
package main

import "fmt"

func main() {
	// Code for A - Diagonal String
	S := make([]string, 3)
	fmt.Scanf("%s", &S[0])
	fmt.Scanf("%s", &S[1])
	fmt.Scanf("%s", &S[2])

	fmt.Printf("%c%c%c\n", S[0][0], S[1][1], S[2][2])
}
//  [ruby]
require 'prime'
require 'set'
require 'tsort'
include Math
ALP = ('a'..'z').to_a
INF = 0xffffffffffffffff
def max(a,b);              a > b ? a : b                              end
def min(a,b);              a < b ?  a : b                             end
def swap(a,b);             a, b = b, a                                end
def gif;                   gets.to_i                                  end
def gff;                   gets.to_f                                  end
def gsf;                   gets.chomp                                 end
def gi;                    gets.split.map(&:to_i)                     end
def gf;                    gets.split.map(&:to_f)                     end
def gs;                    gets.chomp.split.map(&:to_s)               end
def gc;                    gets.chomp.split('')                       end
def pr(num);               num.prime_division                         end
def pr?(num);              Prime.prime?(num)                          end
def digit(num);            num.to_s.length                            end
def array(s,ini=nil);      Array.new(s){ini}                          end
def darray(s1,s2,ini=nil); Array.new(s1){Array.new(s2){ini}}          end
def rep(num);              num.times{|i|yield(i)}                     end
def repl(st,en,n=1);       st.step(en,n){|i|yield(i)}                 end

puts gc[0]+gc[1]+gc[2]
//  [ruby]
a=`dd`.split*"";puts a[0]+a[4]+a[8]
//  [ruby]
a=`dd`;puts a[0]+a[5]+a[10]
//  [rust]
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::{Bytes, Chars};
#[allow(unused_imports)]
use std::cmp::{min, max};

fn main() {
	input! {
		cs1: Chars,
		cs2: Chars,
		cs3: Chars,
	}

	println!("{}{}{}", cs1[0], cs2[1], cs3[2]);
}
//  [rust]
use std::io;
use std::str::FromStr;

fn input_char_vec() -> Vec<char> {
    let mut line: String = String::new();
    io::stdin().read_line(&mut line);
    line.trim().chars().collect()
}

fn main() {
    for i in 0..3 {
        let s = input_char_vec();
        print!("{}", s[i]);
    }
    println!();
}
//  [typescript]
import * as fs from "fs";
const input = (fs.readFileSync("/dev/stdin", "utf8") as string).split(/\n/);
console.log(input[0].charAt(0) + input[1].charAt(1) + input[2].charAt(2));
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const field = input.slice(0, -1).map((line) => line[0]);

  let answer: string[] = [];

  field.forEach((row, index) => {
    answer.push(row[index]);
  });

  return answer.join("");
};

console.log(main(read()));
//  [typescript]
var lines: string[] = [];
var reader: any = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});
reader.on("line", function(line: string) {
  lines.push(line);
});

reader.on("close", function() {

  console.log(lines[0][0] + lines[1][1] + lines[2][2]);
});
//  [python]
import math
import calendar
import fractions
import itertools

n = input()

if n == n[::-1]:
    print("Yes")
else:
    print("No")
//  [python]
# region header
import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**7)
rs = lambda: sys.stdin.readline().rstrip()
ri = lambda: int(rs())
rf = lambda: float(rs())
rs_ = lambda: [_ for _ in rs().split()]
ri_ = lambda: [int(_) for _ in rs().split()]
rf_ = lambda: [float(_) for _ in rs().split()]
INF = float('inf')
MOD = 10 ** 9 + 7
# endregion
N = rs()
print('Yes' if N == N[::-1] else 'No')
//  [python]
import sys
import math
from fractions import gcd
# import queue
# from collections import Counter
# from itertools import accumulate
# from functools import reduce

def lcm(a, b):
    return a * b // gcd(a, b)

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

big_prime = 1000000007

"""
# 標準入力取得
## 文字列
 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())

## 数値
 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]
"""


N = sys.stdin.readline().rstrip()

if N[0] == N[2]:
    print("Yes")
else:
    print("No")
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskC {

		public void solve(int testNumber, InputReader in, PrintWriter out) {
			int n = in.nextInt();
			int a = n % 10;
			int b = n / 100;
			if(a==b){
				out.println("Yes");
			}else{
				out.println("No");
					
			}
		}

	}

	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

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

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

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

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

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

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String n[] = sc.next().split("");
		System.out.println((n[0].equals(n[2]))? "Yes" : "No");
	}
}
//  [java]

import java.util.Scanner;

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

    Scanner sc = new Scanner(System.in);
// splitで文字列を分ける。("")まで必要
//splitを使うために文字列型にする
    String[] N = sc.next().split("");
//０から数えて何個目にあるかを指定する
//文字列は＝＝じゃなく.equals()
      if (N[0].equals(N[2])){
      System.out.println("Yes") ;
      }
      else {
      System.out.println("No") ;
      }
  }
}
//  [cpp]
#include<iostream>
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <iomanip>//setprecision
#include<math.h>
#include <functional>
#include<climits>
using namespace std;
#define ll  long long 
#define rep(i, n)        for(ll i=0; i<(ll)(n); ++i)
#define mod 1000000007
  vector<ll>to[1000005];
   ll dp[2000000];
 int gcd(int a, int b)
{
  if (a%b == 0)
{
return(b);
}
else
{
return(gcd(b,a%b));
}
}
  vector<vector<bool>>d(5001,vector<bool>(5001));
int main(){
  string a;cin>>a;
  if(a[0]==a[2])cout<<"Yes";
  else cout<<"No";
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
 
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
 
template<class T, class C> void chmax(T& a, C b){ a>b?:a=b; }
template<class T, class C> void chmin(T& a, C b){ a<b?:a=b; }
 
const int mod=1e9+7;
 
struct mint {
  ll x;
  mint(ll x=0):x(x%mod){}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
};
 
mint c[4005][4005];
void init() {
  c[0][0] = 1;
  for (int i = 0; i <= 4000; i++) {
    for (int j = 0; j <= i; j++) {
      c[i+1][j] += c[i][j];
      c[i+1][j+1] += c[i][j];
    }
  }
}
mint comb(int n, int k) {
  return c[n][k];
}
 
bool IsPrime(int num)
{
    if (num < 2) return false;
    else if (num == 2) return true;
    else if (num % 2 == 0) return false;
 
    double sqrtNum = sqrt(num);
    for (int i = 3; i <= sqrtNum; i += 2)
    {
        if (num % i == 0)
        {
            return false;
        }
    }
 
    return true;
}
 
map<ll, ll> primeFact(ll n) {
  map<ll, ll> res;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      res[i]++;
      n /= i;
    }
  }
  if (n != 1) res[n]++;
  return res;
}
 
void printv(vi& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
void printv(vll& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
int vtotal(vi& v){
  int total=0;
  rep(i,v.size()) total+=v[i];
  return total;
}
 
int main()
{
  //init(); // mint初期化
  cin.tie( 0 );
  ios::sync_with_stdio( false );
  
  string n;cin>>n;
  string ans="No";
  if(n[0]==n[2])ans="Yes";
  cout(ans);
  
  return 0;
}
//  [c]
#include <stdio.h>
int main(){
  char s[4]={0};
  scanf("%s",s);
  if(s[0]==s[2]){ printf("Yes\n"); }
  else			{ printf("No\n"); }
  return 0;
}
//  [c]
#include<stdio.h>

int main(void){
    char num[4];
    scanf("%s",num);
    puts(num[0] == num[2] ? "Yes" : "No");
}
//  [c]
#include<stdio.h>
int main(){
  char s[4];
  scanf("%s",s);
  printf(s[0]==s[2]?"Yes":"No");
}
//  [javascript]
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);
});

function Main(input) {
    input = input.split(/\r?\n/);
    var n = input[0];
    if (n[0] == n[2]) {
        console.log('Yes');
    }
    else {
        console.log('No');
    }
}
//  [javascript]
function main(s) {
	s = s.split("\n")[0]
	console.log(s[0]===s[2]?"Yes":"No");
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input){
    var N = Number(input);
    if(Math.floor(N/100)==N%10){
        console.log("Yes");
    }else{
        console.log("No");
    }
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

func main(){
	r := bufio.NewReader(os.Stdin)
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()

	var S string
	fmt.Fscan(r, &S)
	N := len(S)
	ans := "Yes"
	for i:=0; i < N; i++{
		if(S[i] != S[N-i-1]){
			ans = "No"
		}
	}
	fmt.Println(ans)


}
//  [ruby]
N=gets.chomp
if N[0] == N[2]
    puts "Yes"
else
    puts "No"
end
//  [ruby]
n = gets.chomp
puts n.reverse == n ? :Yes: :No
//  [ruby]
s=gets.chomp
puts s.reverse==s ? "Yes" : "No"
//  [rust]
use std::io::*;
use std::str::FromStr;

#[allow(dead_code)]
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let s = read::<String>().chars().collect::<Vec<char>>();
    println!(
        "{}",
        if s[0] == *s.last().unwrap() {
            "Yes"
        } else {
            "No"
        }
    );
}
//  [rust]
#[allow(unused_macros)]
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" ) } ; }
#[allow(unused_macros)]
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 ) * } } ; }
#[allow(unused_macros)]
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 ) * } } ; }

fn main() {
    input! {
        n: String,
    }
    if n == n.chars().rev().collect::<String>() {
        println!("Yes");
    } else {
        println!("No");
    }
}
//  [rust]
#![allow(non_snake_case)]
use proconio::input;
// use std::collections::HashMap;
// use std::cmp::max;
// use std::cmp::min;


fn main() {
    input! {
        N: i64,
    }

    let a = N / 100;
    // let b = N / 10;
    let c = N % 10;
    let ans = if a == c { "Yes" } else { "No" };
    println!("{}", ans);
}
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const N = input[0][0];

  return N === N.split("").reverse().join("") ? "Yes" : "No";
};

console.log(main(read()));
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const N = input[0][0];

  return N[0] === N[2] ? "Yes" : "No";
};

console.log(main(read()));
//  [typescript]
import * as fs from 'fs';
const args : string = fs.readFileSync('/dev/stdin','utf8').trim();
if (args[0] === args[2]) {
    console.log('Yes');
} else {
    console.log('No');
}
//  [python]
#
# 　　  ⋀_⋀　 
#　　  (･ω･)  
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│ 
#  │＊　祈　＊│ 
#  │＊　願　＊│ 
#  │＊　　　＊│ 
#      ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    S=ST()
    if("7" in S):
        print("Yes")
    else:
        print("No")
if __name__ == '__main__':
    main()
//  [python]
from __future__ import print_function

import sys

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction
from fractions import gcd
# fractions.gcd() を用いること
# math.log2()はatcoderでは対応していない．留意せよ．

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


def lcm(n, m):
    return int(n * m / gcd(n, m))


def coprimize(p, q):
    common = fractions.gcd(p, q)
    return (p // common, q // common)


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def find_gcd(list_l):
    x = reduce(gcd, list_l)
    return x


def main():
    S = input().strip()
    ans="No"
    for i in range(len(S)):
        if S[i]=='7':
            ans="Yes"
    print(ans)

if __name__ == '__main__':
    main()
//  [java]
import java.util.*;

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

    for ( int i = 0; i < buf.length; i++ ) {
      buf[i] = num % 10;
      num /= 10;
    }
    for ( int b : buf ) {
      if ( b == 7 ) {
        System.out.println("Yes");
        System.exit(0);
      }
    }
    System.out.println("No");
  }
}
//  [java]
import java.util.*;

public class Main {

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

	public void run() {
		Scanner sc = new Scanner(System.in);
		String n = sc.next();
		boolean f = false;
		for(int i=0; i<n.length(); i++) {
			if(n.charAt(i) == '7') {
				f=true;
			}
		}
		if(f) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}
		sc.close();
	}


}
//  [java]
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		String nn = String.valueOf(n);
		for (int i = 0; i < nn.length(); i++) {
			if (nn.charAt(i) == '7') {
				System.out.println("Yes");
				return;
			}
		}
		System.out.println("No");
	}

}