When the curtains are opened, a canvas unfolds outside. Kanno marvels at all the blonde colours along the riverside — not tangerines, but blossoms instead.

"What a pity it's already late spring," sighs Mino with regret, "one more drizzling night and they'd be gone."

"But these blends are at their best, aren't they?" Absorbed in the landscape, Kanno remains optimistic. 

The landscape can be expressed as a row of consecutive cells, each of which either contains a flower of colour amber or buff or canary yellow, or is empty.

When a flower withers, it disappears from the cell that it originally belonged to, and it spreads petals of its colour in its two neighbouring cells (or outside the field if the cell is on the side of the landscape). In case petals fall outside the given cells, they simply become invisible.

You are to help Kanno determine whether it's possible that after some (possibly none or all) flowers shed their petals, at least one of the cells contains all three colours, considering both petals and flowers. Note that flowers can wither in arbitrary order.

Input

The first and only line of input contains a non-empty string s consisting of uppercase English letters 'A', 'B', 'C' and characters '.' (dots) only (\lvert s \rvert ≤ 100) — denoting cells containing an amber flower, a buff one, a canary yellow one, and no flowers, respectively.

Output

Output "Yes" if it's possible that all three colours appear in some cell, and "No" otherwise.

You can print each letter in any case (upper or lower).

Examples

Input

.BAC.


Output

Yes


Input

AA..CB


Output

No

Note

In the first example, the buff and canary yellow flowers can leave their petals in the central cell, blending all three colours in it.

In the second example, it's impossible to satisfy the requirement because there is no way that amber and buff meet in any cell.
import java.io.IOException;
import java.awt.color.*;
import java.util.*;
import java.awt.Point;
import java.math.*;
import java.io.*;
import java.util.InputMismatchException;
@SuppressWarnings("unused")
public class main {	String g="";int c=0;int M=1000000000+7;
	public static void main(String[] args) {
                new main().solve();
                                  }
            public void solve() {
          String s=sc.next();
          String[] a= {"ABC","ACB","BAC","BCA","CAB","CBA"};int c=0;
          for(int i=0;i<6;i++) {
        	  if(s.contains(a[i]))
        		  c++;
          }
          if(c!=0)
        	  System.out.println("Yes");
          else
        	  System.out.println("No");
        
         }
         
            	public class Node{
            		int data;int color;
            		Node par;
            		public Node(int a) {
            			data=a;
            			
            		}
            	}
            	
            static final int MAXN = 100001;
       	 
        	// stores smallest prime factor for every number
        	static int spf[] = new int[MAXN];
        	 
        	// Calculating SPF (Smallest Prime Factor) for every
        	// number till MAXN.
        	// Time Complexity : O(nloglogn)
        	static void sieve()
        	{
        	    spf[1] = 1;
        	    for (int i=2; i<MAXN; i++)
        	 
        	        // marking smallest prime factor for every
        	        // number to be itself.
        	        spf[i] = i;
        	 
        	    // separately marking spf for every even
        	    // number as 2
        	    for (int i=4; i<MAXN; i+=2)
        	        spf[i] = 2;
        	 
        	    for (int i=3; i*i<MAXN; i++)
        	    {
        	        // checking if i is prime
        	        if (spf[i] == i)
        	        {
        	            // marking SPF for all numbers divisible by i
        	            for (int j=i*i; j<MAXN; j+=i)
        	 
        	                // marking spf[j] if it is not 
        	                // previously marked
        	                if (spf[j]==j)
        	                    spf[j] = i;
        	        }
        	    }
        	}
        	 
        	// A O(log n) function returning primefactorization
        	// by dividing by smallest prime factor at every step
        	static Vector<Integer> getFactorization(int x)
        	{
        	    Vector<Integer> ret = new Vector<>();
        	    while (x != 1)
        	    {
        	        ret.add(spf[x]);
        	        x = x / spf[x];
        	    }
        	    return ret;
        	}
        	 
            int d, x, y;
            void extendedEuclid(int A, int B) {
                if(B == 0) {
                    d = A;
                    x = 1;
                    y = 0;
                }
                else {
                    extendedEuclid(B, A%B);
                    int temp = x;
                    x = y;
                    y = temp - (A/B)*y;
                }
            }
            static final int MAX_SIZE = 1000001;
            // isPrime[] : isPrime[i] is true if number is prime 
            // prime[] : stores all prime number less than N
            // SPF[] that store smallest prime factor of number
            // [for Exp : smallest prime factor of '8' and '16'
            // is '2' so we put SPF[8] = 2 , SPF[16] = 2 ]
            static Vector<Boolean>isprime = new Vector<>(MAX_SIZE);
            static Vector<Integer>prime = new Vector<>();
            static Vector<Integer>SPF = new Vector<>(MAX_SIZE);
              
            // method generate all prime number less then N in O(n)
            static void manipulated_seive(int N)
            {
                // 0 and 1 are not prime
                isprime.set(0, false);
                isprime.set(1, false);
                 
                // Fill rest of the entries
                for (int i=2; i<N ; i++)
                {
                    // If isPrime[i] == True then i is
                    // prime number
                    if (isprime.get(i))
                    {
                        // put i into prime[] vector
                        prime.add(i);
              
                        // A prime number is its own smallest
                        // prime factor
                        SPF.set(i,i);
                    }
              
                    // Remove all multiples of  i*prime[j] which are
                    // not prime by making isPrime[i*prime[j]] = false
                    // and put smallest prime factor of i*Prime[j] as prime[j]
                    // [ for exp :let  i = 5 , j = 0 , prime[j] = 2 [ i*prime[j] = 10 ]
                    // so smallest prime factor of '10' is '2' that is prime[j] ]
                    // this loop run only one time for number which are not prime
                    for (int j=0;
                         j < prime.size() &&
                         i*prime.get(j) < N && prime.get(j) <= SPF.get(i);
                         j++)
                    {
                        isprime.set(i*prime.get(j),false);
              
                        // put smallest prime factor of i*prime[j]
                        SPF.set(i*prime.get(j),prime.get(j)) ;
                    }
                }
            }
            

            int modularExponentiation(long x,long n)
            {
                if(n==0)
                    return 1;
                else if(n%2 == 0)        //n is even
                    return modularExponentiation((x*x),n/2);
                else                             //n is odd
                    return (int) ((x*modularExponentiation((x*x),(n-1)/2)));

            }
            
            
            
         
            int modularExponentiation(long x,long n,long M)
            {
                if(n==0)
                    return 1;
                else if(n%2 == 0)        //n is even
                    return modularExponentiation((x*x)%M,n/2,M);
                else                             //n is odd
                    return (int) ((x*modularExponentiation((x*x)%M,(n-1)/2,M))%M);

            }
            
            
            
            
            
            public int bfs(HashSet<Integer>[] adil,int n){
                int c=0;
                int[] shortdis=new int[n+1];
                Arrays.fill(shortdis,(int)1e5);
                LinkedList<Integer> queue=new LinkedList<Integer>();
                queue.add(1);
                shortdis[1]=0;
                while(queue.size()!=0){
                       int cc=queue.removeFirst();
                       Iterator<Integer> it=adil[cc].iterator();
                       while(it.hasNext()){
                              int f=it.next();
                              if(shortdis[f]==1e5){
                                     shortdis[f]=shortdis[cc]+1;
                                     queue.add(f);
                              }
                       }
                }
                return(shortdis[n]);
         }         
            
          /*  boolean[] sieveOfEratosthenes(int n)
            {
            	
                // (a / b) % m = (a % m * b^(m - 2) % m) % mCreate a boolean array "prime[0..n]" and initialize
                // all entries it as true. A value in prime[i] will
                // finally be false if i is Not a prime, else true.
                boolean prime[] = new boolean[n+1];
                for(int i=0;i<n;i++)
                    prime[i] = true;
                 
                for(int p = 2; p*p <=n; p++)
                {
                    // If prime[p] is not changed, then it is a prime
                    if(prime[p] == true)
                    {
                        // Update all multiples of p
                        for(int i = p*2; i <= n; i += p)
                            prime[i] = false;
                    }
                }
                 
                // Print all prime numbers
               return prime;
            }
            
   /*         void DFS(int v,boolean visited[])
    {
        // Mark the current node as visited and print it
        visited[v] = true;
        System.out.print(v+" ");
 
        // Recur for all the vertices adjacent to this vertex
        Iterator<Integer> i = adj[v].listIterator();
        while (i.hasNext())
        {
            int n = i.next();
            if (!visited[n])
                DFS(n, visited);
        }
    }*/
    /*static int binomialCoeff(int n, int k)
    {
        int C[] = new int[k + 1];
        
        // nC0 is 1
        C[0] = 1;  
      
        for (int i = 1; i <= n; i++)
        {
            // Compute next row of pascal 
            // triangle using the previous row
            for (int j = Math.min(i, k); j > 0; j--)
                C[j] = C[j] + C[j-1];
        }
        return C[k];
    }*/
         
          FastReader sc=new FastReader();
static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        int nextInt()
        {
            return Integer.parseInt(next());
        }
 
        long nextLong()
        {
            return Long.parseLong(next());
        }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
public class Pair implements Comparable<Pair> {
	  final long u;
	  final long v;

	  public Pair(long u, long v) {
	    this.u = u;
	    this.v = v;
	  }

	  public int hashCode() {
	    int hu = (int) (u ^ (u >>> 32));
	    int hv = (int) (v ^ (v >>> 32));
	    return 31 * hu + hv;
	  }

	  public boolean equals(Object o) {
	    Pair other = (Pair) o;
	    return u == other.u && v == other.v;
	  }

	  public int compareTo(Pair other) {
	    return Long.compare(u, other.u) != 0 ? Long.compare(u, other.u) : Long.compare(v, other.v);
	  }

	  public String toString() {
	    return "[u=" + u + ", v=" + v + "]";
	  }


}


}