def prime_factorization(n):
    """Decomposes a number into its prime factors."""
    if n == 1:
        return []
    
    factors = []
    divisor = 2
    
    while n > 1:
        while n % divisor == 0:
            factors.append(divisor)
            n //= divisor
        divisor += 1 if divisor == 2 else 2
        
        if divisor * divisor > n:
            if n > 1:
                factors.append(n)
            break
            
    return factors

def find_exponent(n):
    """Finds the exponent k such that n = 2^k."""
    k = 1
    while (1 << k) <= n:
        k += 1
    return k

def generate_complete_sequences(n, num_terms):
    """Generates all requested sequences."""
    k_max = find_exponent(n)
    
    # Store sequences i;i for summary
    sequences_summary = {}
    
    # Generate original sequences
    print(f"n : {', '.join(str(i) for i in range(1, n + 1))}")
    
    # Generate and store sequences 1;k
    sequences_1k = []
    for position in range(k_max):
        current_sequence = []
        for num in range(1, n + 1):
            factors = prime_factorization(num)
            current_sequence.append(str(factors[position]) if position < len(factors) else '-')
        sequences_1k.append(current_sequence)
        print(f"Sequence 1;{position + 1} : {', '.join(current_sequence)}")
        if position == 0:  # Store Sequence 1;1 for summary
            sequences_summary["1;1"] = current_sequence
    
    # Store all sequences for reference
    all_sequences = {f"1;{i+1}": sequences_1k[i] for i in range(len(sequences_1k))}
    
    # For each level i from 1 to k_max-1
    for i in range(1, k_max):
        # Generate sequences A;i;k
        for k in range(i+1, k_max + 1):
            shifted_sequence = ['-'] * n
            source_sequence = all_sequences[f"{i};{i}"] if i > 1 else sequences_1k[0]
            
            for pos in range(n):
                if source_sequence[pos] != '-':
                    new_pos = (pos + 1) * (2 ** (k-i))
                    if new_pos <= n:
                        shifted_sequence[new_pos - 1] = source_sequence[pos]
            
            all_sequences[f"A;{i};{k}"] = shifted_sequence
            print(f"Sequence A;{i};{k} : {', '.join(shifted_sequence)}")
        
        # Generate next level sequences by comparison
        for k in range(i+1, k_max + 1):
            compared_sequence = ['-'] * n
            base_sequence = sequences_1k[k-1] if i == 1 else all_sequences[f"{i};{k}"]
            sequence_a = all_sequences[f"A;{i};{k}"]
            
            for j in range(n):
                if base_sequence[j] != sequence_a[j] and base_sequence[j] != '-':
                    compared_sequence[j] = base_sequence[j]
            
            all_sequences[f"{i+1};{k}"] = compared_sequence
            print(f"Sequence {i+1};{k} : {', '.join(compared_sequence)}")
            
            # Store sequences i;i for summary
            if k == i+1:
                sequences_summary[f"{i+1};{i+1}"] = compared_sequence
    
    # Display summary of sequences i;i limited to requested number of terms
    print(f"\nSummary of sequences i;i (limited to {num_terms} terms):")
    for i in range(1, k_max + 1):
        key = f"{i};{i}"
        if key in sequences_summary:
            numbers = [x for x in sequences_summary[key] if x != '-'][:num_terms]
            print(f"Sequence {key} : {', '.join(numbers)}")

def main():
    while True:
        try:
            n = int(input("Enter the value of n (positive integer): "))
            if n <= 0:
                print("Please enter a positive integer.")
                continue
            break
        except ValueError:
            print("Please enter a valid integer.")
    
    while True:
        try:
            num_terms = int(input("How many terms do you want to display in the summary? "))
            if num_terms <= 0:
                print("Please enter a positive number.")
                continue
            break
        except ValueError:
            print("Please enter a valid number.")
    
    generate_complete_sequences(n, num_terms)

if __name__ == "__main__":
    main()