jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.util.*; import java.io.*; import java.math.*;
public class Main{
	//Don't have to see. start------------------------------------------
	static class InputIterator{
		ArrayList<String> inputLine = new ArrayList<String>(1024);
		int index = 0; int max; String read;
		InputIterator(){
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			try{
				while((read = br.readLine()) != null){
					inputLine.add(read);
				}
			}catch(IOException e){}
			max = inputLine.size();
		}
		boolean hasNext(){return (index < max);}
		String next(){
			if(hasNext()){
				return inputLine.get(index++);
			}else{
				throw new IndexOutOfBoundsException("There is no more input");
			}
		}
	}
	static HashMap<Integer, String> CONVSTR = new HashMap<Integer, String>();
	static InputIterator ii = new InputIterator();//This class cannot be used in reactive problem.
	static PrintWriter out = new PrintWriter(System.out);
	static void flush(){out.flush();}
	static void myout(Object t){out.println(t);}
	static void myerr(Object t){System.err.print("debug:");System.err.println(t);}
	static String next(){return ii.next();}
	static boolean hasNext(){return ii.hasNext();}
	static int nextInt(){return Integer.parseInt(next());}
	static long nextLong(){return Long.parseLong(next());}
	static double nextDouble(){return Double.parseDouble(next());}
	static ArrayList<String> nextStrArray(){return myconv(next(), 8);}
	static ArrayList<String> nextCharArray(){return myconv(next(), 0);}
	static ArrayList<Integer> nextIntArray(){
		ArrayList<String> input = nextStrArray(); ArrayList<Integer> ret = new ArrayList<Integer>(input.size());
		for(int i = 0; i < input.size(); i++){
			ret.add(Integer.parseInt(input.get(i)));
		}
		return ret;
	}
	static ArrayList<Long> nextLongArray(){
		ArrayList<String> input = nextStrArray(); ArrayList<Long> ret = new ArrayList<Long>(input.size());
		for(int i = 0; i < input.size(); i++){
			ret.add(Long.parseLong(input.get(i)));
		}
		return ret;
	}
	static String myconv(Object list, int no){//only join
		String joinString = CONVSTR.get(no);
		if(list instanceof String[]){
			return String.join(joinString, (String[])list);
		}else if(list instanceof ArrayList){
			return String.join(joinString, (ArrayList)list);
		}else{
			throw new ClassCastException("Don't join");
		}
	}
	static ArrayList<String> myconv(String str, int no){//only split
		String splitString = CONVSTR.get(no);
		return new ArrayList<String>(Arrays.asList(str.split(splitString)));
	}
	public static void main(String[] args){
		CONVSTR.put(8, " "); CONVSTR.put(9, "\n"); CONVSTR.put(0, "");
		solve();flush();
	}
	//Don't have to see. end------------------------------------------
	static void solve(){//Here is the main function
      int N = nextInt();
      Arraylist<Integer> plus = nextIntArray();
      Arraylist<Integer> minus = nextIntArray();
      int ouptut = 0;
      for(int i = 0; i < N; i++){
        if(plsu.get(i) > minus.get(i)){
          output += plus.get(i) - minus.get(i);
        }
      }
      myout(output);
	}
	//Method addition frame start



	//Method addition frame end
}
//  [cpp]
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;

int main(){
int n, sum=0,dummy;
cin >> n;
vector <int> a;
vector<int>b;
for (int i=0;i<n;i++){
cin >> dummy;
a.push_back(dummy);
}
for (int i=0;i<n;i++){
cin >> dummy;
b.push_back(dummy);
}
for (int i = 0;i<n;i++){
if (a[i]>b[i]){
sum+= a[i]-b[i];}
}
cout << sum << "\n";
return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
int main()
{
	int n;
	cin>>n;
	int v[n],c[n],sum=0;
	for(int i=0;i<n;i++){
		cin>>v[i];
	}
	for(int i=0;i<n;i++){
		cin>>c[i];
	}
	for(int i=0;i<n;i++){
		if(v[i]-c[i]>0){
			sum+=v[i]-c[i];
		}
	}
	cout<<sum;
	return 0;
}
//  [cpp]
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;

int main()
{
	int n, v[25], c[25], x = 0, y = 0;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> v[i];
	}
	for (int i = 0; i < n; i++) {
		cin >> c[i];
	}
	for (int i = 0; i < n; i++) {
		if (v[i] > c[i]) {
			x += v[i];
			y += c[i];
		}
	}
	cout << x - y << endl;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

int main(){
  int N;cin>>N;
  int V[N],C[N],A[N];
  for(int i=0;i<N;i++) cin>>V[i];
  for(int i=0;i<N;i++) cin>>C[i];
  for(int i=0;i<N;i++) A[i]=V[i]-C[i];
  sort(A.begin(),A.end());
  reverse(A.begin(),A.end());
  int ans=0;
  for(int i=0;i<N;i++){
    if(A[i]>0) ans+=A[i];
    else break;
  }
  cout<<ans<<endl;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

using ll =                   long long int;
using pll =                  pair<ll, ll>;
#define endl                 "\n"
#define space                " "
#define TLE_na_ho            ios_base::sync_with_stdio(false);cin.tie(NULL)
#define MAX_SIZE             1024
#define MOD                  1000000007
#define pb                   push_back
#define fi                   first
#define se                   second
#define rep(i,a,n)           for(ll i=a;i<n;i++)
#define repe(i,a,n)          for(ll i=a;i<=n;i++)
#define repr(i,a,n)          for(ll i=a;i>=n;i--)
#define ain(arr,n)           for(ll i1=0;i1<n;i1++ ) cin>>arr[i1]
#define aout(arr,n)          for(ll i1=0;i1<n;i1++ ) cout<<arr[i1]<<space


int main()
{
    TLE_na_ho;
    //READ THE QUESTION PROPERLY!!
    ll t;
    t=1;
    //cin>>t;
    while(t--){
    	ll n;
    	cin>>n;
    	ll v[n];
    	ain(v,n);
    	ll c[n];
    	ain(c,n);
    	sort(v,v+n,greater<int>());
    	sort(c,c+n,greater<int>());

    	ll ans=0;
    	rep(i,0,n)
    	{
    		if(v[i]>c[i])
    			ans+=v[i]-c[i];
    	}

    	cout<<ans;
    }

}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main(){
  int N;cin>>N;
  int ans=0;
 // vector<int> bene;
  for(int i=0;i<N;i++){
    int V,C;cin>>V>>C;
    if(V>C) ans+=V-C;
  }
//  sort(bene.begin(),bene.end());
 /* for(int i=0;i<N;i++){
    if(bene.at(i)>0) ans+=bene.at(i);
  }*/
  cout<<ans<<endl;
}
//  [c]
//b.c B-Resale
#include<stdio.h>

int main(void){
    int n;
    scanf("%d",&n);
    int v[n],c[n];
    for(int i=0;i<n;++i){
        scanf("%d",v+i);
    }
    for(int i=0;i<n;++i){
        scanf("%d",c+i);
    }

    int x=0,y=0;
    for(int i=0;i<n;++i){
        if(v[i]-c[i]>0){
            x += v[i];
            y += c[i];
        }
    }
    printf("%d\n",x-y);
    return 0;
}
//  [c]
#include <stdio.h>
int main(int argc, char const *argv[]) {
  int N,i,w;
  int V[20],C[20];

  scanf("%d\n",&N );
  for ( i = 0; i < N; i++) {
    scanf("%d ",&V[i] );
  }
  printf("\n" );
  for ( i = 0; i < N; i++) {
    scanf("%d ",&C[i] );
  }

  w = 0;

  for ( i = 0; i < N; i++) {
    if(V[i] - C[i] > 0){
      w = w + (V[i] - C[i]);
    }
  }

  printf("%d\n",w);

  return 0;
}
//  [c]
#include<stdio.h>
int main(){
	int N;
	int a;
	int X_Y=0;
	
	scanf("%d",&N);
	
	int V_C[2][20];
	
	for(int i=0;i<=N-1;i++){
		scanf("%d",&a);
		V_C[0][i]=a;
	}
	
	for(int i=0;i<=N-1;i++){
		scanf("%d",&a);
		V_C[1][i]=a;
	}
	
	for(int i=0;i<=N-1;i++){
		if(V_C[0][i]>V_C[1][i]){
			X_Y+=V_C[0][i]-V_C[1][i];
		}
	}
	
	printf("%d",X_Y);
	return(0);
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define rep(i,n) for(i=0;i<n;i++)
#define ll long long
#define PI 3.14159265358979323846264338327950L
int main(){
    int n,i;
    scanf("%d",&n);
    int c[n],v[n],ans=0;
    rep(i,n) scanf("%d",&v[n]);
    rep(i,n){
        scanf("%d",&c[n]);
        if(v[n]-c[n]>0){
            ans+=v[n]-c[n];
        }
    }
    printf("%d",ans);
    return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define rep(i,n) for(i=0;i<n;i++)
#define ll long long
#define PI 3.14159265358979323846264338327950L
int main(){
    int n,i;
    scanf("%d",&n);
    int c[n],v[n],ans=0;
    rep(i,n) scanf("%d",&v[n]);
    rep(i,n){
        scanf("%d",&c[n]);
        if(v[n]-c[n]>0){
            cost+=v[n]-c[n];
        }
    }
    printf("%d",ans);
    return 0;
}
//  [c]
#include <stdio.h>
int main(void){
    int N, i, X, Y, ans;
    int V[50];
    int C[50];
    
    scanf("%d", &N);
    ans= 0;
    
    for(i = 0; i < N; i++){
        scanf("%d", &V[i]);
        //printf("%d\n", V[i]);
    }
    
    for(i = 0; i < N; i++){
        scanf("%d", &C[i]);
        //printf("%d\n", C[i]);
    }
    
    for(i = 0; i < N; i++){
        if(V[i]>C[i]){
            X = X + V[i];
            //printf("   %d", X);
            Y = Y + C[i];
            //printf("%d\n", Y);
        }
    }
    
    ans = X - Y -1;
    printf("%d", ans);
    
}
//  [javascript]
"use strict";

// read lines from stdin
const input = require("fs")
  .readFileSync("/dev/stdin", "utf8")
  .split("\n");

const N = parseInt(input[0], 10);
const V = input[1].split(" ").map((val) => parseInt(val, 10));
const C = input[2].split(" ").map((val) => parseInt(val, 10));

let ans = 0;

for (let i = 0; i < N; i++) {
  if (V[i] > C[i]) {
    ans += V[i] - C[i];
  }
}

console.log(ans);
//  [javascript]
function Main(stdin){
stdin = stdin.trim().split("\n").reverse();

function input(){return stdin.pop()};
var stdout = [];
function print(x){stdout.push(x)};


var n = parseInt(input());
var v = input().split(" ").map(n=>parseInt(n));
var c = input().split(" ").map(n=>parseInt(n));


var ans = 0;
for (i=0; i < n; i++){
    ans += Math.max(0, v[i]-c[i])
}


print(ans);


stdout = stdout.join("\n");
console.log(stdout);
return stdout
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"))
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
    // 入力を解釈
	input = input.split("\n");
	tmp0 = input[0];
	tmp1Array = input[1].split(" ");
	tmp2Array = input[2].split(" ");
	
	var length = tmp1Array.length;
	var totalValue = 0;
	for(var i = 0 ; i <= length ; i++){
	    var temp = tmp1Array[i] -  tmp2Array[i];
	    
	    if(temp > 0){
	        totalValue += temp;
	    }
	}

    
	
	// 文字を10進数に変換
	// var a = parseInt(input[0], 10);


	//出力
	console.log(totalValue);
}

// var counter = function(str,seq){
//     return str.split(seq).length - 1;
// }

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
	input = input.split("\n");
	var a = input[1].split(" ").map(Number);
	var b = input[2].split(" ").map(Number);
	var sum = 0;
	for(var i=0;i<input.length;i++){
		if((a[i]-b[i])>0) sum+=(a[i]-b[i]);
	}
	console.log(sum);
}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
function Main(input){
	input = input.split("\n");
	var a = input[0].split(" ").map(Number);
	var b = input[1].split(" ").map(Number);
	var sum = 0;
	for(var i=0;i<input.length;i++){
		if(a[0]-b[0]>0) sum+=(a[0]-b[0]);
	}
	console.log(sum);
}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
function Main(stdin){
stdin = stdin.trim().split("\n").reverse();

function input(){return stdin.pop()};
var stdout = [];
function print(x){stdout.push(x)};


var n = parseInt(input());
var v = input().split(" ").map(n=>parseInt(n));
var c = input().split(" ").map(n=>parseInt(n));


var ans = 0;
for (i=0; i < n; i++){
    ans += Math.max(0, v[i]-c[i])
}


print(ans);


stdout = stdout.join("\n");
console.log(stdout);
return stdout
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"))

`
`; var stdin = `
3
10 2 5
6 3 4
5

4
13 21 6 19
11 30 6 15
6

1
1
50
0
`;
//  [go]
package main

import (
	"fmt"
)

func main(){
	var N int
	fmt.Scan(&N)

	var V[20] int
	var C[20] int
	
	for i:=0; i < N; i++ {
		fmt.Scan(&V[i])
	}
	for i:=0; i < N; i++ {
		fmt.Scan(&C[i])
	}
	res := 0
	for i:=0; i < N; i++ {
		if V[i]-C[i] <= 0 {
			continue
		}
		res = res + V[i]-C[i]
	}
	fmt.Println(res)
}
//  [go]
package main

import "fmt"

func main() {
	var n int
	var v, c []int

	fmt.Scan(&n)
	v = make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&v[i])
	}
	c = make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&c[i])
	}

	var res int
	for i, v := range v {
		if v > c[i] {
			res += v - c[i]
		}
	}
	fmt.Println(res)
}
//  [go]
package main

import (
	"fmt"
	"sort"
)

func main() {
	var n int
	fmt.Scan(&n)
	result, v, c := make([]int, n), make([]int, n), make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&v[i])
	}
	for i := 0; i < n; i++ {
		fmt.Scan(&c[i])
	}
	for i := 0; i < n; i++ {
		result[i] = v[i] - c[i]
	}
	sort.Sort(sort.Reverse(sort.IntSlice(result)))
	if n == 1 {
		fmt.Print(0)
	} else {
		fmt.Print(result[0] + result[1])
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

func out(x ...interface{}) {
	fmt.Println(x...)
}

var sc = bufio.NewScanner(os.Stdin)

func getInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func getString() string {
	sc.Scan()
	return sc.Text()
}

// min, max, asub, absなど基本関数
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func asub(a, b int) int {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

func main() {
	sc.Split(bufio.ScanWords)
	N := getInt()
	c := make([]int, N)
	v := make([]int, N)
	for i := 0; i < N; i++ {
		v[i] = getInt()
	}
	for i := 0; i < N; i++ {
		c[i] = getInt()
	}
	n := 1 << uint(N)
	ans := -10001000100
	for i := 0; i < n; i++ {
		C := 0
		V := 0
		for j := 0; j < N; j++ {
			if (i>>j)%2 == 1 {
				C += c[j]
				V += v[j]
			}
		}
		// fmt.Printf("%b %d %d\n", i, V, C)
		ans = max(ans, V-C)
	}
	out(ans)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)

	vs := make([]int, n)
	cs := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&vs[i])
		fmt.Scan(&cs[i])
	}

	r := 0
	for i := 0; i < n; i++ {
		if vs[i] > cs[i] {
			r += vs[i] - cs[i]
		}
	}

	fmt.Print(r)
}
//  [ruby]
_ = gets
v_ary = gets.chomp.split.map(&:to_i)
c_ary = gets.chomp.split.map(&:to_i)
sum = 0

v_ary.length.times do |i|
  if v_ary[i] > c_ary[i]
    sum += v_ary[i] - c_ary[i]
  end
end
puts sum
//  [ruby]
n = gets.split(" ").map(&:to_i)

v = []

v = gets.split(" ").map(&:to_i)

c = []

c = gets.split(" ").map(&:to_i)


v_c = [v,c].transpose.map{|a| a.inject(:-) }

v_c = v_c.sort

sum = 0

v_c.each do |v_c|
  if v_c <= 0
    next
  end
  sum += v_c

end

print sum
//  [ruby]
#
N = gets.chomp.to_i
V = gets.chomp.split.map(&:to_i)
C = gets.chomp.split.map(&:to_i)
sum = 0
(0..(N-1)).each do |i|
  sum = sum + (V[i] - C[i]) if V[i] > C[i]
end
puts sum
//  [ruby]
n=gets.to_i
v=gets.split.map &:to_i
c=gets.split.map &:to_i
max=0
(0..n-1).to_a.combination(2).each do |i|
  sum=0
  sum=(v[i[0]]+v[i[1]])-(c[i[0]]+c[i[1]])
  max=[max,sum].max
end
puts max
//  [ruby]
N = gets.to_i
V_n = gets.split.map(&:to_i)
C_n = gets.split.map(&:to_i)

ans = 0
[0, 1].repeated_permutation(N).to_a.each do |p|
  v = 0
  c = 0
  p.each.with_index do |i, idx|
    v += V_n[idx] if i == 1
    c += C_n[idx] if i == 1
  end
  ans = [ans, v - c].max
end
p ans
//  [ruby]
n = gets.chomp.to_i
v = gets.chomp.split(" ").map(&:to_i)
c = gets.chomp.split(" ").map(&:to_i)
ans = -100000000
["1","0"].repeated_permutation (n) do |i|
    cost = 0
    kati = 0
    sa = 0
    i.each_with_index do |item,j|
        if item == "1"
            cost += c[j]
            kati += v[j]
        end
    end
    sa = kati - cost
    ans = [ans,sa].max
end
puts ans
//  [rust]
#![allow(unused_imports)]
#![allow(dead_code)]
#![macro_use]
use std::io::prelude::*;
use std::cmp::{max, min};
use std::collections::BinaryHeap;

const MOD: i64 = 1e9 as i64 + 7;

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        n: usize,
        v: [i32; n],
        c: [i32; n],
    }
    let ans= v.iter().zip(c.iter()).filter(|&x| x.0 - x.1 > 0).fold(0, |acc, x| acc + x.0 - x.1);
    println!("{}", ans);
}
//  [rust]
//! ----------------------------------------------
//! Framework <https://github.com/vain0x/procon>
//!
//! See the bottom of file for solution.
//! ----------------------------------------------

#![allow(unused_imports)]
#![allow(non_snake_case)]

use std::cell::RefCell;
use std::cmp::{max, min, Ordering};
use std::collections::*;
use std::fmt::{Debug, Display, Formatter, Write as FmtWrite};
use std::io::{stderr, stdin, BufRead, Write};
use std::mem::{replace, swap};
use std::ops::*;
use std::rc::Rc;

/// Print values to standard error if debug mode.
#[allow(unused_macros)]
macro_rules! debug {
    ($($e:expr),*) => {
        #[cfg(debug_assertions)]
        $({
            let (e, mut err) = (stringify!($e), stderr());
            writeln!(err, "\x1B[33m{}\x1B[0m = {:?}", e, $e).unwrap()
        })*
    };
}

/// Read from standard input and parse each word.
/// - `read!(T, U, ..)` parses a line as a tuple of words.
/// - `read![[T]]` parses a line as an array of words.
/// - `read![..; N]` parses `N` lines, using `read!(..)` repeatedly.
#[allow(unused_macros)]
macro_rules! read {
    ([$t:ty] ; $n:expr) =>
        ((0..$n).map(|_| read!([$t])).collect::<Vec<_>>());
    ($($t:ty),+ ; $n:expr) =>
        ((0..$n).map(|_| read!($($t),+)).collect::<Vec<_>>());
    ([$t:ty]) =>
        (rl().split_whitespace().map(|w| w.parse().unwrap()).collect::<Vec<$t>>());
    ($($t:ty),*) => {{
        let buf = rl();
        let mut w = buf.split_whitespace();
        ($(w.next().unwrap().parse::<$t>().unwrap()),*)
    }};
}

/// Read a line from standard input.
#[allow(dead_code)]
fn rl() -> String {
    let mut buf = String::new();
    stdin().read_line(&mut buf).unwrap();

    #[allow(deprecated)]
    buf.trim_right().to_owned()
}

// -----------------------------------------------
// Solution
// -----------------------------------------------

fn main() {
    let N = read!(usize);
    let V = read![[i64]];
    let C = read![[i64]];

    let m = (0..N).map(|i| max(V[i] - C[i], 0)).sum::<i64>();

    println!("{}", m)
}
//  [rust]
#![allow(dead_code, unused_variables, unused_macros, unused_imports)]

// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules! input { (source = $s:expr, $($r:tt)*) => { let mut iter = $s.split_whitespace(); let mut next = || { iter.next().unwrap() }; input_inner!{next, $($r)*} }; ($($r:tt)*) => { let stdin = std::io::stdin(); let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock())); let mut next = move || -> String{ bytes .by_ref() .map(|r|r.unwrap() as char) .skip_while(|c|c.is_whitespace()) .take_while(|c|!c.is_whitespace()) .collect() }; input_inner!{next, $($r)*} }; }
macro_rules! input_inner { ($next:expr) => {}; ($next:expr, ) => {}; ($next:expr, $var:ident : $t:tt $($r:tt)*) => { let $var = read_value!($next, $t); input_inner!{$next $($r)*} }; ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => { let mut $var = read_value!($next, $t); input_inner!{$next $($r)*} }; }
macro_rules! read_value { ($next:expr, ( $($t:tt),* )) => { ( $(read_value!($next, $t)),* ) }; ($next:expr, [ $t:tt ; $len:expr ]) => { (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>() }; ($next:expr, chars) => { read_value!($next, String).chars().collect::<Vec<char>>() }; ($next:expr, usize1) => { read_value!($next, usize) - 1 }; ($next:expr, $t:ty) => { $next().parse::<$t>().expect("Parse error") }; }

fn main() {
    input! {
        n: i32,
        v: [i32; n],
        c: [i32; n],
    }

    let mut ans = 0;
    for (v, c) in v.iter().zip(c.iter()) {
        if v > c {
            ans += v - c;
        }
    }
    println!("{}", ans);
}
//  [rust]
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

use std::cmp::max;

fn main() {
    input! {
        n: u32,
        v: [i32; n],
        c: [i32; n],
    }

    let mut ans = 0;
    for i in 0..1 << v.len() {
        let mut value = 0;
        let mut cost = 0;
        for j in 0..v.len() {
            if (1 << j) & i != 0 {
                value += v.get(j).unwrap();
                cost += c.get(j).unwrap();
            }
        }
        ans = max(ans, value - cost);
        if ans < value - cost {
            ans = value - cost;
        }
        // println!("value: {}, cost: {}", value, cost);
    }
    println!("{}", ans);
}
//  [rust]
use std::io;
use std::cmp;


fn main() {
    let n = read_one::<usize>();
    let vn = read::<isize>();
    let cn = read::<isize>();
    let mut ans = 0;
    for i in 0..1 << n {
        let mut sum: isize = 0;
        for j in 0..1 << (n + 1) {
            if i & (1 << j) != 0 { sum += vn[j] - cn[j]; }
        }
        ans = cmp::max(ans, sum);
    }
    println!("{}", ans);
}


#[allow(dead_code)]
fn read<T>() -> Vec<T>
where T:
std::str::FromStr,
T::Err: std::fmt::Debug {

    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    buf.split_whitespace()
        .map(|s| s.trim().parse().unwrap())
        .collect()
}

#[allow(dead_code)]
fn read_one<T>() -> T
where T:
std::str::FromStr,
T::Err: std::fmt::Debug {

    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    buf.trim().parse().unwrap()
}
//  [rust]
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()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
  let mut s = String::new();
  std::io::stdin().read_line(&mut s).ok();
  s.trim().split_whitespace()
    .map(|e| e.parse().ok().unwrap()).collect()
}
 
fn main() {
  let _: String = read();
  let vs: Vec<i32> = read_vec();
  let cs: Vec<i32> = read_vec();

  let mut p: Vec<i32> = vs.iter().zip(cs.iter())
    .map(|(x, y)| x - y)
    .collect();
  p.sort();
  p.reverse();

  let ans = if p[0] < 0 {
    0
  } else if p.len() <= 1 || p[1] <= 0 {
    p[0]
  } else {
    p[0] + p[1]
  };

  println!("{}", ans);
}
//  [swift]
extension String: CollectionType {}

let a:Int = Int(readLine()!)!
let b: [Int] = readLine()!.split(" ").map { Int($0)! }
let c: [Int] = readLine()!.split(" ").map { Int($0)! }

var d: [Int] = []
for var i = 0; i < a; i += 1 {
  d.append( b[i] - c[i] )
}

var o = 0
for var i = 0; i < a; i += 1 {
  if( d[i] > 0 ) {
  	o += d[i]
  }
}
print(o)
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/



/*************** メインプログラム ***************/

let N = readInt()!
let V = readIntSplit(by: " ")
let C = readIntSplit(by: " ")
var ans = 0
for i in 0..<N {
    ans += max(V[i]-C[i], 0)
}
print(ans)
//  [swift]
let N = Int(readLine()!)!
let V = readLine()!.characters.split(" ").map{Int(String($0))!}
let C = readLine()!.characters.split(" ").map{Int(String($0))!}
print((0..<N).reduce(0){max(V[$1.0]-C[$1.0],0)})
//  [swift]
let N = readInt()!
let V = readLine()!.characters.split(" ").map{Int(String($0))!}
let C = readLine()!.characters.split(" ").map{Int(String($0))!}
print((0..<N).reduce(0){max(V[$1.0]-C[$1.0],0)})
//  [swift]
let N = readInt()!
let V = readIntSplit(by: " ")
let C = readIntSplit(by: " ")
print((0..<N).reduce(0){max(V[$1.0]-C[$1.0],0)})
//  [typescript]
import { readFileSync } from "fs";

function B(count: number, values: number[], costs: number[]) {
    const diff: number[] = [];
    for (let i = 0; i < count; i++) {
        diff.push(values[i] - costs[i]);
    }
    return diff
        .filter(v => {
            return v > 0;
        })
        .reduce((r, c) => {
            return r + c;
        }, 0);
}

const inputB = readFileSync("/dev/stdin", "utf8");
const changeInputB = inputB.split(/\r?\n/).map((v, i) => {
    if (i == 0) return Number(v);
    return v.split(" ").map(Number);
});
console.log(B(changeInputB[0] as number, changeInputB[1] as number[], changeInputB[2] as number[])
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const _n = stdin.split('\n')[0]
const n = Number(_n)

const v = stdin
  .split('\n')[1]
  .split(' ')
  .map(Number)
const c = stdin
  .split('\n')[2]
  .split(' ')
  .map(Number)

let x = 0
let y = 0
const diff = v.map((e, i) => {
  if (e - c[i] > 0) {
    x += e
    y += c[i]
  }
  return e - c[i]
})

const res = x - y

console.log(res)
//  [typescript]
"use strict";

class Main {
  public static main(input: string[]): void {
    
        let result = 0;
    const value = input[1].split(/\s/).map(Number);
    const cost = input[2].split(/\s/).map(Number);
    const length = value.length;
    for (let i = 0; i < length; i++) {
      let benefit = value[i] - cost[i];
      if (benefit > 0) {
        result += benefit;
      }
    }

    console.log(result);
  }
}

Main.main(
  require("fs")
    .readFileSync("/dev/stdin", "utf8")
    .split(/\n/)
);
//  [typescript]
((input: string): void => {
    const [_, v, c]: number[][] = input.trim().split(/\n/).map(
        v => v.split(" ").map(Number)
    );
    const hoge = v.map( (v, i) => v - c[i] ).filter(v => v > 0)
    console.log(hoge.reduce( (a, b) => a+b ));
})(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
const main = (input: string) => {
  const lines = input.trim().split("\n").slice(1)
  const V = lines[0].split(" ").map(str => parseInt(str))
  const C = lines[1].split(" ").map(str => parseInt(str))
  const N = V.length;
  let sumOfV = V.reduce((a, x) => a += x, 0)
  let sumOfC = C.reduce((a, x) => a += x, 0)
  let X: number[] = [];
  let Y: number[] = [];
  let result: number[] = [];
  let answer;
 
  for (let i = 0; i < N; i++) {
    X.push(V[i])
    Y.push(C[i])
    for (let j = i + 1; j < N; j++) {
      X.push(V[i] + V[j])
      Y.push(C[i] + C[j])
    }
  }
  X.push(sumOfV);
  Y.push(sumOfC);
 
  for (let i = 0; i < X.length; i++) {
    result.push(X[i] - Y[i])
  }
 
  resultMax = Math.max.apply(null, result);
  answer = resultMax > 0 ? resultMax : 0

  console.log(answer);
}
 
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const main = (input: string) => {
  const lines = input.trim().split("\n").slice(1)
  const V = lines[0].split(" ").map(str => parseInt(str))
  const C = lines[1].split(" ").map(str => parseInt(str))
  const N = V.length;
  let sumOfV = V.reduce((a, x) => a += x, 0)
  let sumOfC = C.reduce((a, x) => a += x, 0)
  let X: number[] = [];
  let Y: number[] = [];
  let result: number[] = [];
  let answer;

  for (let i = 0; i < N; i++) {
    X.push(V[i])
    Y.push(C[i])
    for (let j = i + 1; j < N; j++) {
      X.push(V[i] + V[j])
      Y.push(C[i] + C[j])
    }
  }
  X.push(sumOfV);
  Y.push(sumOfC);

  for (let i = 0; i < X.length; i++) {
    result.push(X[i] - Y[i])
  }

  answer = Math.max.apply(null, result) >= 0 ? result : 0

  console.log(answer);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
K = input()

if K == 'ABC':
    print('ARC')
else:
    print('ABC')
//  [python]
s = input()

if (s == 'ABC'):
    print('ARC')
else:
    print('ABC')
//  [python]
S = input()

if 'B' in S:
    print('ARC')
else:
    print('ABC')
//  [python]
s = input()

if s == "ABC" :
  print("ARC")

else :
  print("ARC")
//  [python]
S = input()
print("ARC") if S=="ABC" else print("ARC")
//  [python]
s = input()
print("ABC" if s == "ARC" else "ABC")
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.TreeSet;

import javax.swing.*;

import static java.util.Arrays.binarySearch;
import static java.util.Arrays.copyOfRange;
import static java.util.Arrays.sort;

public class Main {

    public static void main(String[] args) throws Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;

        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);

        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }
}

class Task {

    private static int mod = 998244353;


    public void solve(int testNumber, InputReader in, PrintWriter out) {
        String s = in.next();
        if (s.equals("ABC")) {
            out.println("ARC");
        } else {
            out.println("ABC");
        }
    }



}

class InputReader {

    private final BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(nextLine());
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }

}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        }else{
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
    private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
    private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
    public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    public long nextLong() {
        if (!hasNext()) throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while(true){
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            }else if(b == -1 || !isPrintableChar(b)){
                return minus ? -n : n;
            }else{
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
        return (int) nl;
    }
    public double nextDouble() { return Double.parseDouble(next());}
}

public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		FastScanner fs = new FastScanner();
		String S = fs.next();
		if(S.equals("ABC")) System.out.println("ARC");
		else System.out.println("ABC");
	}

}
//  [java]
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String input = in.nextLine();
        String s = "ABC" , t = "ARC";

        if (input == s) {
            System.out.println("ARC");
        } else {
            System.out.println("ABC");
        }
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;

public class Main {
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new java.io.InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        
        String S = br.readLine();
        
        if(S.equals("ABC"))) {
            pw.println("ARC");
        } else {
            pw.println("ABC");
        }

        br.close();
        pw.close();
    }
}
//  [java]
public class Main {
  public static void main(String[] args) {
    String S = new java.util.Scanner(System.in).nextText();
    switch (S) {
      case "ABC":
       System.out.println("ARC");
       break;
      case "ARC":
       System.out.println("ABC");
       break;
    }
  }
}
//  [cpp]
#include<stdio.h>
int main(){
	int i;
    char a, b, c;
    scanf("%c%c%c", &a, &b, &c);	
	if(a == 'A' && b == 'B' && c == 'C'){
	    printf("ARC");
   	}
	else if(a == 'A' && b == 'R' && c == 'C') {
	    printf("ABC");
    }
	return 0;
}
//  [cpp]
#include <stdio.h>
char a[5];
int main(){
    scanf("%s", a);
    if(a[1] == 'B' ) printf("ARC\n");
    else if(a[1] == 'R') printf("ABC\n");
    return 0;
}
//  [cpp]
#pragma GCC optimize("Ofast")
#include<stdio.h>
#include<algorithm>
using namespace std;
char str[5];
int main(){
	scanf(" %s",str);
	if(str[1]=='B')
		str[1]='R';
	else
		str[1]='B';
	puts(str);
}
//  [cpp]
#include <iostream>
#include <string>
using namespace std;

int main(){
  string s;
  if(s=="ABC"){
    cout << "ARC";
  }
  else{
    cout << "ABC";
  }
}
//  [cpp]
#include <iostream>
#include <string>
using namespace std;

int main(){
  string N;
  cin >> N;
  if(N = "ABC"){
    cout << "ARC";
  }
  else{
    cout << "ABC";
  }
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
string S; 
int main() {
cin >>S;
if (S =="ABC"){
   cout <<"ARC"<<endl;
}
if (S == "ARC"){
   cout << "ABC" << endl;
}
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

int main(void){
char s[10];scanf("%s",s);

if(strcmp(s,"ABC")==0){printf("ARC");}
else{printf("ABC\n");}

}
//  [c]
#include <stdio.h>

int main(void){
	char c[4];
  	scanf("%s",c);
  	if(c[1]=='B'){
    	printf("ARC\n");
    }else{
    	printf("ABC\n");
    }
}
//  [c]
#include <stdio.h>
#include<string.h>

int main()
{
 
  char s[4];
  
  scanf("%s",s);
  
  if(strcmp(s,"ABC")==0)
  {
    printf("ARC\n");
  }
  else
  {
    printf("ABC\n");
  }
  return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
int main(void)
{
	char S[3],B[] = "ABC",R[] = "ARC";
	scanf("%s",S);
	if(strcmp(S,B) == 0){
		printf("ARC");
	}else{
		printf("ABC");
	}
	return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
int main(void)
{
	char S[3],B[] = "ABC",R[] = "ARC";
	scanf("%s",S);
	if(strcmp(S,B) == 0){
		printf("ARC");
	}else if(strcmp(S,R) == 0){
		printf("ABC");
	}
	return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
int main(void)
{
	char S[3],B[] = ABC,R[] = ARC;
	scanf("%s",S);
	if(strcmp(S,B) == 0){
		printf("ARC");
	}else if(strcmp(S,R) == 0){
		printf("ABC");
	}
	return 0;
}
//  [javascript]
function Main(input) {
    tmp = input.split("\n");
    s = tmp[0];

    if (s === "ABC") {
        console.log("ARC");
        
    } else if(s === "ARC"){
        console.log("ABC");
    }

}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
  input = input.split("");
  let ans = "ARC";
  if(input[1] === "R"){
    ans = "ABC" ;
  }
  console.log(ans);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
    // 1行目がinput[0], 2行目がinput[1], …に入る
    input = input.trim();
    var N = input;
    if (N == 'ABC') {
        console.log('ARC');
        
    } else {
        console.log('ABC');
        
    }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {

  console.log(input === 'ABC' ? 'ARC' : 'ABC');
    
}

// デバッグ用
function debug() {
  var input = document.getElementById("input").value;
  Main(input);
}

//* この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
    input=input.split("\n");  //ここまで必須
    if (input=="ABC"){console.log("ARC")} else{console.log("ABC")}
}
Main(require("fs").readFileSync("/dev/stdin","utf8"));
//  [javascript]
function Main(input) {
    input = input.split("\n");
    const str = input[0];

    let message = '';

if (str == 'ARC') {
    message = 'ABC';
} else if (str == 'ABC') {
    message = 'ARC';
}


    console.log(message);
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var s string
	fmt.Scan(&s)
	
	if s == "ABC" {
		fmt.Println("ARC")
	} else {
		fmt.Println("ABC")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var s, contest string
	fmt.Scan(&s)
	if s == "ABC" {
		contest = "ARC"
	} else if s == "ARC" {
		contest = "ABC"
	}
	fmt.Printf("%s", contest)
}
//  [go]
package main

import "fmt"

func main() {
	var lastContest string
	fmt.Scan(&lastContest)

	if lastContest == "ABC" {
		fmt.Println("ARC")
	} else {
		fmt.Println("ABC")
	}
}
//  [go]
package main

import "fmt"


func main() {
	var s string
	fmt.Sprintf("%s", &s)
	if s == "ABC" {
		fmt.Println("ARC")
	} else {
		fmt.Println("ABC")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var s string
	fmt.Sprintf("%s", &s)
	if s == "ABC" {
		fmt.Print("ARC")
	} else {
		fmt.Print("ABC")
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var s string
	fmt.Scan(&s)
	fmt.Println(s)
}
//  [ruby]
contest = gets.chomp!
if contest.eql?("ABC")
	puts "ARC"
else
  puts "ABC"
end
//  [ruby]
puts gets.chomp=="ABC"?"ARC":"ABC"
//  [ruby]
if readline.chomp == "ARC"
  puts "ABC"
else
  puts "ARC"
end
//  [ruby]
s=gets.chomp
if s==
//  [ruby]
S = gets.to_s
if S == "ABC"
  puts "ARC"
else
  puts "ABC"
end
//  [ruby]
s=gets.chomp
if s=="ABC"
  p "ARC"
else
  p "ABC"
end
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {
        s: String,
    }

    let ans = if s == "ABC" { "ARC" } else { "ABC" };

    println!("{}", ans);
}
//  [rust]
fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());

    let s: String = sc.read();
    let ans = if s == "ABC" { "ARC" } else { "ABC" };
    println!["{}", ans];
}

pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> IO<R, W> {
        IO(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: ToString>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.to_string().as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main(){

    input!{
        s: chars,
    }

    let ss: String = s.into_iter().collect();

    if ss=="ARC" {
        println!("ABC");
    } else if ss=="ABC" {
        println!("ARC");
    } else {
        return;
    }

    return;
}
//  [rust]
fn main() {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    if s == "ABC" {
        println!("ARC");
    } else {
        println!("ABC");
    }
}
//  [rust]
use std::io::{stdin, Read};
 
fn main() {
    let mut buffer = String::new();
    let mut stdin = stdin();
 
    stdin.read_to_string(&mut buffer).unwrap();
    match &*buffer {
        "ABC" => println!("ARC"),
        "ARC" => println!("ABC"),
        _ => println!(""),
    }
}
//  [rust]
use competitive::prelude::*;

fn main() {
  input!{
    S: String,
  }
  println!("{}", if &*S=="ABC" { "ARC" } else {"ABC"} )
}
//  [swift]
func main() {
    let input = readLine()!
    if input == "ARC" {
        print("ABC")
    } else {
        print("ARC")
    }
}

main()
//  [swift]
let s = readLine()!

if s == "ABC" {
  print("ARC")
} else {
  print("ABC")
}
//  [swift]
print(readLine()! == "ARC" ? "ABC" : "ARC")
//  [swift]
import Foundation
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ") //ブランクで区切られている場合

let S = readLine()!
 
if S == "ABC" {
    print("ARC")
} else {
    print("ABC")
}
//  [swift]
import Foundation
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ") //ブランクで区切られている場合

let String = "S"
if ("S"=="ABC"){
    print("ARC")
}else if ("S"=="ARC"){
    print("ABC")
}
//  [swift]
import Foundation
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ") //ブランクで区切られている場合

var String = "S"
if ("S"=="ABC"){
    print("ARC")
}else if ("S"=="ARC"){
    print("ABC")
}
//  [typescript]
import * as fs from "fs";

const input:string = fs.readFileSync("/dev/stdin", "utf8").trim();
const result: string = input === 'ABC' ? 'ARC' : 'ABC';
console.log(result);
//  [typescript]
"use strict";
const Main = (input) =>{
   let xs = input.trim().split(' ');
   if(xs[0]=='ARC'){
     console.log('ABC');
   }else{
     console.log('ARC');
   }
}
Main(require('fs').readFileSync('/dev/stdin','utf8'));
//  [typescript]
import * as fs from 'fs'
import {debug} from '../../../util'

const input = fs.readFileSync('/dev/stdin', 'utf8').trim()
const output = (x: any) => console.log(x)
// debug(input)
const S = input
S === 'ABC' ? output('ARC') : output('ABC')
//  [typescript]
import * as fs from 'fs'
import {debug} from '../../../util'

const input = fs.readFileSync('/dev/stdin', 'utf8')
const output = (x: any) => console.log(x)
const S = input
S === 'ABC' ? output('ARC') : output('ABC')
//  [typescript]
import * as fs from 'fs'

const input = fs.readFileSync('/dev/stdin', 'utf8')

input.trim()

switch (input) {
    case 'ABC':
        console.log('ARC')
        break
    case 'ARC':
        console.log('ABC')
        break
}