jiahuimbzuai/CoQuIR huggingface dataset:
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
  input = input.split("\n");
  var inputNum = Number(input[0]);
  var tmpAll = [];
  for(var i=1; i <= inputNum; i++){
    var tmp = input[i].split(" ");
    tmpAll.push(tmp);
  }
  var array = tmpAll;

  // ソート
  array.sort(function(a, b){
    return a[1]- b[1];
  });

  var result = 'Yes';
  var sumA = 0;

  for(var j=0; j < inputNum; j++){
    sumA = sumA + Number(array[j][0]);
    if(sumA > Number(array[j][1])){
      result = 'No';
      break;
    }
  }
  console.log(result);
 }
 //*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
 Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"fmt"
	"sort"
)

type work struct {
	a, b int
}

type byB []work

func (bb byB) Len() int           { return len(bb) }
func (bb byB) Swap(i, j int)      { bb[i], bb[j] = bb[j], bb[i] }
func (bb byB) Less(i, j int) bool { return bb[i].b < bb[j].b }

func main() {
	var n int
	fmt.Scan(&n)
	ws := make([]work, n)
	for i := range ws {
		fmt.Scan(&ws[i].a, &ws[i].b)
	}

	sort.Sort(byB(ws))
	now := 0
	for _, w := range ws {
		now += w.a
		if now > w.b {
			fmt.Println("No")
			return
		}
	}
	fmt.Println("Yes")
}
//  [go]
package main

import (
	"fmt"
	"math"
	"sort"
)

func abs(a int) int {
	return int(math.Abs(float64(a)))
}

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

type task struct {
	time int
	end int
}

type tasks []task

func (t tasks) Len() int {return len(t)}
func (t tasks) Swap(i,j int) { t[i], t[j]=t[j], t[i] }
func (t tasks) Less(i,j int) bool { return t[i].end < t[j].end }

func main() {
	var n, t1, t2 int
	fmt.Scan(&n)
	s := make([]task, n)

	for i:=0; i<n; i++ {
		fmt.Scan(&t1, &t2)
		s[i] = task{time: t1, end: t2}
	}

	sort.Sort(tasks(s))
	total := 0

	for i:=0; i<n; i++ {
		total += s[i].time
		if total > s[i].end {
			fmt.Println("No")
			return
		}
	}
	fmt.Println("Yes")
}
//  [go]
package main

import (
	"fmt"
	"sort"
)

type task struct {
	a int
	b int
}

type byB []task

func (a byB) Len() int           { return len(a) }
func (a byB) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a byB) Less(i, j int) bool { return a[i].b < a[j].b }

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

	tasks := make([]task, n)
	for i := range tasks {
		fmt.Scan(&tasks[i].a, &tasks[i].b)
	}

	sort.Sort(byB(tasks))

	sum := 0
	ans := "Yes"
	for _, task := range tasks {
		sum += task.a
		if sum > task.b {
			ans = "No"
			break
		}
	}

	fmt.Println(ans)
}
//  [ruby]
N=gets.to_i
ABS=N.times.map {gets.split.map(&:to_i)}

ABS = ABS.sort
ABS = ABS.sort {|a,b| a[1] <=> b[1]}

time=0
flag=0
ABS.each do |ab|
  time+=ab[0]
  flag = 1 if time > ab[1]
end

if flag == 1
  puts "No"
else
  puts "Yes"
end
//  [ruby]
# 整数の入力
n = gets.to_i

works = []

# スペース区切りの整数の入力
for num in 1..n
    b,c=gets.chomp.split(" ").map(&:to_i);
    works.push([b,c])
end

works.sort_by! {|x| [x[1],x[0]]}

time = 0
time_over = false
for work in works
    time += work[0]
    if time > work[1]
        time_over = true
        print("No")
        exit
    end
end
print("Yes")
//  [ruby]
n = gets.chomp.to_i
hash = {}
n.times do
  a,b = gets.chomp.split(' ').map(&:to_i)
  hash[b] ? hash[b] += a : hash[b] = a
end

memo = 0
hash.sort.each do |arr|
  memo += arr[1]
  if (memo > arr[0])
    puts 'No'
    exit
  end
end
puts 'Yes'
//  [rust]
#[allow(dead_code)]
fn main() {
    let n = i::u();
    let mut ab = i::uv2(n);
    ab.sort_by_key(|a| a.1);
    let mut k = 0;
    for i in 0..n {
        let (a, b) = ab[i];
        k += a;
        if k > b {
            println!("{}", "No");
            return;
        }
    }
    println!("{}", "Yes");
}

#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::io::*;
#[allow(unused_imports)]
use std::num::*;
#[allow(unused_imports)]
use std::str::*;

#[allow(dead_code)]
mod i {
    use super::*;

    pub fn read<T: FromStr>() -> T {
        stdin()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>()
            .parse::<T>()
            .ok()
            .unwrap()
    }

    pub fn str() -> String {
        read()
    }

    pub fn s() -> Vec<char> {
        str().chars().collect()
    }

    pub fn i() -> i64 {
        read()
    }

    pub fn u() -> usize {
        read()
    }

    pub fn u2() -> (usize, usize) {
        (read(), read())
    }

    pub fn u3() -> (usize, usize, usize) {
        (read(), read(), read())
    }

    pub fn f() -> f64 {
        read()
    }

    pub fn c() -> char {
        read::<String>().pop().unwrap()
    }

    pub fn iv(n: usize) -> Vec<i64> {
        (0..n).map(|_| i()).collect()
    }

    pub fn iv2(n: usize) -> Vec<(i64, i64)> {
        (0..n).map(|_| iv(2)).map(|a| (a[0], a[1])).collect()
    }

    pub fn uv(n: usize) -> Vec<usize> {
        (0..n).map(|_| u()).collect()
    }

    pub fn uv2(n: usize) -> Vec<(usize, usize)> {
        (0..n).map(|_| uv(2)).map(|a| (a[0], a[1])).collect()
    }

    pub fn uv3(n: usize) -> Vec<(usize, usize, usize)> {
        (0..n).map(|_| uv(3)).map(|a| (a[0], a[1], a[2])).collect()
    }

    pub fn fv(n: usize) -> Vec<f64> {
        (0..n).map(|_| f()).collect()
    }

    pub fn cmap(h: usize) -> Vec<Vec<char>> {
        (0..h).map(|_| s()).collect()
    }
}
//  [rust]
use std::io::*;
use std::str::FromStr;
use std::collections::BTreeMap;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n: i32 = read();
    let mut b_sum: u64 = 0;

    let mut mp: BTreeMap<u64,u64> = BTreeMap::new();

    for _ in 0..n {
        let a:u64 = read();
        let b:u64 = read();

        if mp.contains_key(&b) {
           let tmp = mp.get_mut(&b).unwrap();
           *tmp = *tmp + a;
        } else {
            mp.insert(b, a);
        }
    }

    for (k, v) in &mp {
        b_sum += *v;
        if b_sum > *k {
            println!("No");
            return;
        }
    }

    println!("Yes");
    return;
}
//  [swift]
let N = Int(readLine()!)!
var tasks = [(Int, Int)]()
for _ in 0..<N {
    let input = readLine()!.characters.split(" ").map{Int(String($0))!}
    tasks += [(input[0], input[1])]
}
tasks.sortInPlace{$0.1<$1.1}
var ans = "Yes"
var time = 0
for AB in tasks {
    time += AB.0
    if time > AB.1 {
        ans = "No"
        break
    }
}
print(ans)
//  [python]
s1, s2, s3 = input().split()

print(s1[0].upper() + s2[0].upper() + s3[0].upper())
//  [python]
s = raw_input().split()
print ''.join([w[0] for w in s]).upper()
//  [python]
print ''.join([w[0] for w in raw_input().split()]).upper()
//  [java]
import java.util.Scanner;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

	private static final int N = 3;

	public static void main(String[] args) {
		try (Scanner scanner = new Scanner(System.in)) {
			System.out.println(IntStream.range(0, N).mapToObj(i -> scanner.next().substring(0, 1).toUpperCase())
					.collect(Collectors.joining()));
		}
	}
}
//  [java]
import java.util.Arrays;
import java.util.Scanner;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String[] s = new String[3];
        for (int i = 0; i < s.length; ++i) {
            s[i] = sc.next();
        }

        System.out.println(solve(s));

        sc.close();
    }

    static String solve(String[] s) {
        return Arrays.stream(s).map(si -> String.valueOf(Character.toUpperCase(si.charAt(0))))
                .collect(Collectors.joining());
    }
}
//  [java]

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.util.stream.IntStream;

public class Main {

	public static void main(String[] args) throws IOException {
		new Main().solve();
	}

	private void solve() throws IOException {
		try {
			solveA();
			// solveB();
			// solveC();
			// solveD();
			// solveE();
			// solveF();
		} finally {
			if (in != null) {
				in.close();
			}
			if (out != null) {
				out.flush();
				out.close();
			}
		}

	}

	private void solveA() {
		StringBuilder builder = new StringBuilder();
		IntStream.range(0, 3).forEach(i -> builder.append(next().charAt(0)));
		out.println(builder.toString().toUpperCase());
	}

	private void solveB() {
		int numN = nextInt();

		out.println("");
	}

	private void solveC() {
		int numN = nextInt();

		out.println("");
	}

	private void solveD() {
		int numN = nextInt();

		out.println("");
	}

	private void solveE() {
		int numN = nextInt();

		out.println("");
	}

	private void solveF() {
		int numN = nextInt();

		out.println("");
	}

	private final PrintWriter out = new PrintWriter(System.out);
	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;
	}

	private void skipUnprintable() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
	}

	public boolean hasNext() {
		skipUnprintable();
		return hasNextByte();
	}

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

	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();
		}
	}
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define irep(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define ireps(i, m, n) for (int i = (int)(m); i <= (int)(n); ++i)
#define FOR(e, c) for (auto &e : c)
#define SORT(v, n) sort(v, v + n);
#define vsort(v) sort(v.begin(), v.end());
#define rvisort(v) sort(v.begin(), v.end(), greater<int>());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
 
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vs = vector<string>;
using vd = vector<double>;
using ul = unsigned long;
 
template<class T, class C> void chmax(T& a, C b){ a>b?:a=b; }
template<class T, class C> void chmin(T& a, C b){ a<b?:a=b; }
 
const int mod=1e9+7;
 
struct mint {
  ll x;
  mint(ll x=0):x(x%mod){}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += mod-a.x) >= mod) x -= mod;
    return *this;
  }
  mint& operator*=(const mint a) {
    (x *= a.x) %= mod;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res+=a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res-=a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res*=a;
  }
};
 
mint c[4005][4005];
void init() {
  c[0][0] = 1;
  for (int i = 0; i <= 4000; i++) {
    for (int j = 0; j <= i; j++) {
      c[i+1][j] += c[i][j];
      c[i+1][j+1] += c[i][j];
    }
  }
}
mint comb(int n, int k) {
  return c[n][k];
}
 
bool IsPrime(int num)
{
    if (num < 2) return false;
    else if (num == 2) return true;
    else if (num % 2 == 0) return false;
 
    double sqrtNum = sqrt(num);
    for (int i = 3; i <= sqrtNum; i += 2)
    {
        if (num % i == 0)
        {
            return false;
        }
    }
 
    return true;
}
 
map<ll, ll> primeFact(ll n) {
  map<ll, ll> res;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      res[i]++;
      n /= i;
    }
  }
  if (n != 1) res[n]++;
  return res;
}
 
void printv(vi& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
void printv(vll& v){
  rep(i,v.size()) cout << v[i] << " ";
  cout << endl;
}
int vtotal(vi& v){
  int total=0;
  rep(i,v.size()) total+=v[i];
  return total;
}
 
int main()
{
  //init(); // mint初期化
  cin.tie( 0 );
  ios::sync_with_stdio( false );
  
  string a,b,c;cin>>a>>b>>c;
  string ans=a.substr(0,1)+b[0]+c[0];
  transform(ans.begin(),ans.end(),ans.begin(),::toupper);
  cout(ans);
  
  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main(){
	vector<string> s(3);
	for(int i=0; i<3; i++){
		cin >> s.at(i);
	}
	string ans;
	string sam="abcdefghijklmnopqrstuvwxyz";
	string res="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	for(int i=0; i<3; i++){
		for(int j=0; j<26; j++){
			if(s.at(i).at(0)==sam.at(j)) ans+=res.at(j);
		}
	}
	cout << ans << endl;
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

#define ll long long
#define pb push_back
#define vi vector<int>
#define bn(n) (n).begin(), (n).end()
#define FOR(n) for(int i = 0; i < (int)n; i++)


void solve() {
    string a, b, c;
    cin >> a >> b >> c;
    string ans;
    ans += toupper(a[0]);
    ans += toupper(b[0]);
    ans += toupper(c[0]);
    cout << ans << "\n";
}

int main () {
    ios::sync_with_stdio(0);
    cin.tie(0);

    int t = 1, i = 1;
    //cin >> t;
    while(t--) {
        //cout << "Case #" << i << ": ";
        solve();
        //i++;
    }
    return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>

int main(void){

    char s1[16], s2[16], s3[16];

    scanf("%s%s%s", s1, s2, s3);

    printf("%c%c%c\n", s1[0]+'A'-'a', s2[0]+'A'-'a', s3[0]+'A'-'a');

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

int main()
{
    char S1[10], S2[10], S3[10];
    scanf("%s %s %s",&S1, &S2, &S3);

    S1[0]=S1[0]-32;
    S2[0]=S2[0]-32;
    S3[0]=S3[0]-32;

    printf("%c%c%c", S1[0], S2[0], S3[0]);

    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    char s1[10],s2[10],s3[10],temp,temp2,temp3;
    scanf("%s %s %s",&s1,&s2,&s3);
    temp=s1[0];
    temp=temp-32;
    temp2=s2[0];
    temp2=temp2-32;
    temp3=s3[0];
    temp3=temp3-32;
    printf("%c%c%c\n",temp,temp2,temp3);
    return 0;

}
//  [javascript]
function main (s) {
    s=s.split(" ");
	console.log((s[0][0]+s[1][0]+s[2][0]).toUpperCase());
}
 
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input){
  input = input.split(' ');
  var a = input[0];
  var b = input[1];
  var c = input[2];

  var result = [];

  function upper(x) {
      var upper_x = x.toUpperCase();
      upper_x = upper_x.split('');
      return upper_x;
  }

  result.push(upper(a).shift());
  result.push(upper(b).shift());
  result.push(upper(c).shift());
  console.log(result.join(''));

}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  input = input.trim();
  const [a,b,c] = input.split(" ");
  let x = a.slice(0,1).toUpperCase() + b.slice(0,1).toUpperCase() + c.slice(0,1).toUpperCase();
  console.log(x);
 
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

/*　入力方法
１、簡単に書く
fmt.Scan
2,たくさん読む()
bufio.Scanner
(テキストを1行ずつ読み込む。fileからscannerを生成し、scan()が末尾に達してfalseを返すまで読み込む。Text()を呼ぶことで文字列として取り出すことができる)
3,長い行を読む
bufio.ReadLine
4, スペース区切りのデータを読み込む
sc.Split(bufio.ScanWords)
#########バッファの最大読み込みの数を変更するには
sc.Buffer(buf,MaxBuf)#MAXBUFのところにサイズをしていする
*/

/* 書き込み
１、接頭辞F（前）
書き込み先を指定できる
2,接頭辞S(前)
出力ではなくフォーマットした結果を文字列で返す
3,接頭辞 f（後ろ）
フォーマット（文字列型など）を指定することができる
４、接頭辞 ln（後ろ）
オペランドの間に半角スペースが入り、文字列の最後に開業が追加

・interface{}型
どのような型がくるかわからないときに演算はできないが全ての型を受ける
new(T)
任意の型

*/
/*
フォーマット文字列
%c 1文字を出力　　　%d　　整数を10進む
%s 文字列を出力

指定子	対応する型	説明	使用例
%c	char	１文字を出力する
%s	char *	文字列を出力する
%d	int, short	整数を10進で出力する
%u	unsigned int, unsigned short	符号なし整数を10進で出力する
%o	int, short,unsigned int, unsigned short	整数を8進で出力する
%x	int, short,unsigned int, unsigned short	整数を16進で出力する
%f	float	実数を出力する
%e	float	実数を指数表示で出力する
%g	float	実数を最適な形式で出力する
%ld	long	倍精度整数を10進で出力する
%lu	unsigned long	符号なし倍精度整数を10進で出力する
%lo	long, unsigned long	倍精度整数を8進で出力する
%lx	long, unsigned long	倍精度整数を16進で出力する
%lf	double	倍精度実数を出力する
*/
/*
文字
*/
const (
	initialBufSize = 100000
	maxBufSize     = 10000000
)

var (
	sc = bufio.NewScanner(os.Stdin)
	wt = bufio.NewWriter(os.Stdout)
)

func next() string {
	sc.Scan()
	return sc.Text()

}

func putf(format string, a ...interface{}) {
	fmt.Fprintf(wt, format, a...)
}

func puts(a ...interface{}) {
	fmt.Fprintln(wt, a...)
}

/*strings.Splitで入力したものを分ける*/
func Scanner() []string {
	var s string
	if sc.Scan() {
		s = sc.Text()
	}
	slice := strings.Split(s, " ")
	return slice

}

/*"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""*/
func main() {
	var a, b, c string
	fmt.Scan(&a, &b, &c)
	fmt.Println(strings.ToUpper(string(a[0])) + strings.ToUpper(string(b[0])) + strings.ToUpper(string(c[0])))
}
//  [go]
package main

import (
	"fmt"
	"strings"
)

func main() {
	// Code for A - Three-letter acronym
	var s1, s2, s3 string
	fmt.Scanf("%s %s %s", &s1, &s2, &s3)

	fmt.Println(strings.ToUpper(s1[0:1]) + strings.ToUpper(s2[0:1]) + strings.ToUpper(s3[0:1]))
}
//  [go]
package main

import (
	"fmt"
	"strings"
)

func main() {
	var s1, s2, s3 string
	fmt.Scan(&s1, &s2, &s3)

	fmt.Println(strings.ToUpper(string(s1[0]) + string(s2[0]) + string(s3[0])))
}
//  [ruby]
s1, s2, s3 = gets.chomp.split.map(&:to_s)

s = s1[0] + s2[0] + s3[0]

puts s.upcase
//  [ruby]
a, b, c = gets.split.map(&:to_s)
puts a[0].upcase + b[0].upcase + c[0].upcase
//  [ruby]
S = gets.chomp.split
puts "#{S[0][0]}#{S[1][0]}#{S[2][0]}".upcase
//  [rust]
use std::io::Read;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();

    let answer = solve(&buf);

    println!("{}", answer);
}

fn solve(input: &str) -> String {
    let mut iterator = input.split_whitespace();

    let s1 = iterator.next().unwrap().to_uppercase().chars().next().unwrap();
    let s2 = iterator.next().unwrap().to_uppercase().chars().next().unwrap();
    let s3 = iterator.next().unwrap().to_uppercase().chars().next().unwrap();

    return format!("{}{}{}", s1, s2, s3);
}
//  [rust]
use proconio::input;

fn main() {
	input!(s1: String);
	input!(s2: String);
	input!(s3: String);

	println!("{}{}{}",
		s1.to_uppercase().chars().nth(0).unwrap(),
		s2.to_uppercase().chars().nth(0).unwrap(),
		s3.to_uppercase().chars().nth(0).unwrap()
	);
}
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const [s1, s2, s3] = input[0];

  return `${s1[0]}${s2[0]}${s3[0]}`.toUpperCase();
};

console.log(main(read()));
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [s1, s2, s3] = stdin.split('\n')[0].split(' ')

const concat = s1[0] + s2[0] + s3[0]

console.log(concat.toUpperCase())
//  [typescript]
var input: string = require('fs').readFileSync('/dev/stdin', 'utf8');
var inputLines: string[] = input.trim().split("\n");
var parts = inputLines[0].split(" ");

var f = parts[0].toUpperCase().charAt(0);
var s = parts[1].toUpperCase().charAt(0);
var t = parts[2].toUpperCase().charAt(0);
console.log(f + s + t);
//  [python]
"""
author : halo2halo
date : 24, Jan, 2020
"""

import sys

# import itertools
# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

A = int(readline())
S = set(readline().decode().split())

print('Four' if len(S) == 4 else 'Three')
//  [python]
input()
s = set(input().split())

print("Four" if len(s) == 4 else "Three")
//  [python]
a = int(input())
b = list(input().split())
count = b.count('Y')
if count == 0:
    print('Three')
else:
    print('Four')
//  [python]
import numpy as np
import scipy as sp

N = int(input())
S = [a for a in input().split()]

a = set(S)

if len(a) == 3:
    print('Three')
else:
    print('Four')
//  [python]
n = raw_input()
sis = set(raw_input().split())
print 'Four' if 'Y' in sis else 'Three'
//  [python]
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**15
mod = 10**9+7

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)


def main():
    n = I()
    c = collections.Counter(S().split())

    if len(c) == 3:
        return 'Three'
    return 'Four'


print(main())
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Main {
	public static void main(String args[]) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		Solver solver = new Solver();
		solver.init();
		solver.readHead(in.readLine());
		// for (; solver.hasNext();) {
		solver.readBody(in.readLine());
		// }
		// solver.solve();
	}
}

class Solver {
	int N;
	int cnt;

	public void init() {
		N = 0;
		cnt = 0;
	}

	public void readHead(String str) {
		String[] strArr = str.split(" ");
		N = Integer.parseInt(strArr[0]);
		// System.out.println(N);
	}

	public boolean hasNext() {
		return cnt < N;
	}

	public void readBody(String str) {
		// System.out.println(str);
		String[] strArr = str.split(" ");
		for (int i = 0; i < N; i++) {
			if ("Y".equals(strArr[i])) {
				System.out.println("Four");
				return;
			}
		}
		System.out.println("Three");
		cnt++;
	}

	public void solve() {

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

public class Main {

	public static void main(String[] args) {

		FastScanner sc = new FastScanner();
		int N = sc.nextInt();
		String[] S = new String[N];
		for (int i = 0; i < N; i++)
			S[i] = sc.next();

		for (int i = 0; i < N; i++) {
			if (S[i].equals("Y")) {
				System.out.println("Four");
				return;
			}
		}
		System.out.println("Three");

	}
	//以下、自作ライブラリ

	//最大公約数
	public static long gcd(long a, long b) {
		if (a < b)
			return gcd(b, a);
		long c = 0;
		c = a % b;
		if (c == 0)
			return b;
		return gcd(b, c);
	}

	//最小公倍数
	public static long lcm(long m, long n) {
		return m * n / gcd(m, n);
	}

	//素数判定
	public static boolean isPrime(int n) {
		if (n < 2)
			return false;
		if (n == 2)
			return true;
		if (n % 2 == 0)
			return false;

		for (int i = 3; i * i <= n; i += 2) {
			if (n % i == 0)
				return false;
		}
		return true;
	}
}

//以下、高速スキャナークラス
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());
	}
}
//  [java]
import java.util.*;

public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Map<String,Integer> count = new HashMap<>();

        for (int i = 0; i < n ; i++) {
            String s = sc.next();
            count.put(s,1);
        }

        final int sum = count.values().stream().mapToInt(Integer::intValue).sum();
        if(sum==3){
            System.out.print("Three");
        }else if (sum==4){
            System.out.print("Four");
        }
    }
}
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author ZYCSwing
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskB {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            Set<Character> set = new HashSet<>();

            int n = in.nextInt();
            String ch;
            for (int i = 0; i < n; ++i) {
                ch = in.next();
                set.add(ch.charAt(0));
            }

            out.println(set.size() == 3 ? "Three" : "Four");
        }

    }
}
//  [java]

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		Scanner sc = new Scanner(System.in);
		int n=sc.nextInt();
		String[] s = new String[n];
		boolean hanbetsu = false;
		for(int i=0;i<n;i++) {
			s[i]=sc.next();
			if(s[i].equals("Y")) {
				hanbetsu = true;
				break;
			}
		}
		if(hanbetsu)
			System.out.print("Four");
			else
			System.out.print("Three");


	}

}
//  [cpp]
#include<cstdio>
int n,s[11];
int main()
{
	scanf("%d",&n);
	for (int i=1;i<=n;i++)
	{
		scanf("%s",s);
		if (s[0]=='Y')
		{
			printf("Four");
			return 0;
		}
	}
	printf("Three");
}
//  [cpp]
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>


int main(void)
{
	int n,k=0;
	char s;
	int i;
	scanf("%d",&n);
	for(i=1;i<=n;i++){scanf("%c",&s);if(s=='Y'){k=1;}}
	
	
	
	
	
	if(k==1){printf("Four\n");}else{printf("Three\n");}
	
	return 0;
}
//  [cpp]
#include <stdio.h>

int N;
char S;

int main(void) {
  
  scanf("%d\n", &N);
  for(int i = 0; i < N ; ++i) {
    scanf("%c ", &S);
    if(S == 'Y') { printf("Four"); return 0; }
  }
  printf("Three");  
  return 0;
}
//  [cpp]
#include <iostream>
#include <string>
#include <vector>
#include <cmath>

using namespace std;


int main() {
	int n;
	cin >> n;

	char cur;
	for (int i=0;i<n;i++) {
		cin >> cur;
		if (cur == 'Y') {
			cout << "Four" << endl;
			goto four;
		}
	}
	
	cout << "Three" << endl;

four:;

	return 0;
}
//  [cpp]
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;

void solve_A(); void solve_B(); void solve_C(); void solve_D();

int main(void) {
	cin.tie(0); ios::sync_with_stdio(false);
    /*
     solve_A();
     //*/
    
    //*
     solve_B();
     //*/
    
    
    /*
     solve_C();
     //*/
    
    /*
    solve_D();
     //*/
	return 0;
}

void solve_A(){
    ll N; cin >> N;
    cout << N/3 << endl;
}

void solve_B(){
    ll N; cin >> N;
    vector<char> S(N);
    for(auto &in:S) cin >> in;
    bool f1,f2,f3,f4;
    f1 = f2 = f3 = f4 = false;
    for(int i = 0; i < N;i++){
        if(S[i] == 'P') f1 = true;
        if(S[i] == 'W') f2 = true;
        if(S[i] == 'G') f3 = true;
        if(S[i] == 'Y') f4 = true;
    }
    if(f4){
        cout << "Four" << endl;
    }else{
        cout << "Three" << endl;
    }
}

void solve_C(){
    
}

void solve_D(){
    
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

int main() {
	int n;
	cin >> n;
	for (int i=0;i < n;i++) {
		string s;
		cin >> s;
		if (s == "Y") {
			cout << "Four";
			return 0;
		}
	}
	cout << "Three";
	return 0;
}
//  [c]
#include<stdio.h>

int main()
{
    int n,p=0,w=0,g=0,y=0,i;
    scanf("%d",&n);
    char A[n];
    for(i=0;i<n;i++){
        scanf("%s",&A[i]);
        if(A[i]=='P') p++;
        if(A[i]=='W') w++;
        if(A[i]=='G') g++;
        if(A[i]=='Y') y++;
    }
    if(p&&w&&g&&y)
        printf("Four\n");
    else
        printf("Three\n");
}
//  [c]
#include <stdio.h>
int main(void){
    int N;
    char s[N];
    scanf("%d", &N);
    for (int i = 0; i < N; i++){
        scanf("%c", &s[i]);
    }

    int tmp = 0;
    for (int i = 0; i < N; i++){
        if (s[i] == 'Y'){
            tmp += 1;
        }
    }
    if (tmp == 0){
        printf("%s\n", "Three");
    }
    else {
        printf("%s\n", "Four");
    }

    return 0;
}
//  [c]
#include <stdio.h>
int main(void){

    int n;
  	char c;
    scanf("%d",&n);
  	for(int i= 0;i<n;i++){
      	scanf(" %c",&c);
  		if(c == 'Y') {printf("Four"); return 0;}
    }
  
    printf("Three");
  
    return 0;
}
//  [c]
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int main(void)
{
	int n;
	char buffer[1000];
	int i;
	short kind = 3;

	fgets(buffer, sizeof(buffer), stdin);
	fgets(buffer, sizeof(buffer), stdin);

	n = strlen(buffer);
	for (i = 0; i < n; ++i){
		if (buffer[i] == 'Y'){
			kind = 4;
		}
	}
	if (kind == 3){
		printf("Three\n");
	}
	else if (kind == 4){
		printf("Four\n");
	}
	return 0;
}
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>
#include<math.h>
#include<ctype.h>

#define MOD 1e7+7
typedef long long ll;

ll mygcd(ll a, ll b) { if (b == 0) return a; return mygcd(b, a % b); }

ll mylcm(ll a, ll b) { return a / mygcd(a, b) * b; }

ll mymax(ll a, ll b) { return (a > b) ? a : b; }

ll mymin(ll a, ll b) { return (a < b) ? a : b; }

ll myasc(const void* a, const void* b) { return *(ll*)a - *(ll*)b; }

ll mydsc(const void* a, const void* b) { return *(ll*)b - *(ll*)a; }

bool flag;
ll n ;
char s[101];

int main() {
	scanf("%lld", &n);
	for (int i=0;i<n;i++) scanf("%c",&s[i]);
	for (int i = 0; i < n; i++) {
		if (s[i] == 'Y') {
			printf("Four");
			return 0;
		}
	}
	printf("Three");

	return 0;
}
//  [c]
#include<stdio.h>
int main(){
  int i,n;
  char a;
  scanf("%d ",&n);
  for(i=0;i<n;i++){scanf("%c",&a);getchar();if(a=='Y'){printf("Four");return 0;}}
  printf("Three");
}
//  [javascript]
function myout(text){console.log(text);}//standard output
function Main(input) {
	//input = parseInt(input);
	//input = input.trim().split(" ");
	input = input.trim().split("\n");
	//input = input.trim().split(" ").map((a)=>Number(a));
	//input = input.trim().split("\n").map((a)=>Number(a));
  var list = input[1].split(" ");
  if(list.indexOf("Y") != -1){
     myout("Four");
     }else{
       myout("Three");
     }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
function Main(input){
  input  = input.split('\n');
  var arare = input[1].slice(' ');

  if(arare.indexOf('Y') != -1)
    console.log('Four');
  else
    console.log('Three');
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	var line = input.split("\n");
	var N = Number(line[0]);
	var S = line[1].split(" ");
	var ans = "Three"
  	for(var i = 0; i < N; i++){
    	if(S[i] === "Y") ans ="Four";
    }
	console.log(ans);
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
  var inp = input.trim().split('\n');
  var N = parseInt(inp[0].trim());
  var S = inp[1].split(' ');

  var answer = 'Three';
  for(var i = 0; i < S.length; i++){
    if (S[i] === 'Y'){
      answer = 'Four';
    }
  }
  console.log(answer);
}
Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
run (function * (write, gets) {
	var n = parseInt(yield, 10);

	for (var i=0; i<n; ++i) {
		if ('Y' === (yield)) {
			write("Four");
			return;
		}
	}

	write("Three");
});

/**
 * @param {(write: (line: string, end?: string) => void, gets: () => IterableIterator<string|null>) => IterableIterator<any>} main 
 */
function run (main) {
	var istream = process.stdin;
	var ostream = process.stdout;

	/**
	 * @type {[string|null]}
	 */
	var words = [];
	/**
	 * @type {[string]}
	 */
	var lines = [];
	var rest = "";
	var ended = false;
	var INPUT_MODE_LINE = 0;
	var INPUT_MODE_WORD = 1;
	var input_mode = INPUT_MODE_WORD;

	/**
	 * @param {string} line 
	 * @param {string} [end] 
	 */
	function write (line, end) {
		ostream.write(line + (undefined === end ? os.EOL : end));
	}
	function *gets () {
		if (0 < lines.length) {
			return lines.shift();
		} else {
			input_mode = INPUT_MODE_LINE;
			/**
			 * @type {string}
			 */
			var line = yield;
			input_mode = INPUT_MODE_WORD;
			return line;
		}
	}

	var main_itr = main(write, gets);

	/**
	 * @param {string|null} chunk 
	 */
	function get_chunk (chunk) {
		istream.pause();
		if (null === chunk) {
			lines.push(null);
		} else {
			rest += chunk;
			var line_exp = /.*(\r?\n|\r)/g;
			var line_match, lastIndex = 0;
			while (null !== (line_match = line_exp.exec(rest))) {
				lastIndex = line_exp.lastIndex;
				lines.push(line_match[0]);
			}
			rest = rest.substring(lastIndex);
		}
		loop();
	}

	function loop () {
		while (0 < lines.length) {
			switch (input_mode) {
				case INPUT_MODE_LINE:
				{
					words.push(lines.shift());
				}
				break;
				case INPUT_MODE_WORD:
				{
					if (null === lines[0]) {
						words.push(lines.shift());
					} else {
						var word_exp = /[^\s]+/g;
						var line_match;
						if (null !== (line_match = word_exp.exec(lines[0]))) {
							words.push(line_match[0]);
							lines[0] = lines[0].substring(word_exp.lastIndex);
						} else {
							lines.shift();
						}
					}
				}
				break;
			}

			while (0 < words.length) {
				var result = main_itr.next(words.shift());
				if (undefined !== result.value) {
					if ('string' === typeof result.value) {
						write(result.value, "");
					} else {
						write(`${result.value}`, "");
					}
				}
				if (result.done) return;
			}
		}

		ended ? setTimeout(get_chunk, 0, null) : process.stdin.resume();
	}
	istream.on('data', get_chunk);
	istream.on('end', function () {
		ended = true;
		get_chunk(null);
	});

	istream.setEncoding('utf8');
	get_chunk(null);
};

var os = require('os');
//  [javascript]
"use strict";

function main(input) {
  input = input.split(/\n/);
  const n = input[0];
  input = input[1].split(" ");

  let ans = "Three";
  for (let v in input) {
    if (input[v] == "Y") {
      ans = "Four";
      break;
    }
  }

  console.log(ans);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"fmt"
)

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

	m := make(map[string]bool, n)

	var x string
	for i := 0; i < n; i++ {
		fmt.Scan(&x)
		m[x] = true
	}

	if len(m) == 3{
		fmt.Println("Three")
	} else {
		fmt.Println("Four")
	}
}
//  [go]
package main

import (
	"fmt"
)

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

	m := make(map[string]bool, n)

	var x string
	for i := 0; i < n; i++ {
		fmt.Scan(&x)
		m[x] = true
	}

	c := 0
	for _, v := range m {
		if v {
			c++
		}
	}

	if c == 3{
		fmt.Println("Three")
	} else {
		fmt.Println("Four")
	}
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer([]byte{}, math.MaxInt64)
}

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

func readInt() int {
	sc.Scan()
	r, _ := strconv.Atoi(sc.Text())
	return r
}

func main() {
	n := readInt()
	m := make(map[string]int)
	for i := 0; i < n; i++ {
		m[readString()]++
	}
	len := len(m)
	switch len {
	case 3:
		fmt.Println("Three")
	case 4:
		fmt.Println("Four")
	}
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func iScan() int {
	n, _ := strconv.Atoi(Scan())
	return n
}

func fScan() float64 {
	n, _ := strconv.ParseFloat(Scan(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func SScan(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scan()
	}
	return a
}
func iSScan(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = iScan()
	}
	return a
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func sum(a []int) int {
	x := 0
	for _, v := range a {
		x += v
	}
	return x
}

var mod int = 1000000007

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	n := iScan()
	ans := make(map[string]struct{})
	for i := 0; i < n; i++ {
		ans[Scan()] = struct{}{}
	}
	if len(ans) == 4 {
		fmt.Println("Four")
	} else {
		fmt.Println("Three")
	}
}
//  [go]
package main

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

func main() {
	scanInit()

	n := nextInt()
	m := map[string]int{}

	for i := 0; i < n; i++ {
		m[nextStr()]++
	}

	if len(m) == 3 {
		fmt.Println("Three")
	} else {
		fmt.Println("Four")
	}

}

// ---- readfunc
var sc = bufio.NewScanner(os.Stdin)

func scanInit() {
	const cap = 200 * 1024 // default=64*1024
	var buf = make([]byte, cap)
	sc.Buffer(buf, cap)
	sc.Split(bufio.ScanWords)
	return
}
func nextInt() int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return i
}
func nextStr() string {
	sc.Scan()
	return sc.Text()
}
//  [go]
package main

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

func main() {
	io, flush := NewIO()
	defer flush()

	n := io.ScanInt()
	snacks := io.ScanStrings(n)
	snackExistMap := map[string]bool{}
	for _, s := range snacks {
		snackExistMap[s] = true
	}
	
	if len(snackExistMap) == 3 {
		fmt.Println("Three")
	} else {
		fmt.Println("Four")
	}
}

type IO struct {
	scanner *bufio.Scanner
	writer  *bufio.Writer
}

func NewIO() (*IO, func()) {
	io := &IO{
		scanner: newScanner(),
		writer:  newWriter(),
	}
	return io, func() { io.writer.Flush() }
}

func newScanner() *bufio.Scanner {
	s := bufio.NewScanner(os.Stdin)
	s.Buffer(make([]byte, 10000000), 10000000)
	s.Split(bufio.ScanWords)
	return s
}

func newWriter() *bufio.Writer {
	return bufio.NewWriter(os.Stdout)
}

func (io *IO) ScanBytes() []byte {
	if !io.scanner.Scan() {
		panic("scan string failed")
	}
	return io.scanner.Bytes()
}

func (io *IO) ScanString() string {
	if !io.scanner.Scan() {
		panic("scan string failed")
	}
	return io.scanner.Text()
}

func (io *IO) ScanStrings(n int) []string {
	strs := make([]string, n)
	for i := 0; i < n; i++ {
		strs[i] = io.ScanString()
	}
	return strs
}

func (io *IO) Scan2DStrings(y, x int) [][]string {
	strings := make([][]string, y)
	for i := 0; i < y; i++ {
		strings[i] = io.ScanStrings(x)
	}
	return strings
}

func (io *IO) Scan2DGraph(y int) [][]string {
	strs := make([][]string, y)
	for i := 0; i < y; i++ {
		strs[i] = strings.Split(io.ScanString(), "")
	}
	return strs
}

func (io *IO) ScanInt() int {
	return int(io.ScanInt64())
}

func (io *IO) ScanInt2() (int, int) {
	return int(io.ScanInt64()), int(io.ScanInt64())
}

func (io *IO) ScanInt3() (int, int, int) {
	return int(io.ScanInt64()), int(io.ScanInt64()), int(io.ScanInt64())
}

func (io *IO) ScanInt4() (int, int, int, int) {
	return int(io.ScanInt64()), int(io.ScanInt64()), int(io.ScanInt64()), int(io.ScanInt64())
}

func (io *IO) ScanInts(n int) []int {
	ints := make([]int, n)
	for i := 0; i < n; i++ {
		ints[i] = io.ScanInt()
	}
	return ints
}

func (io *IO) Scan2DInts(y, x int) [][]int {
	ints := make([][]int, y)
	for i := 0; i < y; i++ {
		ints[i] = io.ScanInts(x)
	}
	return ints
}

func (io *IO) ScanInt64() int64 {
	i, err := strconv.ParseInt(io.ScanString(), 10, 64)
	if err != nil {
		panic(err)
	}
	return i
}

func (io *IO) ScanFloat64() float64 {
	i, _ := strconv.ParseFloat(io.ScanString(), 64)
	return i
}

func (io *IO) ScanFloat64s(n int) []float64 {
	floats := make([]float64, n)
	for i := 0; i < n; i++ {
		floats[i] = io.ScanFloat64()
	}
	return floats
}

func (io *IO) Println(a ...interface{}) {
	fmt.Fprintln(io.writer, a...)
}
//  [ruby]
n = gets.to_i
s = gets.split
puts s.uniq.size == 3 ? :Three : :Four
//  [ruby]
def get_i() #空白区切の入力を数値(整数)の配列で返す
  return gets.chomp.split(" ").map(&:to_i)
end
def get_f() #空白区切の入力を数値(実数)の配列で返す
  return gets.chomp.split(" ").map(&:to_f)
end
def get() #空白区切の入力を文字列の配列で返す
  return gets.chomp.split(" ")
end
def get_nsp() #入力されたものを一文字ずつに区切った文字列の配列で返す
  return gets.chomp.split("")
end
def yn_judge(bool,y="Yes",n="No") #boolに真偽を投げることで、trueならy、falseならnの値を出力する
  return bool ? y : n 
end
def array(size1,init=nil,size2=1) #size2に二次元配列時の最初の要素数、size1に次の配列の大きさ、initに初期値を投げることでその配列を返す
  if size2==1
    return Array.new(size1){init}
  else
    return Array.new(size2){Array.new(size1){init}}
  end
end

N=gets.to_i
S=get.uniq!
puts yn_judge(S.size==4,"Four","Three")
//  [ruby]
n = gets.to_i
s = gets.chomp.split
cnt = 0
cl = Hash.new(0)
s.each{|c| cl[c] += 1}
cl.each{|v| cnt += 1}
(cnt == 3) ? (puts "Three"):(puts "Four")
//  [ruby]
require 'prime'
require 'set'
require 'tsort'
include Math
ALP = ('a'..'z').to_a
INF = 0xffffffffffffffff
def max(a,b);              a > b ? a : b                              end
def min(a,b);              a < b ?  a : b                             end
def swap(a,b);             a, b = b, a                                end
def gif;                   gets.to_i                                  end
def gff;                   gets.to_f                                  end
def gsf;                   gets.chomp                                 end
def gi;                    gets.split.map(&:to_i)                     end
def gf;                    gets.split.map(&:to_f)                     end
def gs;                    gets.chomp.split.map(&:to_s)               end
def gc;                    gets.chomp.split('')                       end
def pr(num);               num.prime_division                         end
def pr?(num);              Prime.prime?(num)                          end
def digit(num);            num.to_s.length                            end
def array(s,ini=nil);      Array.new(s){ini}                          end
def darray(s1,s2,ini=nil); Array.new(s1){Array.new(s2){ini}}          end
def rep(num);              num.times{|i|yield(i)}                     end
def repl(st,en,n=1);       st.step(en,n){|i|yield(i)}                 end

n = gif
puts gs.uniq.size == 4 ? 'Four' : 'Three'
//  [ruby]
require 'pp'

N,d=gets.chomp.split(' ').map{|n| n.to_i}
S=gets.chomp.split(' ').map{|n| n}

if(S.any?{|s| s=="Y"})
	puts "Four"
else
	puts "Three"
end
//  [ruby]
puts`dd`[?Y]?:Four: :Three
//  [rust]
#[allow(dead_code)]
fn is_whitespace(c: &char) -> bool {
    c.is_whitespace()
}

#[allow(dead_code)]
fn is_eol(c: &char) -> bool {
    ['\r', '\n'].contains(c)
}

#[allow(unused_macros)]
macro_rules! input {
    ($var:ident, $($r:tt)*) => {
        input_inner!{$var, $($r)*}
    };

    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        #[allow(unused_mut, unused_variables, bare_trait_objects)]
        let mut next = move |f: &Fn(&char)->bool| -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|f(&c))
                .take_while(|c|!f(&c))
                .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)*}
    };

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $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 ; eol ]) => {
        $next(&is_eol).split(' ').map(|x| x.parse::<$t>().unwrap()).collect::<Vec<_>>()
    };

    ($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, bytes) => {
        read_value!($next, String).into_bytes()
    };

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

    ($next:expr, parser) => {
        $next
    };

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

#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{BinaryHeap, HashMap, HashSet};

#[allow(dead_code)]
struct Edge {
    from: usize,
    to: usize,
}

#[allow(dead_code)]
type Graph = Vec<Vec<usize>>;
#[allow(dead_code)]
const M: usize = 1_000_000_007;

fn main() {
    input! {
        n: usize,
        mut s: [chars; n],
    }

    s.sort();
    s.dedup();
    println!("{}", if s.len() == 4 { "Four" } else { "Three" });
}