---

from itertools import product

def nand(a: int, b: int) -> int:
    return int(not (a and b))

def nor(a: int, b: int) -> int:
    return int(not (a or b))

def xor(a: int, b: int) -> int:
    return int((a or b) and not (a and b))

def print_row(*values) -> None:
    print(*[int(v) for v in values])

def truth_table(expr, n: int) -> dict:
    return {values: expr(*values) for values in product((0, 1), repeat=n)}

def equivalent(expr1, expr2, n: int) -> bool:
    table1 = truth_table(expr1, n)
    table2 = truth_table(expr2, n)
    return all(table1[k][-1] == table2[k][-1] for k in table1)

def show_table(title: str, expr, n: int) -> None:
    print(title)
    for values, parts in truth_table(expr, n).items():
        print_row(*values, *parts)

def task1():
    print("A B A&B NAND")
    for a, b in product((0, 1), repeat=2):
        and_part = a and b
        print_row(a, b, and_part, nand(a, b))
    # 1 1 -> 1 0

def task2():
    print("A B A|B NOR")
    for a, b in product((0, 1), repeat=2):
        or_part = a or b
        print_row(a, b, or_part, nor(a, b))
    # 0 0 -> 0 1

def task3():
    print("A B A|B A&B !(A&B) XOR")
    for a, b in product((0, 1), repeat=2):
        or_part = a or b
        and_part = a and b
        nand_part = not and_part
        print_row(a, b, or_part, and_part, nand_part, xor(a, b))
    # 0 1 -> 1 0 1 1

def task4():
    print("A !A !!A")
    valid = True
    for a in (0, 1):
        not_a = not a
        not_not_a = not not_a
        print_row(a, not_a, not_not_a)
        if bool(a) != not_not_a:
            valid = False
    print("Закон выполняется:", valid)

def task5():
    print("A B | A&B B&A | A|B B|A")
    valid_and = True
    valid_or = True
    for a, b in product((0, 1), repeat=2):
        left_and, right_and = a and b, b and a
        left_or, right_or = a or b, b or a
        print_row(a, b, left_and, right_and, left_or, right_or)
        if left_and != right_and:
            valid_and = False
        if left_or != right_or:
            valid_or = False
    print("Коммутативность И:", valid_and)
    print("Коммутативность ИЛИ:", valid_or)

def task6():
    print("A B C (A|B)|C A|(B|C)")
    valid = True
    for a, b, c in product((0, 1), repeat=3):
        left = (a or b) or c
        right = a or (b or c)
        print_row(a, b, c, left, right)
        if left != right:
            valid = False
    print("Закон выполняется:", valid)

def task7():
    # F = (A & B) | (!A & C)
    print("A B C A&B !A !A&C F")
    for a, b, c in product((0, 1), repeat=3):
        ab = a and b
        not_a = not a
        not_a_c = not_a and c
        f = ab or not_a_c
        print_row(a, b, c, ab, not_a, not_a_c, f)
    # 1 1 0 -> 1 0 0 1

def task8():
    de_morgan_left = lambda a, b: [a and b, not (a and b)]
    de_morgan_right = lambda a, b: [not a, not b, (not a) or (not b)]
    show_table("not(A and B): A B A&B result", de_morgan_left, 2)
    show_table("not A or not B: A B !A !B result", de_morgan_right, 2)
    print("De Morgan:", equivalent(de_morgan_left, de_morgan_right, 2)) # True
    f1 = lambda a, b, c: [b or c, a and (b or c)]
    f2 = lambda a, b, c: [a and b, (a and b) or c]
    print("A&(B|C) == (A&B)|C:", equivalent(f1, f2, 3)) # False
    xor_gates = lambda a, b: [a or b, not (a and b), (a or b) and not (a and b)]
    xor_neq = lambda a, b: [a != b]
    print("XOR == (A != B):", equivalent(xor_gates, xor_neq, 2)) # True

match int(input("Номер задания: ")):
    case 1:
        task1()
    case 2:
        task2()
    case 3:
        task3()
    case 4:
        task4()
    case 5:
        task5()
    case 6:
        task6()
    case 7:
        task7()
    case 8:
        task8()