from math import factorial, floor
from typing import List

def calculate_peak_form(k: int, t: int) -> int:
    """
    Calculates peak form of k with t.
    """
    fold = factorial(factorial(k+1))
    crease = factorial(factorial(k))**2
    return (fold // crease)**t - 1

def escher(n: int) -> List[int]:
    """
    Calculates the first n terms of the Escher sequence.
    """
    sequence = [1, 1]
    h = 2
    while len(sequence) < n:
        t = 2 - h % 2
        sequence += [t] * ((sequence[h-1] * 2) // t)
        h += 1
    return sequence[:n]

def transform_list(input_list: List[int], t: int) -> List[int]:
    """
    Transforms input_list according to the parameter t.
    """
    replacements = {(1, 1): (1 << t) - 1, 2: [1 << t, (1 << t) - 2]}
    output_list = []
    count = 0  # Counter for '2' elements
    i = 0  # Index pointer
    while i < len(input_list):
        if i < len(input_list) - 1 and input_list[i] == input_list[i+1] == 1:
            output_list.append(replacements[(1, 1)])
            i += 2
        elif input_list[i] == 2:
            output_list.append(replacements[2][count % 2])
            count += 1
            i += 1
        else:
            output_list.append(input_list[i])
            i += 1
    return output_list[:-1]

def interleave_with_ones(sequence: List[int]) -> List[int]:
    """
    Interleaves 1s into the sequence.
    """
    return [elem for num in sequence for elem in [num, 1]]

def ruler_function(n: int) -> int:
    """
    Calculates the ruler function of n.
    """
    binary = bin(n)[2:][::-1]
    return binary.index('1') + 1

def kth_peak(k: int, t: int) -> int:
    """
    Returns the k-th peak with t.
    """
    return calculate_peak_form(ruler_function(k) + 1, t)

def interleave_lists(nums: List[int], letters: List[int], t: int) -> List[int]:
    """
    Interleaves the lists nums and letters according to the parameter t.
    """
    chunks = [[(1 << t) - 1, 1], [1 << t], [1, (1 << t) - 1], [1, (1 << t) - 2, 1]]
    chunks = [[1, 1], [2]] if t == 1 else chunks
    result = []
    letter_index = 0
    i = 0
    while i < len(nums):
        for chunk in chunks:
            if nums[i:i+len(chunk)] == chunk:
                result.extend(chunk)
                if letter_index < len(letters):
                    result.append(letters[letter_index])
                    letter_index += 1
                i += len(chunk)
                break
        else:
            if i < len(nums):
                result.append(nums[i])
                i += 1
    return result

def generate_continued_fraction():
    print("""Generates the continued fraction expansion via formula for sums of the form n>=0 1/(n!)!^t, t in N.""")
    while True:
        try:
            t = int(input('Set t in sum n>=0 1/(n!)!^t: '))
            terms = int(input('Enter number of terms: '))
            if terms < 12:
                n = terms
            else:
                n = floor(terms*(2/3))
            break
        except ValueError:
            print('Enter a natural number.')

    peak_terms = [int(kth_peak(x, t)) for x in range(1, n)]
    escher_terms = escher(n)
    escher_terms = interleave_with_ones(transform_list(escher_terms, t)) if t > 1 else escher_terms
    return [2] + interleave_lists(escher_terms, peak_terms, t)[:terms-1]


print(generate_continued_fraction())