import scala.collection.mutable

object Main extends App {
  import scala.io.StdIn._


  val v = readInt()
  val edges = Array.tabulate(v){_ ⇒ readLine.trim}
  val vertex = Array.tabulate(v){_ ⇒ new UnionFindTree}
  for (i ← 0 until v; j ← i + 1 until v if edges(i)(j) =='Y'){
    vertex(i).merge(vertex(j))
  }
  val wholeEdge = edges.map(_.count('Y' == _)).sum / 2
  val tops = vertex.filter(_.isTop)
  implicit val memo = mutable. Map[(Int, Int, Int), Boolean]()
  val res = calWin(tops.map(u ⇒ u.size * (u.size - 1) / 2).sum - wholeEdge, tops.count(_.size % 2 == 0), tops.count(_.size % 2 == 1))
  println(if(res) "Taro" else "Hanako")
  def calWin(e: Int, ce: Int, co: Int)(implicit memo: mutable.Map[(Int, Int, Int), Boolean]): Boolean = {
    if (memo.isDefinedAt((e % 2, ce, co))) {
      memo((e % 2, ce, co))
    }
    else {
        val result = if (ce + co == 2){
          if (e % 2 == 0) false
          else true
        }else {
          !List[Option[Boolean]](
            if (e % 2 == 1) Some(calWin(0, ce, co)) else None,
            if (ce > 0) Some(calWin((e + 1) % 2, ce - 1, co)) else None,
            if (co > 1) Some(calWin(e % 2, ce + 1, co - 2)) else None).flatten.forall(i ⇒ i)
        }
        memo.update((e % 2, ce, co), result)
        result
    }
  }
  class UnionFindTree{
    private var mParent: Option[UnionFindTree] = None
    private var mSize: Int = 1
    private def parent: UnionFindTree = {
      mParent.map{_.parent} match {
        case None ⇒ this
        case c@Some(p) ⇒
          mParent = c
          p
      }
    }
    def isTop: Boolean = mParent.isEmpty
    def size: Int = parent.mSize
    def isSameUnion(that: UnionFindTree): Boolean = {
      parent == that.parent
    }
    def merge(that: UnionFindTree): Unit = {
      if (!isSameUnion(that)){
        val p = parent
        val tp = that.parent
        if (p.mSize > tp.mSize){
          tp.mParent = Some(p)
          p.mSize += tp.mSize
        }else {
          p.mParent = Some(tp)
          tp.mSize += p.mSize
        }
      }
    }
  }
  implicit class Extension[T](val value :T) extends AnyVal {
    @inline
    def let[A](@inline func: T ⇒ A): A = func(value)
    @inline
    def also(@inline func: T ⇒ Unit): T = {func(value); value}
    @inline
    def takeIf(@inline predicate: T ⇒ Boolean): Option[T] = Some(value).filter(predicate)
  }
}
