






'''simple docstring'''





from __future__ import annotations

from collections import Counter
def        UpperCAmelCase      (   _lowercase      ):


    '''simple docstring'''



    _lowercase     =	[True] * n
    _lowercase     =	False
    _lowercase     =	False
    _lowercase     =	True

    for i in range(3,      int(n**0.5 + 1      ),      2      ):
        _lowercase     =	i * 2
        while index < n:
            _lowercase     =	False
            _lowercase     =	index + i

    _lowercase     =	[2]

    for i in range(3,      _lowercase,      2      ):
        if is_prime[i]:
            primes.append(_lowercase      )

    return primes
def        UpperCAmelCase      (   _lowercase      ):


    '''simple docstring'''



    _lowercase     =	str(_lowercase      )
    _lowercase     =	[]
    _lowercase     =	['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

    for duplicate in Counter(_lowercase      ) - Counter(set(_lowercase      )      ):
        _lowercase     =	[int(number_str.replace(_lowercase,      _lowercase      )      ) for digit in digits]
        replacements.append(_lowercase      )

    return replacements
def        UpperCAmelCase      (   _lowercase = 8      ):


    '''simple docstring'''



    _lowercase     =	set()

    # Filter primes with less than 3 replaceable digits
    _lowercase     =	{
        x for x in set(prime_sieve(1000000      )      ) if len(str(_lowercase      )      ) - len(set(str(_lowercase      )      )      ) >= 3
    }

    for prime in primes:
        if prime in numbers_checked:
            continue

        _lowercase     =	digit_replacements(_lowercase      )

        for family in replacements:
            numbers_checked.update(_lowercase      )
            _lowercase     =	primes.intersection(_lowercase      )

            if len(_lowercase      ) != family_length:
                continue

            return min(_lowercase      )

    return -1


if __name__ == "__main__":
   print(solution())








from __future__ import annotations
def        UpperCAmelCase      (   _lowercase,      _lowercase      ):


    '''simple docstring'''



    _lowercase     =	[None] * (len(_lowercase      ) + len(_lowercase      ))

    _lowercase     =	0  # pointer to current index for left Half
    _lowercase     =	0  # pointer to current index for the right Half
    _lowercase     =	0  # pointer to current index for the sorted array Half

    while pointera < len(_lowercase      ) and pointera < len(_lowercase      ):
        if left_half[pointera] < right_half[pointera]:
            _lowercase     =	left_half[pointera]
            pointera += 1
            index += 1
        else:
            _lowercase     =	right_half[pointera]
            pointera += 1
            index += 1
    while pointera < len(_lowercase      ):
        _lowercase     =	left_half[pointera]
        pointera += 1
        index += 1

    while pointera < len(_lowercase      ):
        _lowercase     =	right_half[pointera]
        pointera += 1
        index += 1

    return sorted_array
def        UpperCAmelCase      (   _lowercase      ):


    '''simple docstring'''



    if len(_lowercase      ) <= 1:
        return array
    # the actual formula to calculate the middle element = left + (right - left) // 2
    # this avoids integer overflow in case of large N
    _lowercase     =	0 + (len(_lowercase      ) - 0) // 2

    # Split the array into halves till the array length becomes equal to One
    # merge the arrays of single length returned by mergeSort function and
    # pass them into the merge arrays function which merges the array
    _lowercase     =	array[:middle]
    _lowercase     =	array[middle:]

    return merge(merge_sort(_lowercase      ),      merge_sort(_lowercase      )      )


if __name__ == "__main__":
   import doctest

   doctest.testmod()
