// -*- coding:utf-8-unix -*-
// #![feature(map_first_last)]
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_macros)]

use std::cmp::*;
use std::collections::*;
use std::fmt::*;
use std::hash::*;
use std::io::BufRead;
use std::iter::FromIterator;
use std::*;

const INF: i64 = 1223372036854775807;
const UINF: usize = INF as usize;
const LINF: i64 = 2147483647;
const INF128: i128 = 1223372036854775807000000000000;
const MOD1: i64 = 1000000007;
const MOD9: i64 = 998244353;
const MOD: i64 = MOD9;
const UMOD: usize = MOD as usize;
const M_PI: f64 = 3.14159265358979323846;

macro_rules! p {
    ($x:expr) => {
        //if expr
        println!("{}", $x);
    };
}

macro_rules! vp {
    // vector print separate with space
    ($x:expr) => {
        println!(
            "{}",
            $x.iter()
                .map(|x| x.to_string())
                .collect::<Vec<_>>()
                .join(" ")
        );
    };
}

macro_rules! d {
    ($x:expr) => {
        eprintln!("{:?}", $x);
    };
}
macro_rules! yn {
    ($val:expr) => {
        if $val {
            println!("Yes");
        } else {
            println!("No");
        }
    };
}

macro_rules! map{
    // declear btreemap
    ($($key:expr => $val:expr),*) => {
        {
            let mut map = ::std::collections::BTreeMap::new();
            $(
                map.insert($key, $val);
            )*
            map
        }
    };
}

macro_rules! set{
    // declear btreemap
    ($($key:expr),*) => {
        {
            let mut set = ::std::collections::BTreeSet::new();
            $(
                set.insert($key);
            )*
            set
        }
    };
}

//input output
#[allow(dead_code)]
fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

#[allow(dead_code)]
fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

#[allow(dead_code)]
fn read_mat<T: std::str::FromStr>(n: u32) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}

#[allow(dead_code)]
fn readii() -> (i64, i64) {
    let mut vec: Vec<i64> = read_vec();
    (vec[0], vec[1])
}

#[allow(dead_code)]
fn readiii() -> (i64, i64, i64) {
    let mut vec: Vec<i64> = read_vec();
    (vec[0], vec[1], vec[2])
}
#[allow(dead_code)]
fn readuu() -> (usize, usize) {
    let mut vec: Vec<usize> = read_vec();
    (vec[0], vec[1])
}

fn readuuu() -> (usize, usize, usize) {
    let mut vec: Vec<usize> = read_vec();
    (vec[0], vec[1], vec[2])
}

// slice_permutations: returns all permutations of a slice of length 3
fn slice_permutations<T: Clone>(slice: &[T]) -> Vec<Vec<T>> {
    let n = slice.len();
    let mut res = Vec::new();
    if n == 3 {
        for &i in &[0, 1, 2] {
            for &j in &[0, 1, 2] {
                if j == i {
                    continue;
                }
                for &k in &[0, 1, 2] {
                    if k == i || k == j {
                        continue;
                    }
                    res.push(vec![slice[i].clone(), slice[j].clone(), slice[k].clone()]);
                }
            }
        }
    }
    res
}

fn main() {
    let colors: Vec<String> = read_vec();
    let one = vec![
        "gray", "brown", "green", "cyan", "blue", "yellow", "orange", "red",
    ];
    let two = vec!["gray", "green", "blue", "yellow", "red"];
    let three = vec!["gray", "green", "cyan", "blue", "violet", "orange", "red"];
    let sites = vec![&one, &two, &three];
    let f_same_color = colors.iter().all(|c| c == &colors[0]);
    let mut cnt = 0;
    let cp = colors;
    let perm = slice_permutations(&sites);
    // d!(perm.clone());
    for sp in perm {
        let mut ok = true;
        for i in 0..3 {
            if !sp[i].contains(&cp[i].as_str()) {
                ok = false;
                break;
            }
        }
        // d!((ok, cp.clone()));
        if ok {
            cnt += 1;
        }
    }
    // let f_same_color = colors.clone().iter().all(|c| c == &colors[0]);
    println!(
        "{}",
        if cnt == 1 || (cnt == 6 && f_same_color) {
            "Yes"
        } else {
            "No"
        }
    );
}