Language: C++

#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;
using namespace std;

class boolean;
template<typename T> class Value;

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(string f = "Yes", string s = "No"){
		cout << (b ? f : s) << endl;
	}
};

template<typename T>
class Value{
	T value;

	public:

	Value() { }
	Value(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;
	}

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

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

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

	boolean even(){ return value % 2 == 0; }
	boolean odd(){ return value % 2 == 1; }

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

	T get(){ return value; }
	set<char> getSet(){ return std::set<char>(begin(), end()); }
	void set(T v){ value = v; }

	auto begin(){ return value.begin(); }
	auto end(){ return value.end(); }

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

class String{
	private:
		string str;
	public:
	String() { }
	String(string str) : str(str) { }

	bool operator < (const String &right ) const {
		return str < right.str;
	}
	bool operator > (const String &right ) const {
		return str > right.str;
	}

	String add(String a){ return str + a.get(); }

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

	string get(){ return str; }
	void set(string s){ str = s; }

	auto begin(){ return str.begin(); }
	auto end(){ return str.end(); }

	void out(){ cout << str << endl; };
};


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

/* 多重vector */
template <typename X, typename T>
auto vectors(X x, T a) {
	return 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 vector<decltype(cont)>(x, cont);
}

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

template<typename T> T in(){
	T res;
	cin >> res;
	return res;
}
template<typename T> vector<T> in(int n){
	vector<T> res(n);
	rep(i,n) res[i] = in<T>();
	return res;
}
template<typename T> vector<vector<T>> in(int h, int w){
	vector<vector<T>> res(h);
	rep(i,h) res[i] = in<T>(w);
	return res;
}
template<typename T> set<T> inSet(int n){
	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 vector<V> Vec;

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


int main(){
	solve();
}


Compiler output:
a.cc:78:14: error: declaration of 'void Value<T>::set(T)' changes meaning of 'set' [-Wchanges-meaning]
   78 |         void set(T v){ value = v; }
      |              ^~~
a.cc:77:9: note: used here to mean 'class std::set<char>'
   77 |         set<char> getSet(){ return std::set<char>(begin(), end()); }
      |         ^~~~~~~~~
In file included from /usr/include/c++/14/set:63,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:158,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_set.h:96:11: note: declared here
   96 |     class set
      |           ^~~