#nullable enable

using System.Numerics;

void Run()
{
    var c1 = new HashSet<string>{ "gray","brown","green","cyan","blue","yellow","orange","red" };
    var c2 = new HashSet<string>{ "gray","green","blue","yellow","red" };
    var c3 = new HashSet<string>{ "gray","green","cyan","blue","violet","orange","red" };

    var s = 3.Repeat(String);
    var p = new List<int>{ 0, 1, 2 };
    var ans = new HashSet<string>();
    while (p != null)
    {
        var s1 = s[p[0]];
        var s2 = s[p[1]];
        var s3 = s[p[2]];
        if (c1.Contains(s1) && c2.Contains(s2) && c3.Contains(s3))
        {
            ans.Add(s1 + " " + s2 + " " + s3);
        }
        p = p.NextPermutation();
    }
    Out(ans.Count == 1 ? "Yes" : "No");
}

#region
var _io_ = new AtCoderIO(){ Backend = new() };
Run();
_io_.Backend.Flush();

string String() => _io_.Next();
int Int() => int.Parse(String());
void Out(object? x, string? sep = null) => _io_.Out(x, sep);

class AtCoderIO
{
    public required StandardIOBackend Backend { get; init; }

    ReadOnlyMemory<string> _input = Array.Empty<string>();
    int _iter = 0;
    public string Next()
    {
        while (_iter >= _input.Length) (_input, _iter) = (Backend.ReadLine().Split(' '), 0);
        return _input.Span[_iter++];
    }

    public void Out(object? x, string? separator = null)
    {
        if (x == null) return;
        separator ??= Environment.NewLine;
        if (x is System.Collections.IEnumerable a and not string)
        {
            var objects = a.Cast<object>();
            if (separator == Environment.NewLine && !objects.Any()) return;
            x = string.Join(separator, objects);
        }
        Backend.WriteLine(x);
    }
}

class StandardIOBackend
{
    readonly StreamReader _sr = new(Console.OpenStandardInput());
    readonly StreamWriter _sw = new(Console.OpenStandardOutput()) { AutoFlush = false };
    public string ReadLine() => _sr.ReadLine()!;
    public void WriteLine(object? value) => _sw.WriteLine(value);
    public void Flush() => _sw.Flush();
}
#endregion

static class Extensions
{
    public static T[] Repeat<T>(this int time, Func<T> F) => Enumerable.Range(0, time).Select(_ => F()).ToArray();

    public static List<T>? NextPermutation<T>(this IEnumerable<T> p) where T : IComparable<T>
    {
        var a = p.ToList();
        var b = new List<T> { a[^1] };
        for (var i = a.Count - 2; i >= 0; i--)
        {
            var t = a[i];
            if (t.CompareTo(b[^1]) >= 0) b.Add(t);
            else
            {
                var k = 0;
                while (k < b.Count && b[k].CompareTo(t) <= 0) k++;
                (b[k], a[i]) = (t, b[k]);
                for (var j = 0; j < b.Count; j++) a[i + 1 + j] = b[j];
                return a;
            }
        }
        return null;
    }

}