what os the time ocmplexuty and space comlelxuty of each as in asked ina. interview if 
"""
import sys

class Node:
    def __init__(self, val):
        self.val = val
        self.uid = None
        self.parent = None  
        self.child = [] 
        self.isLocked = False  
        self.locked_descendants = set()  # Set of locked descendant nodes

class Tree:
    def __init__(self, m, n, name_list):
        self.node_list = []
        self.node_map = {}
        for name in name_list:
            node = Node(name)
            self.node_list.append(node)
            self.node_map[name] = node

        # Build the tree
        for i in range(n):
            for j in range(m):
                child_index = m * i + j + 1
                if child_index < n:
                    self.node_list[i].child.append(self.node_list[child_index])
                    self.node_list[child_index].parent = self.node_list[i]

        self.root = self.node_list[0]

    def lock(self, node, uid):
        if node.isLocked:
            return False

        # Check if any ancestor is locked
        current = node.parent
        while current:
            if current.isLocked:
                return False
            current = current.parent

        # Check if any descendant is locked
        if node.locked_descendants:
            return False

        # Lock the node
        node.isLocked = True
        node.uid = uid

        # Update locked_descendants for all ancestors
        current = node.parent
        while current:
            current.locked_descendants.add(node)
            current = current.parent

        return True

    def unlock(self, node, uid):
        if not node.isLocked or node.uid != uid:
            return False

        # Unlock the node
        node.isLocked = False
        node.uid = None

        # Update locked_descendants for all ancestors
        current = node.parent
        while current:
            current.locked_descendants.discard(node)  # Correct
            current = current.parent

        return True

    def upgrade(self, node, uid):
        if node.isLocked:
            return False

        # Check if any ancestor is locked
        current = node.parent
        while current:
            if current.isLocked:
                return False
            current = current.parent

        # Check if there is at least one locked descendant
        if not node.locked_descendants:
            return False

        # Collect all locked descendants
        locked_descendants = []
        for ld in node.locked_descendants:
            locked_descendants.append(ld)

        # Check if all locked descendants have the same uid
        for ld in locked_descendants:
            if ld.uid != uid:
                return False

        # Unlock all locked descendants
        for ld in locked_descendants:
            ld.isLocked = False
            ld.uid = None
            node.locked_descendants.discard(ld)

            # Update locked_descendants for all ancestors of ld
            ancestor = ld.parent
            while ancestor:
                ancestor.locked_descendants.discard(ld)
                ancestor = ancestor.parent

        # Lock the current node
        node.isLocked = True
        node.uid = uid

        # Update locked_descendants for all ancestors
        current = node.parent
        while current:
            current.locked_descendants.add(node)
            current = current.parent

        return True

    def process_queries(self, queries):
        results = []
        for query in queries:
            parts = query.strip().split()
            if len(parts) != 3:
                results.append('false')
                continue
            operation, node_name, uid = parts
            try:
                uid = int(uid)
            except ValueError:
                results.append('false')
                continue
            node = self.node_map.get(node_name, None)
            if not node:
                results.append('false')
                continue
            if operation == "1":
                result = self.lock(node, uid)
            elif operation == "2":
                result = self.unlock(node, uid)
            elif operation == "3":
                result = self.upgrade(node, uid)
            else:
                result = False  # Invalid operation
            results.append('true' if result else 'false')
        return results

def main():
    try:
        n_line = sys.stdin.readline()
        if not n_line:
            n = 0
        else:
            n = int(n_line)
    except ValueError:
        n = 0

    try:
        m_line = sys.stdin.readline()
        if not m_line:
            m = 0
        else:
            m = int(m_line)
    except ValueError:
        m = 0

    try:
        q_line = sys.stdin.readline()
        if not q_line:
            q = 0
        else:
            q = int(q_line)
    except ValueError:
        q = 0

    name_list = []
    for _ in range(n):
        name = sys.stdin.readline()
        if not name:
            name = ""
        else:
            name = name.strip()
        name_list.append(name)

    queries = []
    for _ in range(q):
        query = sys.stdin.readline()
        if not query:
            query = ""
        else:
            query = query.strip()
        queries.append(query)

    tree = Tree(m, n, name_list)
    results = tree.process_queries(queries)
    for res in results:
        print(res)

main()
"""