Go: package main

import "fmt"

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

func max3(a, b, c int) int {
	return max(max(a, b), c)
}

func main() {
	var (
		a, b, c int
		ch      byte
	)
	fmt.Scanln(&a, &b, &c)
	m := max3(a, b, c)
	switch m {
	case a:
		ch = 'A'
	case b:
		ch = 'B'
	case c:
		ch = 'C'
	}
	fmt.Printf("%c\n", ch)
}

C++: #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
signed main() {
  ios::sync_with_stdio(false); cin.tie(0);
  int a, b, c;
  cin >> a >> b >> c;
  int mx = max({a, b, c});
  if (mx == a) cout << "A" << endl;
  if (mx == b) cout << "B" << endl;
  if (mx == c) cout << "C" << endl;
  return 0;	
}

C++: #include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
//#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
　　　　　　　　　　　 ∧＿∧  
　　　　　 ∧＿∧ 　（´<_｀ ）　 Welcome to My Coding Space!
　　　　 （ ´_ゝ`）　/　 ⌒i     
　　　　／　　　＼　 　 |　|     
　　　 /　　 /￣￣￣￣/　　|  
　 ＿_(__ﾆつ/　    ＿/ .| .|＿＿＿＿  
　 　　　＼/＿＿＿＿/　（u　⊃  
---------------------------------------------------------------------------------------------------*/














int A, B, C;
//---------------------------------------------------------------------------------------------------
void _main() {
    cin >> A >> B >> C;

    int ma = max(A, max(B, C));

    if (ma == A) printf("A\n");
    if (ma == B) printf("B\n");
    if (ma == C) printf("C\n");
}

C++: #include <iostream>
#include <bitset>
#include <fstream>
#include <string>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <algorithm>
#include <numeric>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <functional>
#include <cctype>
#include <list>
#include <limits>
//#include <boost/multiprecision/cpp_int.hpp>

const double EPS = (1e-10);


using namespace std;
using Int = long long;
//using namespace boost::multiprecision;

const Int MOD = 1000000007;

const int MAXN = 1000000;
Int fact[MAXN], inv[MAXN];

Int mod_pow(Int x, Int n) {
    Int res = 1;
    while(n > 0) {
        if(n & 1) res = (res * x) % MOD; //ビット演算(最下位ビットが1のとき)
        x = (x * x) % MOD;
        n >>= 1; //右シフト(n = n >> 1)
    }
    return res;
}

void init_fact() {
    fact[0] = 1;
    for(int i=1; i<MAXN; i++) {
        fact[i] = (fact[i-1] * i) % MOD;
    }

    inv[MAXN - 1] = mod_pow(fact[MAXN - 1], MOD-2);
    for(int i=MAXN - 2; i>=0; i--) {
        inv[i] = (inv[i+1] * (i+1)) % MOD;
    }
}

Int comb(int n, int r) {
    if(r < 0 || n < r) return 0;
    return fact[n] * inv[n-r] % MOD * inv[r] % MOD;
}

template<typename T>
T gcd(T a, T b) {
    return b != 0 ? gcd(b, a % b) : a;
}

template<typename T>
T lcm(T a, T b) {
    return a * b / gcd(a, b);
}

char s[100005];
char st;
void rec(char a, char b){
    if (a == 'T' && b == 'F') st = 'F';
    else st = 'T';
}
int field[10][10];
vector<int> ans;

int rec(int a, int b, int c, int d){
    int cnt = 0;
    for (int i = a; i <= c; i++){
        for (int j = b; j <= d; j++){
            if (field[i][j]){
                cnt++;
            }
        }
    }
    ans.push_back(cnt);
    return 0;
}
int a[10];

int main(){
    cin.tie(0);

    int ma = -1;
    for (int i = 0; i < 3; i++){
        cin >> a[i];
        ma = max(a[i], ma);
    }
    for (int i = 0; i < 3; i++){
        if (ma == a[i]){
            cout << (char)('A' + i) << endl;
            return 0;
        }
    }

}

C++: #include <bits/stdc++.h>
using LL = long long;
const LL MOD = 1e9+9;
using namespace std;



int main(){
    int A,B,C;cin >> A >> B >> C;
    if(max({A,B,C}) == A){
        cout<<"A"<<endl;
        return 0;
    }
    if(max({A,B,C}) == B){
        cout<<"B"<<endl;
        return 0;
    }
    if(max({A,B,C}) == C){
        cout<<"C"<<endl;
    }
}

C++: #include <iostream>
#include <string>
#include <vector>
using namespace std;

int a, b, c;
int main() {
    while (cin >> a >> b >> c) {
        if (a > b && a > c) cout << "A" << endl;
        else if (b > a && b > c) cout << "B" << endl;
        else cout << "C" << endl;
    }
}

C++: /*  -*- coding: utf-8 -*-
 *
 * 3051.cc: 
 */

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int N = 3;

/* typedef */

/* global variables */

/* subroutines */

/* main */

int main() {
  int as[N];
  for (int i = 0; i < N; i++) scanf("%d", as + i);

  int maxa = as[0], maxi = 0;
  for (int i = 1; i < N; i++)
    if (maxa < as[i]) maxa = as[i], maxi = i;

  printf("%c\n", 'A' + maxi);
  return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}

//INSERT ABOVE HERE
signed main(){
  int x,y,z;
  cin>>x>>y>>z;
  int v=max({x,y,z});
  if(v==x) cout<<"A"<<endl;
  if(v==y) cout<<"B"<<endl;
  if(v==z) cout<<"C"<<endl;
  return 0;
}

C++: #include <bits/stdc++.h>
#define int long long
#define pii pair<int,int>
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(c) (c).begin(),(c).end()
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
#define MINF(a) memset(a,0x3f,sizeof(a))
#define POW(n) (1LL<<(n))
#define IN(i,a,b) (a <= i && i <= b)
using namespace std;
template <typename T> inline bool CHMIN(T& a,T b) { if(a>b) { a=b; return 1; } return 0; }
template <typename T> inline bool CHMAX(T& a,T b) { if(a<b) { a=b; return 1; } return 0; }
template <typename T> inline void SORT(T& a) { sort(ALL(a)); }
template <typename T> inline void REV(T& a) { reverse(ALL(a)); }
template <typename T> inline void UNI(T& a) { sort(ALL(a)); a.erase(unique(ALL(a)),a.end()); }
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f3f3f3f3f;
const double EPS = 1e-10;
/* ---------------------------------------------------------------------------------------------------- */

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(false);
  cout << fixed << setprecision(10);

  vector<pair<int,char>> v(3);
  REP(i,3) {
    cin >> v[i].first;
    v[i].second = i+'A';
  }
  SORT(v);
  cout << v[2].second << endl;

  return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <map>
#include <queue>
#include <iomanip>
#define MOD 1000000007
typedef long long ll;
using namespace std;

int main(){
  int a,b,c;
  cin>>a>>b>>c;
  
  int ma=max(a,max(b,c));
  if(ma==a) cout<<"A"<<endl;
  else if(ma==b) cout<<"B"<<endl;
  else cout<<"C"<<endl;

  return 0;
}

C++: #include <bits/stdc++.h>
int main(){
	int a,b,c;
	std::cin>>a>>b>>c;
	if(a>b&&a>c)puts("A");
	if(b>a&&b>c)puts("B");
	if(c>b&&c>a)puts("C");
}

C++: #include<iostream>
using namespace std;
int main() {
	int a, b, c;
	cin >> a >> b >> c;
	if (a > b && a > c){
		cout << "A";
		}
	if (b > c && b > a) {
		cout << "B";
	}
	if (c > a && c > b) {
		cout << "C";
	}
	cout << endl;
}