





from __future__ import annotations

from queue import Queue
def 			__UpperCamelCase				(			lowercase__	:       int		,    lowercase__	:       int		)	->      tuple[int, int]:
    '''simple docstring'''





    a ^= b
    b ^= a
    a ^= b
    return a, b
def 			__UpperCamelCase				(			lowercase__	:       int		,    lowercase__	:       list[list[int]]		)	->      list[list[int]]:
    '''simple docstring'''





    lowerCAmelCase_					:	Any						=   1
    while (1 << j) < max_node:
        for i in range(1		,    max_node + 1		):
            lowerCAmelCase_					:	Optional[Any]						=   parent[j - 1][parent[j - 1][i]]
        j += 1
    return parent
def 			__UpperCamelCase				(			lowercase__	:       int		,    lowercase__	:       int		,    lowercase__	:       list[int]		,    lowercase__	:       list[list[int]]		)	->      int:
    '''simple docstring'''





    if level[u] < level[v]:
        lowerCAmelCase_					:	str						=   swap(lowercase__		,    lowercase__		)
    # making depth of u same as depth of v
    for i in range(18		,    -1		,    -1		):
        if level[u] - (1 << i) >= level[v]:
            lowerCAmelCase_					:	Tuple						=   parent[i][u]
    # at the same depth if u==v that mean lca is found
    if u == v:
        return u
    # moving both nodes upwards till lca in found
    for i in range(18		,    -1		,    -1		):
        if parent[i][u] not in [0, parent[i][v]]:
            lowerCAmelCase_					:	Union[str, Any]						=   parent[i][u], parent[i][v]
    # returning longest common ancestor of u,v
    return parent[0][u]
def 			__UpperCamelCase				(			lowercase__	:       list[int]		,    lowercase__	:       list[list[int]]		,    lowercase__	:       int		,    lowercase__	:       dict[int, list[int]]		,    lowercase__	:       int = 1		,    )	->      tuple[list[int], list[list[int]]]:
    '''simple docstring'''





    lowerCAmelCase_					:	int						=   0
    lowerCAmelCase_					:	Queue[int]						=   Queue(maxsize=lowercase__		)
    q.put(lowercase__		)
    while q.qsize() != 0:
        lowerCAmelCase_					:	Union[str, Any]						=   q.get()
        for v in graph[u]:
            if level[v] == -1:
                lowerCAmelCase_					:	List[str]						=   level[u] + 1
                q.put(lowercase__		)
                lowerCAmelCase_					:	Tuple						=   u
    return level, parent
def 			__UpperCamelCase				(			)	->      None:
    '''simple docstring'''





    lowerCAmelCase_					:	List[Any]						=   13
    # initializing with 0
    lowerCAmelCase_					:	Dict						=   [[0 for _ in range(max_node + 10		)] for _ in range(20		)]
    # initializing with -1 which means every node is unvisited
    lowerCAmelCase_					:	List[Any]						=   [-1 for _ in range(max_node + 10		)]
    lowerCAmelCase_					:	dict[int, list[int]]						=   {
        1: [2, 3, 4],
        2: [5],
        3: [6, 7],
        4: [8],
        5: [9, 10],
        6: [11],
        7: [],
        8: [12, 13],
        9: [],
        10: [],
        11: [],
        12: [],
        13: [],
    }
    lowerCAmelCase_					:	Tuple						=   breadth_first_search(lowercase__		,    lowercase__		,    lowercase__		,    lowercase__		,    1		)
    lowerCAmelCase_					:	Dict						=   create_sparse(lowercase__		,    lowercase__		)
    print("""LCA of node 1 and 3 is: """		,    lowest_common_ancestor(1		,    3		,    lowercase__		,    lowercase__		)		)
    print("""LCA of node 5 and 6 is: """		,    lowest_common_ancestor(5		,    6		,    lowercase__		,    lowercase__		)		)
    print("""LCA of node 7 and 11 is: """		,    lowest_common_ancestor(7		,    11		,    lowercase__		,    lowercase__		)		)
    print("""LCA of node 6 and 7 is: """		,    lowest_common_ancestor(6		,    7		,    lowercase__		,    lowercase__		)		)
    print("""LCA of node 4 and 12 is: """		,    lowest_common_ancestor(4		,    12		,    lowercase__		,    lowercase__		)		)
    print("""LCA of node 8 and 8 is: """		,    lowest_common_ancestor(8		,    8		,    lowercase__		,    lowercase__		)		)


if __name__ == "__main__":
  main()









from __future__ import annotations

import math
from itertools import permutations
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      bool:
    '''simple docstring'''





    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5		,    int(math.sqrt(lowercase__		) + 1		)		,    6		):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True
def 			__UpperCamelCase				(			lowercase__	:       int = 7		)	->      int:
    '''simple docstring'''





    lowerCAmelCase_					:	str						=   """""".join(str(lowercase__		) for i in range(1		,    n + 1		)		)
    lowerCAmelCase_					:	Any						=   [int("""""".join(lowercase__		)		) for i in permutations(lowercase__		,    lowercase__		)]
    lowerCAmelCase_					:	List[Any]						=   [num for num in perm_list if is_prime(lowercase__		)]
    return max(lowercase__		) if pandigitals else 0


if __name__ == "__main__":
  print(f"""{solution() = }""")


