import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.StringTokenizer;



public class Main
{	
	
	static class Pair implements Comparable<Pair>
	{
		int x;
		int y;
		int type;
		Pair(int x,int y,int type)
		{
			this.x = x;
			this.y = y;
			this.type = type;
		}
		
		@Override
		public int compareTo(Pair o)
		{
			if(x != o.x)
			{	
				if(x < o.x)
				return -1;
				
				else return 1;
			}
			else
			{	
				if(y < o.y)
				return -1;
				
				else return 1;
			}
		}
	}
	 
	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; 
	    } 
	}

	static int maxN = 2000000;
	static int fact[] = new int[maxN+1];
	static int factorialNumInverse[] = new int[maxN+1];
	static int naturalNumInverse[] = new int[maxN+1];
	
	static void InverseofNumber() 
	{ 	
		int p = mod;
	    naturalNumInverse[0] = naturalNumInverse[1] = 1; 
	    for (int i = 2; i <= maxN; i++) 
	        naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p); 
	}
	
	static void InverseofFactorial() 
	{ 	
		int p = mod;
	    factorialNumInverse[0] = factorialNumInverse[1] = 1; 
	  
	    for (int i = 2; i <= maxN; i++) 
	        factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p); 
	} 
	
	static void Factorial()
	{
		
		fact[0] = 1;
		for(int i = 1; i < maxN; i++) 
		{
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		}
	}
	
	static int Binomial(int N, int R) 
	{ 
	    int p = mod;
	    int ans = (int)((1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) % p); 
	    return ans; 
	} 
	static int paths(int x1,int y1,int x2,int y2)
	{	
		int x = Math.abs(x2-x1);
		int y = Math.abs(y2-y1);
		
		int N = x+y;
		int R = x;
		
		int ans = Binomial(N,R);
		return ans;
	}
	
	static int mod = 998244353;
	
	// a b c d e f g h i j k
	// 0 1 0 1 0 1 0 1 0 1 0
	
	
	
	
	public static void main(String[] args) 
	{
		OutputStream outputStream = System.out;
		FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        
        
        String s = sc.nextLine();
        
        String a = "ARC";
        
        if(s.equals(a))
        out.println("ABC");
        
        else out.println("ARC");
        out.close();
        

	}
 
} import java.io.BufferedReader; BufferedReader java.io import java.io.IOException; IOException java.io import java.io.InputStreamReader; InputStreamReader java.io import java.io.OutputStream; OutputStream java.io import java.io.PrintWriter; PrintWriter java.io import java.util.ArrayList; ArrayList java.util import java.util.Arrays; Arrays java.util import java.util.Collections; Collections java.util import java.util.HashMap; HashMap java.util import java.util.StringTokenizer; StringTokenizer java.util public class Main
{	
	
	static class Pair implements Comparable<Pair>
	{
		int x;
		int y;
		int type;
		Pair(int x,int y,int type)
		{
			this.x = x;
			this.y = y;
			this.type = type;
		}
		
		@Override
		public int compareTo(Pair o)
		{
			if(x != o.x)
			{	
				if(x < o.x)
				return -1;
				
				else return 1;
			}
			else
			{	
				if(y < o.y)
				return -1;
				
				else return 1;
			}
		}
	}
	 
	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; 
	    } 
	}

	static int maxN = 2000000;
	static int fact[] = new int[maxN+1];
	static int factorialNumInverse[] = new int[maxN+1];
	static int naturalNumInverse[] = new int[maxN+1];
	
	static void InverseofNumber() 
	{ 	
		int p = mod;
	    naturalNumInverse[0] = naturalNumInverse[1] = 1; 
	    for (int i = 2; i <= maxN; i++) 
	        naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p); 
	}
	
	static void InverseofFactorial() 
	{ 	
		int p = mod;
	    factorialNumInverse[0] = factorialNumInverse[1] = 1; 
	  
	    for (int i = 2; i <= maxN; i++) 
	        factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p); 
	} 
	
	static void Factorial()
	{
		
		fact[0] = 1;
		for(int i = 1; i < maxN; i++) 
		{
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		}
	}
	
	static int Binomial(int N, int R) 
	{ 
	    int p = mod;
	    int ans = (int)((1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) % p); 
	    return ans; 
	} 
	static int paths(int x1,int y1,int x2,int y2)
	{	
		int x = Math.abs(x2-x1);
		int y = Math.abs(y2-y1);
		
		int N = x+y;
		int R = x;
		
		int ans = Binomial(N,R);
		return ans;
	}
	
	static int mod = 998244353;
	
	// a b c d e f g h i j k
	// 0 1 0 1 0 1 0 1 0 1 0
	
	
	
	
	public static void main(String[] args) 
	{
		OutputStream outputStream = System.out;
		FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        
        
        String s = sc.nextLine();
        
        String a = "ARC";
        
        if(s.equals(a))
        out.println("ABC");
        
        else out.println("ARC");
        out.close();
        

	}
 
} Main static int maxN = 2000000; maxN 2000000 static int fact[] = new int[maxN+1]; fact new int[maxN+1] maxN+1 maxN 1 static int factorialNumInverse[] = new int[maxN+1]; factorialNumInverse new int[maxN+1] maxN+1 maxN 1 static int naturalNumInverse[] = new int[maxN+1]; naturalNumInverse new int[maxN+1] maxN+1 maxN 1 static int mod = 998244353; mod 998244353 static void InverseofNumber() 
	{ 	
		int p = mod;
	    naturalNumInverse[0] = naturalNumInverse[1] = 1; 
	    for (int i = 2; i <= maxN; i++) 
	        naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p); 
	} InverseofNumber { 	
		int p = mod;
	    naturalNumInverse[0] = naturalNumInverse[1] = 1; 
	    for (int i = 2; i <= maxN; i++) 
	        naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p); 
	} int p = mod; p mod naturalNumInverse[0] = naturalNumInverse[1] = 1 naturalNumInverse[0] naturalNumInverse 0 naturalNumInverse[1] = 1 naturalNumInverse[1] naturalNumInverse 1 1 for (int i = 2; i <= maxN; i++) 
	        naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p); int i = 2; int i = 2; i 2 i <= maxN i maxN i++ i++ i naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p); naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p) naturalNumInverse[i] naturalNumInverse i (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p) (1L *naturalNumInverse[p % i] * (p - p / i)) 1L *naturalNumInverse[p % i] * (p - p / i) 1L naturalNumInverse[p % i] naturalNumInverse p % i p i (p - p / i) p p / i p i p static void InverseofFactorial() 
	{ 	
		int p = mod;
	    factorialNumInverse[0] = factorialNumInverse[1] = 1; 
	  
	    for (int i = 2; i <= maxN; i++) 
	        factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p); 
	} InverseofFactorial { 	
		int p = mod;
	    factorialNumInverse[0] = factorialNumInverse[1] = 1; 
	  
	    for (int i = 2; i <= maxN; i++) 
	        factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p); 
	} int p = mod; p mod factorialNumInverse[0] = factorialNumInverse[1] = 1 factorialNumInverse[0] factorialNumInverse 0 factorialNumInverse[1] = 1 factorialNumInverse[1] factorialNumInverse 1 1 for (int i = 2; i <= maxN; i++) 
	        factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p); int i = 2; int i = 2; i 2 i <= maxN i maxN i++ i++ i factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p); factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p) factorialNumInverse[i] factorialNumInverse i (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p) (1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) 1L*naturalNumInverse[i] * factorialNumInverse[i - 1] 1L naturalNumInverse[i] naturalNumInverse i factorialNumInverse[i - 1] factorialNumInverse i - 1 i 1 p static void Factorial()
	{
		
		fact[0] = 1;
		for(int i = 1; i < maxN; i++) 
		{
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		}
	} Factorial {
		
		fact[0] = 1;
		for(int i = 1; i < maxN; i++) 
		{
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		}
	} fact[0] = 1 fact[0] fact 0 1 for(int i = 1; i < maxN; i++) 
		{
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		} int i = 1; int i = 1; i 1 i < maxN i maxN i++ i++ i {
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		} {
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		} fact[i] = (int)(1L *fact[i - 1] * i % mod) fact[i] fact i (int)(1L *fact[i - 1] * i % mod) 1L *fact[i - 1] * i 1L *fact[i - 1] * i 1L fact[i - 1] fact i - 1 i 1 i mod static int Binomial(int N, int R) 
	{ 
	    int p = mod;
	    int ans = (int)((1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) % p); 
	    return ans; 
	} Binomial { 
	    int p = mod;
	    int ans = (int)((1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) % p); 
	    return ans; 
	} int p = mod; p mod int ans = (int)((1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) % p); ans (int)((1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) % p) (1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) 1L *(1L*fact[N] * factorialNumInverse[R]) % p 1L *(1L*fact[N] * factorialNumInverse[R]) 1L (1L*fact[N] * factorialNumInverse[R]) 1L*fact[N] * factorialNumInverse[R] 1L fact[N] fact N factorialNumInverse[R] factorialNumInverse R p factorialNumInverse[(N - R)] factorialNumInverse (N - R) N R p return ans; ans int N N int R R static int paths(int x1,int y1,int x2,int y2)
	{	
		int x = Math.abs(x2-x1);
		int y = Math.abs(y2-y1);
		
		int N = x+y;
		int R = x;
		
		int ans = Binomial(N,R);
		return ans;
	} paths {	
		int x = Math.abs(x2-x1);
		int y = Math.abs(y2-y1);
		
		int N = x+y;
		int R = x;
		
		int ans = Binomial(N,R);
		return ans;
	} int x = Math.abs(x2-x1); x Math.abs(x2-x1) Math.abs Math x2-x1 x2 x1 int y = Math.abs(y2-y1); y Math.abs(y2-y1) Math.abs Math y2-y1 y2 y1 int N = x+y; N x+y x y int R = x; R x int ans = Binomial(N,R); ans Binomial(N,R) Binomial N R return ans; ans int x1 x1 int y1 y1 int x2 x2 int y2 y2 public static void main(String[] args) 
	{
		OutputStream outputStream = System.out;
		FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        
        
        String s = sc.nextLine();
        
        String a = "ARC";
        
        if(s.equals(a))
        out.println("ABC");
        
        else out.println("ARC");
        out.close();
        

	} main {
		OutputStream outputStream = System.out;
		FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        
        
        String s = sc.nextLine();
        
        String a = "ARC";
        
        if(s.equals(a))
        out.println("ABC");
        
        else out.println("ARC");
        out.close();
        

	} OutputStream outputStream = System.out; outputStream System.out System System.out FastReader sc = new FastReader(); sc new FastReader() PrintWriter out = new PrintWriter(outputStream); out new PrintWriter(outputStream) String s = sc.nextLine(); s sc.nextLine() sc.nextLine sc String a = "ARC"; a "ARC" if(s.equals(a))
        out.println("ABC");
        
        else out.println("ARC"); s.equals(a) s.equals s a out.println("ABC") out.println out "ABC" out.println("ARC") out.println out "ARC" out.close() out.close out String[] args args static class Pair implements Comparable<Pair>
	{
		int x;
		int y;
		int type;
		Pair(int x,int y,int type)
		{
			this.x = x;
			this.y = y;
			this.type = type;
		}
		
		@Override
		public int compareTo(Pair o)
		{
			if(x != o.x)
			{	
				if(x < o.x)
				return -1;
				
				else return 1;
			}
			else
			{	
				if(y < o.y)
				return -1;
				
				else return 1;
			}
		}
	} Pair int x; x int y; y int type; type Pair(int x,int y,int type)
		{
			this.x = x;
			this.y = y;
			this.type = type;
		} Pair {
			this.x = x;
			this.y = y;
			this.type = type;
		} this.x = x this.x this this.x x this.y = y this.y this this.y y this.type = type this.type this this.type type int x x int y y int type type @Override
		public int compareTo(Pair o)
		{
			if(x != o.x)
			{	
				if(x < o.x)
				return -1;
				
				else return 1;
			}
			else
			{	
				if(y < o.y)
				return -1;
				
				else return 1;
			}
		} compareTo {
			if(x != o.x)
			{	
				if(x < o.x)
				return -1;
				
				else return 1;
			}
			else
			{	
				if(y < o.y)
				return -1;
				
				else return 1;
			}
		} if(x != o.x)
			{	
				if(x < o.x)
				return -1;
				
				else return 1;
			}
			else
			{	
				if(y < o.y)
				return -1;
				
				else return 1;
			} x != o.x x o.x o o.x {	
				if(x < o.x)
				return -1;
				
				else return 1;
			} if(x < o.x)
				return -1;
				
				else return 1; x < o.x x o.x o o.x return -1; -1 1 return 1; 1 {	
				if(y < o.y)
				return -1;
				
				else return 1;
			} if(y < o.y)
				return -1;
				
				else return 1; y < o.y y o.y o o.y return -1; -1 1 return 1; 1 Pair o o Comparable 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; 
	    } 
	} FastReader BufferedReader br; br StringTokenizer st; st public FastReader() 
	    { 
	        br = new BufferedReader(new
	                 InputStreamReader(System.in)); 
	    } FastReader { 
	        br = new BufferedReader(new
	                 InputStreamReader(System.in)); 
	    } br = new BufferedReader(new
	                 InputStreamReader(System.in)) 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(); 
	    } next { 
	        while (st == null || !st.hasMoreElements()) 
	        { 
	            try
	            { 
	                st = new StringTokenizer(br.readLine()); 
	            } 
	            catch (IOException  e) 
	            { 
	                e.printStackTrace(); 
	            } 
	        } 
	        return st.nextToken(); 
	    } while (st == null || !st.hasMoreElements()) 
	        { 
	            try
	            { 
	                st = new StringTokenizer(br.readLine()); 
	            } 
	            catch (IOException  e) 
	            { 
	                e.printStackTrace(); 
	            } 
	        } st == null || !st.hasMoreElements() st == null st null !st.hasMoreElements() st.hasMoreElements() st.hasMoreElements st { 
	            try
	            { 
	                st = new StringTokenizer(br.readLine()); 
	            } 
	            catch (IOException  e) 
	            { 
	                e.printStackTrace(); 
	            } 
	        } try
	            { 
	                st = new StringTokenizer(br.readLine()); 
	            } 
	            catch (IOException  e) 
	            { 
	                e.printStackTrace(); 
	            } catch (IOException  e) 
	            { 
	                e.printStackTrace(); 
	            } IOException  e { 
	                e.printStackTrace(); 
	            } e.printStackTrace() e.printStackTrace e { 
	                st = new StringTokenizer(br.readLine()); 
	            } st = new StringTokenizer(br.readLine()) st new StringTokenizer(br.readLine()) return st.nextToken(); st.nextToken() st.nextToken st int nextInt() 
	    { 
	        return Integer.parseInt(next()); 
	    } nextInt { 
	        return Integer.parseInt(next()); 
	    } return Integer.parseInt(next()); Integer.parseInt(next()) Integer.parseInt Integer next() next long nextLong() 
	    { 
	        return Long.parseLong(next()); 
	    } nextLong { 
	        return Long.parseLong(next()); 
	    } return Long.parseLong(next()); Long.parseLong(next()) Long.parseLong Long next() next double nextDouble() 
	    { 
	        return Double.parseDouble(next()); 
	    } nextDouble { 
	        return Double.parseDouble(next()); 
	    } return Double.parseDouble(next()); Double.parseDouble(next()) Double.parseDouble Double next() next String nextLine() 
	    { 
	        String str = ""; 
	        try
	        { 
	            str = br.readLine(); 
	        } 
	        catch (IOException e) 
	        { 
	            e.printStackTrace(); 
	        } 
	        return str; 
	    } nextLine { 
	        String str = ""; 
	        try
	        { 
	            str = br.readLine(); 
	        } 
	        catch (IOException e) 
	        { 
	            e.printStackTrace(); 
	        } 
	        return str; 
	    } String str = ""; str "" try
	        { 
	            str = br.readLine(); 
	        } 
	        catch (IOException e) 
	        { 
	            e.printStackTrace(); 
	        } catch (IOException e) 
	        { 
	            e.printStackTrace(); 
	        } IOException e { 
	            e.printStackTrace(); 
	        } e.printStackTrace() e.printStackTrace e { 
	            str = br.readLine(); 
	        } str = br.readLine() str br.readLine() br.readLine br return str; str public class Main
{	
	
	static class Pair implements Comparable<Pair>
	{
		int x;
		int y;
		int type;
		Pair(int x,int y,int type)
		{
			this.x = x;
			this.y = y;
			this.type = type;
		}
		
		@Override
		public int compareTo(Pair o)
		{
			if(x != o.x)
			{	
				if(x < o.x)
				return -1;
				
				else return 1;
			}
			else
			{	
				if(y < o.y)
				return -1;
				
				else return 1;
			}
		}
	}
	 
	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; 
	    } 
	}

	static int maxN = 2000000;
	static int fact[] = new int[maxN+1];
	static int factorialNumInverse[] = new int[maxN+1];
	static int naturalNumInverse[] = new int[maxN+1];
	
	static void InverseofNumber() 
	{ 	
		int p = mod;
	    naturalNumInverse[0] = naturalNumInverse[1] = 1; 
	    for (int i = 2; i <= maxN; i++) 
	        naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p); 
	}
	
	static void InverseofFactorial() 
	{ 	
		int p = mod;
	    factorialNumInverse[0] = factorialNumInverse[1] = 1; 
	  
	    for (int i = 2; i <= maxN; i++) 
	        factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p); 
	} 
	
	static void Factorial()
	{
		
		fact[0] = 1;
		for(int i = 1; i < maxN; i++) 
		{
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		}
	}
	
	static int Binomial(int N, int R) 
	{ 
	    int p = mod;
	    int ans = (int)((1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) % p); 
	    return ans; 
	} 
	static int paths(int x1,int y1,int x2,int y2)
	{	
		int x = Math.abs(x2-x1);
		int y = Math.abs(y2-y1);
		
		int N = x+y;
		int R = x;
		
		int ans = Binomial(N,R);
		return ans;
	}
	
	static int mod = 998244353;
	
	// a b c d e f g h i j k
	// 0 1 0 1 0 1 0 1 0 1 0
	
	
	
	
	public static void main(String[] args) 
	{
		OutputStream outputStream = System.out;
		FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        
        
        String s = sc.nextLine();
        
        String a = "ARC";
        
        if(s.equals(a))
        out.println("ABC");
        
        else out.println("ARC");
        out.close();
        

	}
 
} public class Main
{	
	
	static class Pair implements Comparable<Pair>
	{
		int x;
		int y;
		int type;
		Pair(int x,int y,int type)
		{
			this.x = x;
			this.y = y;
			this.type = type;
		}
		
		@Override
		public int compareTo(Pair o)
		{
			if(x != o.x)
			{	
				if(x < o.x)
				return -1;
				
				else return 1;
			}
			else
			{	
				if(y < o.y)
				return -1;
				
				else return 1;
			}
		}
	}
	 
	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; 
	    } 
	}

	static int maxN = 2000000;
	static int fact[] = new int[maxN+1];
	static int factorialNumInverse[] = new int[maxN+1];
	static int naturalNumInverse[] = new int[maxN+1];
	
	static void InverseofNumber() 
	{ 	
		int p = mod;
	    naturalNumInverse[0] = naturalNumInverse[1] = 1; 
	    for (int i = 2; i <= maxN; i++) 
	        naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p); 
	}
	
	static void InverseofFactorial() 
	{ 	
		int p = mod;
	    factorialNumInverse[0] = factorialNumInverse[1] = 1; 
	  
	    for (int i = 2; i <= maxN; i++) 
	        factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p); 
	} 
	
	static void Factorial()
	{
		
		fact[0] = 1;
		for(int i = 1; i < maxN; i++) 
		{
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		}
	}
	
	static int Binomial(int N, int R) 
	{ 
	    int p = mod;
	    int ans = (int)((1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) % p); 
	    return ans; 
	} 
	static int paths(int x1,int y1,int x2,int y2)
	{	
		int x = Math.abs(x2-x1);
		int y = Math.abs(y2-y1);
		
		int N = x+y;
		int R = x;
		
		int ans = Binomial(N,R);
		return ans;
	}
	
	static int mod = 998244353;
	
	// a b c d e f g h i j k
	// 0 1 0 1 0 1 0 1 0 1 0
	
	
	
	
	public static void main(String[] args) 
	{
		OutputStream outputStream = System.out;
		FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        
        
        String s = sc.nextLine();
        
        String a = "ARC";
        
        if(s.equals(a))
        out.println("ABC");
        
        else out.println("ARC");
        out.close();
        

	}
 
} Main
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.StringTokenizer;



public class Main
{	
	
	static class Pair implements Comparable<Pair>
	{
		int x;
		int y;
		int type;
		Pair(int x,int y,int type)
		{
			this.x = x;
			this.y = y;
			this.type = type;
		}
		
		@Override
		public int compareTo(Pair o)
		{
			if(x != o.x)
			{	
				if(x < o.x)
				return -1;
				
				else return 1;
			}
			else
			{	
				if(y < o.y)
				return -1;
				
				else return 1;
			}
		}
	}
	 
	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; 
	    } 
	}

	static int maxN = 2000000;
	static int fact[] = new int[maxN+1];
	static int factorialNumInverse[] = new int[maxN+1];
	static int naturalNumInverse[] = new int[maxN+1];
	
	static void InverseofNumber() 
	{ 	
		int p = mod;
	    naturalNumInverse[0] = naturalNumInverse[1] = 1; 
	    for (int i = 2; i <= maxN; i++) 
	        naturalNumInverse[i] = (int)((1L *naturalNumInverse[p % i] * (p - p / i))%p); 
	}
	
	static void InverseofFactorial() 
	{ 	
		int p = mod;
	    factorialNumInverse[0] = factorialNumInverse[1] = 1; 
	  
	    for (int i = 2; i <= maxN; i++) 
	        factorialNumInverse[i] = (int)((1L*naturalNumInverse[i] * factorialNumInverse[i - 1]) % p); 
	} 
	
	static void Factorial()
	{
		
		fact[0] = 1;
		for(int i = 1; i < maxN; i++) 
		{
			fact[i] = (int)(1L *fact[i - 1] * i % mod);
		}
	}
	
	static int Binomial(int N, int R) 
	{ 
	    int p = mod;
	    int ans = (int)((1L *(1L*fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[(N - R)]) % p); 
	    return ans; 
	} 
	static int paths(int x1,int y1,int x2,int y2)
	{	
		int x = Math.abs(x2-x1);
		int y = Math.abs(y2-y1);
		
		int N = x+y;
		int R = x;
		
		int ans = Binomial(N,R);
		return ans;
	}
	
	static int mod = 998244353;
	
	// a b c d e f g h i j k
	// 0 1 0 1 0 1 0 1 0 1 0
	
	
	
	
	public static void main(String[] args) 
	{
		OutputStream outputStream = System.out;
		FastReader sc = new FastReader();
        PrintWriter out = new PrintWriter(outputStream);
        
        
        String s = sc.nextLine();
        
        String a = "ARC";
        
        if(s.equals(a))
        out.println("ABC");
        
        else out.println("ARC");
        out.close();
        

	}
 
}