Language: C++

using System;
using System.Collections.Generic;
using System.Diagnostics.Tracing;
using System.Linq;
using System.Net.NetworkInformation;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using Extensions;
using static System.Math;
using static Extensions.MathExtension;
using static Extensions.ConsoleInputExtension;
using static Extensions.ConsoleOutputExtension;

class Solver
{
    public void Solve()
    {
        //Solve Code Here
        int a = Cin, b = Cin, c = Cin;
        if (a == b && b == c)
        {
            Coutln("No");
            return;
        }

        if (a != b && b != c && c != a)
        {
            Coutln("No");
            return;
        }

        Coutln("Yes");
    }

    //Other Functions Here
}

//Other Classes Here

#if !DEBUG
class EntryPoint
{
    static void Main(string[] args)
    {
        new Solver().Solve();
        Flush();
    }
}
#endif

class PriorityQueue<T>
{
    private readonly List<Tuple<int, T>> _list = new List<Tuple<int, T>>();

    public int Count => _list.Count;

    public PriorityQueue()
    {
    }

    public void Push(T item, int priority)
    {
        _list.Add(Tuple.Create(priority, item));

        int itemIndex = Count - 1, parentIndex;
        while ((parentIndex = GetParentIndex(itemIndex)) != -1 &&
               priority > _list[parentIndex].Item1)
        {
            Swap(itemIndex, parentIndex);
            itemIndex = parentIndex;
        }
    }

    private int GetParentIndex(int index)
    {
        if (index == 0) return -1;
        return ((index + 1) >> 1) - 1;
    }

    private Tuple<int, int> GetChildrenIndex(int index)
    {
        var item2 = (index + 1) << 1;
        var item1 = item2 - 1;
        return Tuple.Create(item1, item2);
    }

    public T Pop()
    {
        if (Count <= 0) throw new IndexOutOfRangeException();
        var item = _list[0].Item2;
        _list[0] = _list[Count - 1];
        _list.RemoveAt(Count - 1);

        int index = 0;
        Tuple<int, int> childrenIndex = GetChildrenIndex(index);
        while (childrenIndex.Item1 < Count || childrenIndex.Item2 < Count)
        {
            if (childrenIndex.Item2 >= Count || _list[childrenIndex.Item1].Item1 > _list[childrenIndex.Item2].Item1)
            {
                if (_list[childrenIndex.Item1].Item1 <= _list[index].Item1) return item;

                Swap(index, childrenIndex.Item1);
                index = childrenIndex.Item1;
            }
            else
            {
                if (_list[childrenIndex.Item2].Item1 <= _list[index].Item1) return item;
                Swap(index, childrenIndex.Item2);
                index = childrenIndex.Item2;
            }

            childrenIndex = GetChildrenIndex(index);
        }

        return item;
    }

    public T Peek()
    {
        return _list[0].Item2;
    }

    private void Swap(int index1, int index2)
    {
        var tmp = _list[index1];
        _list[index1] = _list[index2];
        _list[index2] = tmp;
    }
}

struct Rational
{
    private long _numerator;
    private long _denominator;
    public long Numerator => _numerator;
    public long Denominator => _denominator;

    public Rational(long numerator, long denominator)
    {
        var gcd = GCD(numerator, denominator);
        _numerator = numerator / gcd;
        _denominator = denominator / gcd;
    }

    public static Rational operator +(Rational a, Rational b)
    {
        return new Rational(a._numerator * b._denominator + b._numerator * a._denominator,
            a._denominator * b._denominator);
    }

    public static Rational operator -(Rational a, Rational b)
    {
        return new Rational(a._numerator * b._denominator - b._numerator * a._denominator,
            a._denominator * b._denominator);
    }

    public static Rational operator *(Rational a, Rational b)
    {
        return new Rational(a._numerator * b._numerator, a._denominator * b._denominator);
    }

    public static Rational operator /(Rational a, Rational b)
    {
        return new Rational(a._numerator * b._denominator, a._denominator * b._numerator);
    }

    public static explicit operator Rational(int i)
    {
        return new Rational(i, 1);
    }

    public static explicit operator Rational(long l)
    {
        return new Rational(l, 1);
    }

    public static explicit operator Rational(double d)
    {
        long denominator = 1;
        while (d % 1 != 0)
        {
            denominator *= 2;
            d *= 2;
        }

        return new Rational((long) d, denominator);
    }

    public static explicit operator Rational(float f)
    {
        long denominator = 1;
        while (f % 1 != 0)
        {
            denominator *= 2;
            f *= 2;
        }

        return new Rational((long) f, denominator);
    }
}

struct ModInt
{
    public long Value { get; }
    public static long Mod { get; set; } = 1000000000L + 7;

    public ModInt(long l)
    {
        long value = l % Mod;
        while (value < 0) value += Mod;
        Value = value % Mod;
    }

    public static implicit operator long(ModInt m)
    {
        return m.Value;
    }

    public static implicit operator ModInt(long l)
    {
        return new ModInt(l);
    }

    public static ModInt operator +(ModInt a, ModInt b)
    {
        return new ModInt(a.Value + b.Value);
    }

    public static ModInt operator -(ModInt a, ModInt b)
    {
        return new ModInt(a.Value - b.Value);
    }

    public static ModInt operator *(ModInt a, ModInt b)
    {
        return new ModInt(a.Value * b.Value);
    }

    public static ModInt operator /(ModInt a, ModInt b)
    {
        return new ModInt(a * b.Inverse());
    }

    public override string ToString()
    {
        return Value.ToString();
    }
}

static class ModIntMath
{
    public static ModInt Pow(this ModInt a, ModInt b)
    {
        var pow = b.Value;
        var m = a;
        ModInt ans = new ModInt(1);
        while (pow != 0)
        {
            if ((pow & 1) == 1)
            {
                ans *= m;
            }

            pow >>= 1;
            m *= m;
        }

        return ans;
    }

    public static ModInt Inverse(this ModInt m)
    {
        return m.Pow((ModInt) (ModInt.Mod - 2));
    }
}

class UnionFind
{
    private readonly int[] _array;

    public UnionFind(int N)
    {
        _array = new int[N];
        for (int i = 0; i < N; i++)
        {
            _array[i] = i;
        }
    }

    public int GetRootNode(int n)
    {
        if (_array[n] == n) return n;
        return _array[n] = GetRootNode(_array[n]);
    }

    public void UnionGroup(int a, int b)
    {
        var rootA = GetRootNode(a);
        var rootB = GetRootNode(b);
        if (rootA == rootB) return;
        _array[rootA] = rootB;
    }

    public bool IsSameGroup(int a, int b) => GetRootNode(a) == GetRootNode(b);

    public bool IsRoot(int n) => _array[n] == n;
}


namespace Extensions
{
    public class ConsoleInputExtension
    {
        private static readonly ConsoleInputExtension _cin = new ConsoleInputExtension();

        public static ConsoleInputExtension Cin => _cin;

        private static readonly Queue<string> _inputQueue = new Queue<string>();

        private ConsoleInputExtension()
        {
        }

        public static implicit operator string(ConsoleInputExtension _)
        {
            if (_inputQueue.Count == 0)
                Console.ReadLine().Split(' ')
                    .ForEach(val => _inputQueue.Enqueue(val));
            return _inputQueue.Dequeue();
        }

        public static implicit operator int(ConsoleInputExtension _)
        {
            if (_inputQueue.Count == 0)
                Console.ReadLine().Split(' ')
                    .ForEach(val => _inputQueue.Enqueue(val));
            return int.Parse(_inputQueue.Dequeue());
        }

        public static implicit operator long(ConsoleInputExtension _)
        {
            if (_inputQueue.Count == 0)
                Console.ReadLine().Split(' ')
                    .ForEach(val => _inputQueue.Enqueue(val));
            return long.Parse(_inputQueue.Dequeue());
        }

        public static implicit operator float(ConsoleInputExtension _)
        {
            if (_inputQueue.Count == 0)
                Console.ReadLine().Split(' ')
                    .ForEach(val => _inputQueue.Enqueue(val));
            return float.Parse(_inputQueue.Dequeue());
        }

        public static implicit operator double(ConsoleInputExtension _)
        {
            if (_inputQueue.Count == 0)
                Console.ReadLine().Split(' ')
                    .ForEach(val => _inputQueue.Enqueue(val));
            return double.Parse(_inputQueue.Dequeue());
        }
    }

    public static class ConsoleOutputExtension
    {
        private static StringBuilder _builder = new StringBuilder();

        public static void Cout(object o)
        {
            _builder.Append(o);
        }


        public static void CoutF(object o)
        {
            _builder.Append(o);
            Flush();
        }

        public static void Coutln(object o)
        {
            _builder.Append(o);
            _builder.Append('\n');
        }

        public static void Coutln()
        {
            _builder.Append('\n');
        }

        public static void CoutlnF(object o)
        {
            _builder.Append(o);
            _builder.Append('\n');
            Flush();
        }

        public static void Flush()
        {
            Console.Write(_builder.ToString());
            _builder.Clear();
        }
    }

    public static class MathExtension
    {
        //最小公倍数
        public static int LCM(int num1, int num2)
        {
            var gcd = GCD(num1, num2);
            return num1 * (num2 / gcd);
        }

        public static long LCM(long num1, long num2)
        {
            var gcd = GCD(num1, num2);
            return num1 * (num2 / gcd);
        }

        //最大公約数
        public static int GCD(int num1, int num2)
        {
            int a = Math.Max(num1, num2);
            int b = Math.Min(num1, num2);
            if (b == 0) return a;
            int mod;
            while ((mod = a % b) != 0)
            {
                a = b;
                b = mod;
            }

            return b;
        }

        public static long GCD(long num1, long num2)
        {
            long a = Math.Max(num1, num2);
            long b = Math.Min(num1, num2);
            if (b == 0) return a;
            long mod;
            while ((mod = a % b) != 0)
            {
                a = b;
                b = mod;
            }

            return b;
        }
    }

    public static class EnumerableExtension
    {
        public delegate void Function<in T>(T val);

        public static void ForEach<T>(this IEnumerable<T> enumerable, Function<T> function)
        {
            foreach (var x in enumerable)
            {
                function(x);
            }
        }
    }
}

Compiler output:
a.cc:1:7: error: expected nested-name-specifier before 'System'
    1 | using System;
      |       ^~~~~~
a.cc:2:7: error: expected nested-name-specifier before 'System'
    2 | using System.Collections.Generic;
      |       ^~~~~~
a.cc:3:7: error: expected nested-name-specifier before 'System'
    3 | using System.Diagnostics.Tracing;
      |       ^~~~~~
a.cc:4:7: error: expected nested-name-specifier before 'System'
    4 | using System.Linq;
      |       ^~~~~~
a.cc:5:7: error: expected nested-name-specifier before 'System'
    5 | using System.Net.NetworkInformation;
      |       ^~~~~~
a.cc:6:7: error: expected nested-name-specifier before 'System'
    6 | using System.Security.Cryptography;
      |       ^~~~~~
a.cc:7:7: error: expected nested-name-specifier before 'System'
    7 | using System.Text;
      |       ^~~~~~
a.cc:8:7: error: expected nested-name-specifier before 'System'
    8 | using System.Threading;
      |       ^~~~~~
a.cc:9:7: error: expected nested-name-specifier before 'Extensions'
    9 | using Extensions;
      |       ^~~~~~~~~~
a.cc:10:7: error: expected nested-name-specifier before 'static'
   10 | using static System.Math;
      |       ^~~~~~
a.cc:11:7: error: expected nested-name-specifier before 'static'
   11 | using static Extensions.MathExtension;
      |       ^~~~~~
a.cc:12:7: error: expected nested-name-specifier before 'static'
   12 | using static Extensions.ConsoleInputExtension;
      |       ^~~~~~
a.cc:13:7: error: expected nested-name-specifier before 'static'
   13 | using static Extensions.ConsoleOutputExtension;
      |       ^~~~~~
a.cc:17:11: error: expected ':' before 'void'
   17 |     public void Solve()
      |           ^~~~~
      |           :
a.cc:37:2: error: expected ';' after class definition
   37 | }
      |  ^
      |  ;
a.cc: In member function 'void Solver::Solve()':
a.cc:20:17: error: 'Cin' was not declared in this scope
   20 |         int a = Cin, b = Cin, c = Cin;
      |                 ^~~
a.cc:21:18: error: 'b' was not declared in this scope
   21 |         if (a == b && b == c)
      |                  ^
a.cc:21:28: error: 'c' was not declared in this scope
   21 |         if (a == b && b == c)
      |                            ^
a.cc:23:13: error: 'Coutln' was not declared in this scope
   23 |             Coutln("No");
      |             ^~~~~~
a.cc:27:18: error: 'b' was not declared in this scope
   27 |         if (a != b && b != c && c != a)
      |                  ^
a.cc:27:28: error: 'c' was not declared in this scope
   27 |         if (a != b && b != c && c != a)
      |                            ^
a.cc:29:13: error: 'Coutln' was not declared in this scope
   29 |             Coutln("No");
      |             ^~~~~~
a.cc:33:9: error: 'Coutln' was not declared in this scope
   33 |         Coutln("Yes");
      |         ^~~~~~
a.cc: At global scope:
a.cc:44:22: error: 'string' has not been declared
   44 |     static void Main(string[] args)
      |                      ^~~~~~
a.cc:44:31: error: expected ',' or '...' before 'args'
   44 |     static void Main(string[] args)
      |                               ^~~~
a.cc:49:2: error: expected ';' after class definition
   49 | }
      |  ^
      |  ;
a.cc: In static member function 'static void EntryPoint::Main(int*)':
a.cc:46:21: error: expected ';' before '.' token
   46 |         new Solver().Solve();
      |                     ^
a.cc:47:9: error: 'Flush' was not declared in this scope
   47 |         Flush();
      |         ^~~~~
a.cc: At global scope:
a.cc:52:7: error: 'PriorityQueue' is not a class template
   52 | class PriorityQueue<T>
      |       ^~~~~~~~~~~~~
a.cc:52:21: error: 'T' was not declared in this scope
   52 | class PriorityQueue<T>
      |                     ^
a.cc:54:12: error: expected ':' before 'readonly'
   54 |     private readonly List<Tuple<int, T>> _list = new List<Tuple<int, T>>();
      |            ^~~~~~~~~
      |            :
a.cc:54:13: error: 'readonly' does not name a type
   54 |     private readonly List<Tuple<int, T>> _list = new List<Tuple<int, T>>();
      |             ^~~~~~~~
a.cc:56:11: error: expected ':' before 'int'
   56 |     public int Count => _list.Count;
      |           ^~~~
      |           :
a.cc:58:11: error: expected ':' before 'PriorityQueue'
   58 |     public PriorityQueue()
      |           ^~~~~~~~~~~~~~
      |           :
a.cc:62:11: error: expected ':' before 'void'
   62 |     public void Push(T item, int priority)
      |           ^~~~~
      |           :
a.cc:62:22: error: 'T' has not been declared
   62 |     public void Push(T item, int priority)
      |                      ^
a.cc:75:12: error: expected ':' before 'int'
   75 |     private int GetParentIndex(int index)
      |            ^~~~
      |            :
a.cc:81:12: error: expected ':' before 'Tuple'
   81 |     private Tuple<int, int> GetChildrenIndex(int index)
      |            ^~~~~~
      |            :
a.cc:81:13: error: 'Tuple' does not name a type
   81 |     private Tuple<int, int> GetChildrenIndex(int index)
      |             ^~~~~
a.cc:88:11: error: expected ':' before 'T'
   88 |     public T Pop()
      |           ^~
      |           :
a.cc:88:12: error: 'T' does not name a type
   88 |     public T Pop()
      |            ^
a.cc:119:11: error: expected ':' before 'T'
  119 |     public T Peek()
      |           ^~
      |           :
a.cc:119:12: error: 'T' does not name a type
  119 |     public T Peek()
      |            ^
a.cc:124:12: error: expected ':' before 'void'
  124 |     private void Swap(int index1, int index2)
      |            ^~~~~
      |            :
a.cc:130:2: error: expected ';' after class definition
  130 | }
      |  ^
      |  ;
a.cc:56:23: error: expected primary-expression before '>' token
   56 |     public int Count => _list.Count;
      |                       ^
a.cc:56:25: error: '_list' was not declared in this scope
   56 |     public int Count => _list.Count;
      |                         ^~~~~
a.cc: In member function 'void PriorityQueue::Push(int, int)':
a.cc:64:9: error: '_list' was not declared in this scope
   64 |         _list.Add(Tuple.Create(priority, item));
      |         ^~~~~
a.cc:64:19: error: 'Tuple' was not declared in this scope
   64 |         _list.Add(Tuple.Create(priority, item));
      |                   ^~~~~
a.cc: In member function 'void PriorityQueue::Swap(int, int)':
a.cc:126:9: error: 'var' was not declared in this scope
  126 |         var tmp = _list[index1];
      |         ^~~
a.cc:127:9: error: '_list' was not declared in this scope
  127 |         _list[index1] = _list[index2];
      |         ^~~~~
a.cc:128:25: error: 'tmp' was not declared in this scope
  128 |         _list[index2] = tmp;
      |                         ^~~
a.cc: At global scope:
a.cc:134:12: error: expected ':' before 'long'
  134 |     private long _numerator;
      |            ^~~~~
      |            :
a.cc:135:12: error: expected ':' before 'long'
  135 |     private long _denominator;
      |            ^~~~~
      |            :
a.cc:136:11: error: expected ':' before 'long'
  136 |     public long Numerator => _numerator;
      |           ^~~~~
      |           :
a.cc:137:11: error: expected ':' before 'long'
  137 |     public long Denominator => _denominator;
      |           ^~~~~
      |           :
a.cc:139:11: error: expected ':' before 'Rational'
  139 |     public Rational(long numerator, long denominator)
      |           ^~~~~~~~~
      |           :
a.cc:146:11: error: expected ':' before 'static'
  146 |     public static Rational operator +(Rational a, Rational b)
      |           ^~~~~~~
      |           :
a.cc:146:28: error: 'static Rational Rational::operator+(Rational, Rational)' must be either a non-static member function or a non-member function
  146 |     public static Rational operator +(Rational a, Rational b)
      |                            ^~~~~~~~
a.cc:152:11: error: expected ':' before 'static'
  152 |     public static Rational operator -(Rational a, Rational b)
      |           ^~~~~~~
      |           :
a.cc:152:28: error: 'static Rational Rational::operator-(Rational, Rational)' must be either a non-static member function or a non-member function
  152 |     public static Rational operator -(Rational a, Rational b)
      |                            ^~~~~~~~
a.cc:158:11: error: expected ':' before 'static'
  158 |     public static Rational operator *(Rational a, Rational b)
      |           ^~~~~~~
      |           :
a.cc:158:28: error: 'static Rational Rational::operator*(Rational, Rational)' must be either a non-static member function or a non-member function
  158 |     public static Rational operator *(Rational a, Rational b)
      |                            ^~~~~~~~
a.cc:163:11: error: expected ':' before 'static'
  163 |     public static Rational operator /(Rational a, Rational b)
      |           ^~~~~~~
      |           :
a.cc:163:28: error: 'static Rational Rational::operator/(Rational, Rational)' must be either a non-static member function or a non-member function
  163 |     public static Rational operator /(Rational a, Rational b)
      |                            ^~~~~~~~
a.cc:168:11: error: expected ':' before 'static'
  168 |     public static explicit operator Rational(int i)
      |           ^~~~~~~
      |           :
a.cc:168:28: error: 'static Rational::operator Rational(int)' must be a non-static member function
  168 |     public static explicit operator Rational(int i)
      |                            ^~~~~~~~
a.cc:173:11: error: expected ':' before 'static'
  173 |     public static explicit operator Rational(long l)
      |           ^~~~~~~
      |           :
a.cc:173:28: error: 'static Rational::operator Rational(long int)' must be a non-static member function
  173 |     public static explicit operator Rational(long l)
      |                            ^~~~~~~~
a.cc:178:11: error: expected ':' before 'static'
  178 |     public static explicit operator Rational(double d)
      |           ^~~~~~~
      |           :
a.cc:178:28: error: 'static Rational::operator Rational(double)' must be a non-static memb