"""
二叉搜索樹定義：
    1,每個節(jié)點上都有數(shù)據(jù)
    2,當(dāng)前節(jié)點的左節(jié)點數(shù)據(jù)比當(dāng)前節(jié)點的數(shù)據(jù)小，并且當(dāng)前節(jié)點的所有左節(jié)點數(shù)據(jù)都比當(dāng)前節(jié)點的數(shù)據(jù)小
    3,當(dāng)前節(jié)點的右節(jié)點數(shù)據(jù)比當(dāng)前節(jié)點的數(shù)據(jù)大，并且當(dāng)前節(jié)點的所有右節(jié)點數(shù)據(jù)都比當(dāng)前節(jié)點的數(shù)據(jù)大
"""


class Tree:
    def __init__(self):
        self.root = None
        self.list_data = []

    def insert(self, data):

        if self.root is None:
            self.root = Node(data)
            return

        current_node = self.root

        while current_node is not Node:

            if current_node.data == data:   # 這個數(shù)據(jù)已經(jīng)在里面則跳出
                return

            elif data > current_node.data:    # 當(dāng)前這個節(jié)點的值小于需要插入的值
                if current_node.right is None:      # 如果右節(jié)點為空插入這個節(jié)點數(shù)據(jù)
                    current_node.right = Node(data)
                else:                               # 不為空的時候需要繼續(xù)比較下一級
                    current_node = current_node.right
            else:   # 當(dāng)前節(jié)點的數(shù)據(jù)大于需要插入的數(shù)據(jù)
                if current_node.left is None:
                    current_node.left = Node(data)
                else:
                    current_node = current_node.left

    def get_tree_data(self):
        self.print_node_data(self.root)

    def print_node_data(self, node):
            if node.left is not None:
                self.print_node_data(node.left)
            self.list_data.append(node.data)

            if node.right is not None:
                self.print_node_data(node.right)

    def print_tree(self, list_type=0):    # 遍歷輸出這顆樹
        self.print_node(self.root, list_type)

    def print_node(self, node, list_type):

        if list_type == 0:  # 前序遍歷
            if node.left is not None:
                self.print_node(node.left, list_type)
            print(node.data)

            if node.right is not None:
                self.print_node(node.right, list_type)
        elif list_type == 1:    # 前序遍歷
            print(node.data)
            if node.left is not None:
                self.print_node(node.left, list_type)
            if node.right is not None:
                self.print_node(node.right, list_type)
        elif list_type == 2:    # 后序遍歷
            if node.left is not None:
                self.print_node(node.left, list_type)
            if node.right is not None:
                self.print_node(node.right, list_type)
            print(node.data)

    # 判斷是否是一顆二叉樹
    def is_tree(self):
        return self.is_tree_detail(self.root)

    def is_tree_detail(self, node):
        flag = True
        if node is None:
            return flag

        # 處理當(dāng)前節(jié)點的左子樹
        if node.left is not None:
            if node.left.data > node.data:
                return False
            else:
                if self.is_fit(node.data, node.left) is False:
                    return False

        # 處理當(dāng)前節(jié)點的右子樹
        if node.right is not None:
            if node.right.data < node.data:
                return False
            else:
                if self.is_fit(node.data, node.right, 1) is False:
                    return False

        # 處理當(dāng)前節(jié)點的左節(jié)點
        if self.is_tree_detail(node.left) is False:
            return False

        # 處理當(dāng)前節(jié)點的右節(jié)點
        if self.is_tree_detail(node.right) is False:
            return False

        return flag

    def is_fit(self, data, node, type=0):
        flag = True

        if type == 0:   # type=0表示在比較左子樹
            if node.left is not None:
                if data < node.left.data:
                    return False
                else:
                    if self.is_fit(data, node.left) is False:
                        return False

            if node.right is not None:
                if data < node.right.data:
                    return False
                else:
                    if self.is_fit(data, node.right) is False:
                        return False
        else:           # 等于1表示在比較右子樹
            if node.left is not None:
                if data > node.left.data:
                    return False
                else:
                    if self.is_fit(data, node.left, type) is False:
                        return False

            if node.right is not None:
                if data > node.right.data:
                    return False
                else:
                    if self.is_fit(data, node.right, type) is False:
                        return False

        return flag


class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None


def get_node(data, node_id):

    if node_id == 0:
        return None

    for x in data:
        if x[0] == node_id:
            # print('get_node:node_id：{}'.format(node_id), x[1])
            node = Node(x[1])
            node.left = get_node(data, x[2])
            node.right = get_node(data, x[3])
            return node

    return None


def main():
    n = int(input())
    data = [[int(i) for i in input().split()] for j in range(n)]    # 一次性讀入所有的數(shù)據(jù)

    # print(data)

    # 存儲二叉樹
    tree = Tree()
    for i in range(n):
        x = data[i]
        if x[0] == 1:
            node = Node(x[1])
            node.left = get_node(data, x[2])
            node.right = get_node(data, x[3])
            tree.root = node

    # tree.print_tree()

    # 如果是一顆二叉樹的琴儿，那么得到的數(shù)據(jù)和排序后輸出的數(shù)據(jù)肯定是一致的
    # flag = True

    flag = tree.is_tree()

    if flag:
        print('T')
    else:
        print('F')

    return


if __name__ == '__main__':
    main()