#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 1001

enum GAME{
	Unknown,
	Sente,
	Gote,
};

enum Type{
	GU,
	KI,
};

int V;
int boss[NUM],height[NUM],edge_num[NUM],member_num[NUM];

int get_boss(int id){
	if(boss[id] == id)return id;
	else{
		return boss[id] = get_boss(boss[id]);
	}
}

int is_same(int x,int y){
	return get_boss(x) == get_boss(y);
}

void unite(int x,int y){
	int boss_x = get_boss(x);
	int boss_y = get_boss(y);

	if(boss_x == boss_y)return;

	if(height[x] > height[y]){

		boss[boss_y] = boss_x;

	}else if(height[x] < height[y]){

		boss[boss_x] = boss_y;

	}else{ //height[x] == height[y]

		boss[boss_y] = boss_x;
		height[x]++;
	}
}


GAME dp[NUM][NUM][2][2];
Type rev_type[2] = {KI,GU};
bool loop_guard[NUM][NUM][2][2];
char table[NUM][NUM];

GAME recursive(GAME turn,int KI_group_num,int GU_group_num,Type inner_edge_type){
	if(dp[KI_group_num][GU_group_num][turn][inner_edge_type] != Unknown)return dp[KI_group_num][GU_group_num][turn][inner_edge_type];

	GAME enemy;
	if(turn == Sente){
		enemy = Gote;
	}else{
		enemy = Sente;
	}

	if(KI_group_num+GU_group_num == 2 && inner_edge_type == GU){
		return dp[KI_group_num][GU_group_num][turn][inner_edge_type] = enemy;
	}

	bool FLG = false;

	if(loop_guard[KI_group_num][GU_group_num][turn][inner_edge_type] == false){
		loop_guard[KI_group_num][GU_group_num][turn][inner_edge_type] = true;
		if(recursive(enemy,KI_group_num,GU_group_num,rev_type[inner_edge_type]) == turn){
			FLG = true;
		}
	}

	if(KI_group_num >= 2){
		if(recursive(enemy,KI_group_num-2,GU_group_num+1,inner_edge_type) == turn){
			FLG = true;
		}
	}

	if(GU_group_num >= 2){
		if(recursive(enemy,KI_group_num,GU_group_num-1,rev_type[inner_edge_type]) == turn){
			FLG = true;
		}
	}

	if(KI_group_num >= 1 && GU_group_num >= 1){
		if(recursive(enemy,KI_group_num,GU_group_num-1,rev_type[inner_edge_type]) == turn){
			FLG = true;
		}
	}

	if(FLG){
		return dp[KI_group_num][GU_group_num][turn][inner_edge_type] = turn;
	}else{
		return dp[KI_group_num][GU_group_num][turn][inner_edge_type] = enemy;
	}
}


int main(){

	scanf("%d",&V);

	for(int i = 0; i < V; i++){
		boss[i] = i;
		height[i] = 0;
		edge_num[i] = 0;
		member_num[i] = 0;
	}

	for(int row = 0; row < V; row++){
		scanf("%s",table[row]);
		for(int col = 0; col < V; col++){
			if(table[row][col] == 'Y'){
				unite(row,col);
			}
		}
	}

	for(int i = 0; i < V; i++){
		member_num[get_boss(i)]++;
	}

	for(int row = 0; row < V; row++){
		for(int col = 0; col < V; col++){
			if(table[row][col] == 'Y'){
				edge_num[boss[row]]++;
			}
		}
	}

	for(int i = 0; i < V; i++){
		edge_num[i] /= 2;
	}

	int KI_group_num = 0,GU_group_num = 0,inner_edge_num = 0;
	for(int i = 0; i < V; i++){
		if(member_num[i] == 0)continue;

		if(member_num[i]%2 == 1){
			KI_group_num++;
		}else{
			GU_group_num++;
		}
		inner_edge_num += (member_num[i]*(member_num[i]-1))/2-edge_num[i];
	}

	for(int i = 0; i <= V; i++){
		for(int k = 0; k <= V; k++){
			for(int a = 0; a < 2; a++){
				for(int b = 0; b < 2; b++){
					dp[i][k][a][b] = Unknown;
					loop_guard[i][k][a][b] = false;
				}
			}
		}
	}

	Type first_type;
	if(inner_edge_num%2 == 0){
		first_type = GU;
	}else{
		first_type = KI;
	}

	if(recursive(Sente,KI_group_num,GU_group_num,first_type) == Sente){
		printf("Taro\n");
	}else{
		printf("Hanako\n");
	}

	return 0;
}



Measured memory_bytes: 23920