from math import floor

def prRed(s): print(f"\033[91m{s}\033[00m", end="")
def prGreen(s): print(f"\033[92m{s}\033[00m", end="")

def left_of(i: int):
    return 2 * i + 1

def right_of(i: int):
    return 2 * i + 2

def parent_of(i: int) -> int:
    return floor((i - 1) / 2)


def insert(A: list, i: int):
    vizualize_list(A, {}, {}, {})
    n = len(A)
    A.append(i)
    vizualize_list(A, {}, {n}, {})
    while n != 0 and A[parent_of(n)] > A[n]:
        A[n], A[parent_of(n)] = A[parent_of(n)], A[n]
        vizualize_list(A, {n, parent_of(n)}, {}, {})
        n = parent_of(n)
    vizualize_list(A, {}, {}, {})
    print()

def remove_min(A: list):
    vizualize_list(A, {}, {}, {})
    A[0], A[len(A) - 1] = A[len(A) - 1], A[0]
    vizualize_list(A, {0, len(A) - 1}, {}, {})
    i = A.pop()
    vizualize_list(A, {}, {}, {i})
    n = 0
    fortsett = True
    while fortsett:
        if left_of(n) < len(A) and right_of(n) < len(A):
            if A[n] > A[left_of(n)] and A[n] > A[right_of(n)]:
                old_n = n
                n = left_of(n) if A[left_of(n)] < A[right_of(n)] else right_of(n)
                A[old_n], A[n] = A[n], A[old_n]
                vizualize_list(A, {n, old_n}, {}, {})
            elif A[n] > A[left_of(n)]:
                A[n], A[left_of(n)] = A[left_of(n)], A[n]
                vizualize_list(A, {n, left_of(n)}, {}, {})
                n = left_of(n)
            elif A[n] > A[right_of(n)]:
                A[n], A[right_of(n)] = A[right_of(n)], A[n]
                vizualize_list(A, {n, right_of(n)}, {}, {})
                n = right_of(n)
            else:
                fortsett = False
        elif left_of(n) < len(A):
            if A[n] > A[left_of(n)]:
                A[n], A[left_of(n)] = A[left_of(n)], A[n]
                vizualize_list(A, {n, left_of(n)}, {}, {})
                n = left_of(n)
            else:
                fortsett = False
        else:
            fortsett = False
    vizualize_list(A, {}, {}, {})
    print()
    return i

def vizualize_list(A: list, red_indexes: set, green_indexes: set, deleted: set):
    print("| ", end="")
    for i, n in enumerate(A):
        if i in red_indexes:
            prRed(n)
        elif i in green_indexes:
            prGreen(n)
        else:
            print(n, end="")
        print(" | ", end="")
    if deleted:
        for i in deleted:
            prRed("--" + str(i))
    print("")

def main():
    heap = [int(i) for i in input("Skriv inn en heap: ").split(" ")]
    vizualize_list(heap, {}, {i for i in range(len(heap))}, {})
    fortsett = True
    while fortsett:
        inp = int(input("1 - insert, 2 - remove, 3 - exit: "))
        match inp:
            case 1:
                i = int(input("Insert: "))
                insert(heap, i)
            case 2:
                i = remove_min(heap)
                print("Removed " + str(i))
            case 3:
                fortsett = False

main()