#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x)  cerr << #x << " = " << (x) << endl;

class boolean;
template<typename T> class Value;
template<typename T> void out(T a);

class boolean{
	bool b;
	public:
	boolean() { }
	boolean(bool b) : b(b) { }

	void operator = (const bool b){
		this->b = b;
	}

	boolean And(boolean a){ return b and a.get(); };
	boolean Or(boolean a){ return b or a.get(); };
	boolean Xor(boolean a){ return b xor a.get(); };

	template<typename X> Value<X> ter(X x, X y){ return b ? x : y; };

	bool get(){ return b; }
	void out(std::string f = "Yes", std::string s = "No"){
		std::cout << (b ? f : s) << std::endl;
	}
};

template<typename T>
class BaseType{
	protected:
		T value;
	public:
		BaseType() { }
		BaseType(T value) : value(value) { }

		bool operator < (const Value<T> &right ) const {
			return value < right.value;
		}
		bool operator > ( Value<T> &right ) const {
			return value > right.value;
		}

		T get(){ return value; }
		void set(T v){ value = v; }

		void out(){ std::cout << value << std::endl; };
};

template<typename T>
class Value : public BaseType<T>{
	public:
		Value() {}
		Value(T value) : BaseType<T>(value) { }

		Value<T> add(Value<T> a){ return Value<T>(this->get() + a.get()); }
		Value<T> sub(Value<T> a){ return Value<T>(this->get() - a.get()); }
		Value<T> pro(Value<T> a){ return Value<T>(this->get() * a.get()); }
		Value<T> div(Value<T> a){ return Value<T>(this->get() / a.get()); }
		Value<T> mod(Value<T> a){ return Value<T>(this->get() % a.get()); }

		Value<T> sqrt(){
			for(int i = 1; i * i <= this->get(); i++){
				if(i * i == this->get()) return i;
			}
			return -1;
		}
		Value<T> abs(){ return std::abs(this->get()); }

		boolean eq(Value<T> a){ return this->get() == a.get(); }
		boolean neq(Value<T> a){ return this->get() != a.get(); }
		boolean gt(Value<T> a){ return this->get() > a.get(); }
		boolean gtq(Value<T> a){ return this->get() >= a.get(); }
		boolean lt(Value<T> a){ return this->get() < a.get(); }
		boolean ltq(Value<T> a){ return this->get() <= a.get(); }

		boolean even(){ return this->get() % 2 == 0; }
		boolean odd(){ return this->get() % 2 == 1; }

		Value<T> max(Value<T> a){ return this->get() < a.get() ? a : *this; }
		Value<T> min(Value<T> a){ return this->get() < a.get() ? *this : a; }

};

class String : public BaseType<std::string>{
	String() { }
	String(std::string str) : BaseType<std::string>(str) { }
	public:
	String add(String a){ return String(this->value + a.get()); }

	boolean eq(String a){ return this->value == a.get(); }
	boolean neq(String a){ return this->value != a.get(); }
	boolean seq(String a){
		std::set<char> x, y;
		for(auto i : this->value) x.emplace(i);
		for(auto i : a.get()) y.emplace(i);
		return x == y;
	}

	auto begin(){ return this->value.begin(); }
	auto end(){ return this->value.end(); }
};


/* output */
template<typename T>
std::ostream& operator << (std::ostream& os, Value<T> t){
	os << t.get();
	return os;
}
template<typename T> void out(T a){
	std::cout << a << std::endl;
}
template<typename T> void out(std::vector<T> a, bool space = true){
	rep(i,a.size()){
		out(a[i]);
		out(i + 1 == a.size() ? "\n" : (space ? " " : ""));
	}
}
template<typename T> void out(std::vector<std::vector<Value<T>>>& v){
	rep(i,v.size()){
		out(v[i]);
	}
}

/* 多重vector */
template <typename X, typename T>
auto vectors(X x, T a) {
	return std::vector<T>(x, a);
}

template <typename X, typename Y, typename Z, typename... Zs>
auto vectors(X x, Y y, Z z, Zs... zs) {
	auto cont = vectors(y, z, zs...);
	return std::vector<decltype(cont)>(x, cont);
}

/* input */
template<typename T>
std::istream& operator >> (std::istream& is, Value<T>& t){
	T res;
	is >> res;
	t.set(res);
	return is;
}
std::istream& operator >> (std::istream& is, String& t){
	std::string res;
	is >> res;
	t.set(res);
	return is;
}

template<typename T> T in(){
	T res;
	std::cin >> res;
	return res;
}
template<typename T> std::vector<T> in(int n){
	std::vector<T> res(n);
	rep(i,n) res[i] = in<T>();
	return res;
}
template<typename T> std::vector<std::vector<T>> in(int h, int w){
	std::vector<std::vector<T>> res(h);
	rep(i,h) res[i] = in<T>(w);
	return res;
}
template<typename T> std::set<T> inSet(int n){
	std::set<T> res;
	rep(i,n) res.emplace(in<T>());
	return res;
}

struct Type{
	using T = int;
	static constexpr int Number(){ return 1; }
};

typedef typename Type::T S;
typedef Value<S> V;
typedef std::vector<V> Vec;

void solve(){
	V n = in<V>();
	V(static_cast<int>(inSet<char>(n.get()).size())).eq(3).out("Three", "Four");
}


int main(){
	solve();
}


Measured memory_bytes: 256