def build_kmp_table(pattern: str) -> list:
    """Строит таблицу префиксов для алгоритма Кнута-Морриса-Пратта"""
    table = [0] * len(pattern)
    length = 0
    i = 1
    while i < len(pattern):
        if pattern[i] == pattern[length]:
            length += 1
            table[i] = length
            i += 1
        else:
            if length != 0:
                length = table[length-1]
            else:
                table[i] = 0
                i += 1
    return table

def encode_numbers(numbers: list) -> str:
    """Кодирует список чисел в уникальную строку с префиксами длин"""
    return ''.join(f"{len(str(num))}{num}" for num in sorted(numbers))

def find_in_pi(pattern: str, pi_file: str = 'pi.txt') -> tuple[int, int]:
    """Ищет подстроку в числе π с использованием алгоритма KMP"""
    if not pattern:
        return 0, 0
    
    kmp_table = build_kmp_table(pattern)
    state = 0
    current_pos = 0
    found = False
    
    try:
        with open(pi_file, 'r') as f:
            # Пропускаем "3." в начале файла
            if f.read(2) == "3.":
                pass  # Уже в дробной части
            else:
                f.seek(0)  # Читаем файл с начала если нет "3."
            
            # Буферизированное чтение
            chunk_size = 131072  # 128KB
            buffer = ""
            keep = max(0, len(pattern) - 1)  # Сохраняем хвост для поиска
            
            while True:
                chunk = f.read(chunk_size)
                if not chunk:
                    break
                
                buffer += chunk
                index = buffer.find(pattern)
                
                if index != -1:
                    start_pos = current_pos + index
                    return start_pos, len(pattern)
                
                # Обновляем позицию и буфер
                if len(buffer) > keep:
                    processed = len(buffer) - keep
                    current_pos += processed
                    buffer = buffer[-keep:] if keep > 0 else ""
    
    except FileNotFoundError:
        pass
    
    return -1, 0  # Последовательность не найдена

def make_pi_photo(numbers: list, pi_file: str = 'pi.txt') -> complex:
    """Создает π-фото для списка чисел"""
    # Кодируем числа в уникальную строку
    pattern = encode_numbers(numbers)
    
    # Ищем подстроку в числе π
    start, length = find_in_pi(pattern, pi_file)
    
    # Возвращаем результат в виде комплексного числа
    return complex(start, length)

def decode_photo(photo: complex) -> tuple[int, int]:
    """Декодирует π-фото в позицию и длину"""
    return int(photo.real), int(photo.imag)

def decode_pi_sequence(pi_file: str, start: int, length: int) -> list:
    """Восстанавливает исходные числа из последовательности в π"""
    try:
        with open(pi_file, 'r') as f:
            # Пропускаем "3." и начальные позиции
            header = f.read(2)
            skip_chars = 2 + start if header == "3." else start
            
            # Позиционируем и читаем нужную длину
            f.seek(skip_chars)
            sequence = f.read(length)
            
            # Декодируем последовательность
            numbers = []
            i = 0
            while i < len(sequence):
                # Первая цифра - длина числа
                num_length = int(sequence[i])
                i += 1
                
                # Извлекаем само число
                num_str = sequence[i:i+num_length]
                i += num_length
                
                numbers.append(int(num_str))
            
            return numbers
    
    except (FileNotFoundError, ValueError, IndexError):
        return []  # Ошибка чтения или декодирования

# Пример использования
if __name__ == "__main__":
    # Пример с известными первыми цифрами π
    numbers = [1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
    photo = make_pi_photo(numbers)
    print(f"π-фото: {photo}")
    
    start, length = decode_photo(photo)
    print(f"Начало: {start}, Длина: {length}")
    
    # Восстановление исходных чисел из π
    restored = decode_pi_sequence('pi.txt', start, length)
    print(f"Восстановленные числа: {restored}")
    print(f"Совпадает с исходными? {sorted(numbers) == restored}")