


'''simple docstring'''

import numpy as np

def _SCREAMING_SNAKE_CASE   (A						,				A="utf-8"						,				A="surrogatepass" ) -> List[str]:






       """simple docstring"""







       lowercase__       =				bin(int.from_bytes(text.encode(A						,				A )						,				'''big''' ) )[2:]
       return bits.zfill(8 * ((len(A ) + 7) // 8) )

def _SCREAMING_SNAKE_CASE   (A						,				A="utf-8"						,				A="surrogatepass" ) -> Union[str, Any]:






       """simple docstring"""







       lowercase__       =				int(A						,				2 )
       return n.to_bytes((n.bit_length() + 7) // 8						,				'''big''' ).decode(A						,				A ) or "\0"

def _SCREAMING_SNAKE_CASE   (A						,				A ) -> Any:






       """simple docstring"""







       if size_par + len(A ) <= 2**size_par - (len(A ) - 1):
              raise ValueError('''size of parity don\'t match with size of data''' )

       lowercase__       =				[]
       lowercase__       =				[]
       lowercase__       =				[bin(A )[2:] for x in range(1						,				size_par + len(A ) + 1 )]

       # sorted information data for the size of the output data
       lowercase__       =				[]
       # data position template + parity
       lowercase__       =				[]
       # parity bit counter
       lowercase__       =				0
       # counter position of data bits
       lowercase__       =				0

       for x in range(1						,				size_par + len(A ) + 1 ):
              # Performs a template of bit positions - who should be given,
              # and who should be parity
              if qtd_bp < size_par:
                     if (np.log(A ) / np.log(2 )).is_integer():
                            data_out_gab.append('''P''' )
                            lowercase__       =				qtd_bp + 1
                     else:
                            data_out_gab.append('''D''' )
              else:
                     data_out_gab.append('''D''' )

              # Sorts the data to the new output size
              if data_out_gab[-1] == "D":
                     data_ord.append(data[cont_data] )
                     cont_data += 1
              else:
                     data_ord.append(A )

    # Calculates parity
       lowercase__       =				0  # parity bit counter
       for bp in range(1						,				size_par + 1 ):
              # Bit counter one for a given parity
              lowercase__       =				0
              # counter to control the loop reading
              lowercase__       =				0
              for x in data_ord:
                     if x is not None:
                            try:
                                   lowercase__       =				(bin_pos[cont_loop])[-1 * (bp)]
                            except IndexError:
                                   lowercase__       =				'''0'''
                            if aux == "1" and x == "1":
                                   cont_bo += 1
                     cont_loop += 1
              parity.append(cont_bo % 2 )

              qtd_bp += 1

       # Mount the message
       lowercase__       =				0  # parity bit counter
       for x in range(0						,				size_par + len(A ) ):
              if data_ord[x] is None:
                     data_out.append(str(parity[cont_bp] ) )
                     cont_bp += 1
              else:
                     data_out.append(data_ord[x] )

       return data_out

def _SCREAMING_SNAKE_CASE   (A						,				A ) -> Optional[Any]:






       """simple docstring"""







       lowercase__       =				[]
       # Parity bit counter
       lowercase__       =				0
       # Counter p data bit reading
       lowercase__       =				0
       # list of parity received
       lowercase__       =				[]
       lowercase__       =				[]

       for x in range(1						,				len(A ) + 1 ):
              # Performs a template of bit positions - who should be given,
              #  and who should be parity
              if qtd_bp < size_par and (np.log(A ) / np.log(2 )).is_integer():
                     data_out_gab.append('''P''' )
                     lowercase__       =				qtd_bp + 1
              else:
                     data_out_gab.append('''D''' )

              # Sorts the data to the new output size
              if data_out_gab[-1] == "D":
                     data_output.append(data[cont_data] )
              else:
                     parity_received.append(data[cont_data] )
              cont_data += 1

       # -----------calculates the parity with the data
       lowercase__       =				[]
       lowercase__       =				[]
       lowercase__       =				[bin(A )[2:] for x in range(1						,				size_par + len(A ) + 1 )]

       #  sorted information data for the size of the output data
       lowercase__       =				[]
       # Data position feedback + parity
       lowercase__       =				[]
       # Parity bit counter
       lowercase__       =				0
       # Counter p data bit reading
       lowercase__       =				0

       for x in range(1						,				size_par + len(A ) + 1 ):
              # Performs a template position of bits - who should be given,
              # and who should be parity
              if qtd_bp < size_par and (np.log(A ) / np.log(2 )).is_integer():
                     data_out_gab.append('''P''' )
                     lowercase__       =				qtd_bp + 1
              else:
                     data_out_gab.append('''D''' )

              # Sorts the data to the new output size
              if data_out_gab[-1] == "D":
                     data_ord.append(data_output[cont_data] )
                     cont_data += 1
              else:
                     data_ord.append(A )

    # Calculates parity
       lowercase__       =				0  # parity bit counter
       for bp in range(1						,				size_par + 1 ):
              # Bit counter one for a certain parity
              lowercase__       =				0
              # Counter to control loop reading
              lowercase__       =				0
              for x in data_ord:
                     if x is not None:
                            try:
                                   lowercase__       =				(bin_pos[cont_loop])[-1 * (bp)]
                            except IndexError:
                                   lowercase__       =				'''0'''
                            if aux == "1" and x == "1":
                                   cont_bo += 1
                     cont_loop += 1
              parity.append(str(cont_bo % 2 ) )

              qtd_bp += 1

       # Mount the message
       lowercase__       =				0  # Parity bit counter
       for x in range(0						,				size_par + len(A ) ):
              if data_ord[x] is None:
                     data_out.append(str(parity[cont_bp] ) )
                     cont_bp += 1
              else:
                     data_out.append(data_ord[x] )

       lowercase__       =				parity_received == parity
       return data_output, ack








'''simple docstring'''

from __future__ import annotations

from collections import Counter

def _SCREAMING_SNAKE_CASE   (A ) -> list[int]:






       """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						,				A						,				2 ):
              if is_prime[i]:
                     primes.append(A )

       return primes

def _SCREAMING_SNAKE_CASE   (A ) -> list[list[int]]:






       """simple docstring"""







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

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

       return replacements

def _SCREAMING_SNAKE_CASE   (A = 8 ) -> int:






       """simple docstring"""







       lowercase__       =				set()

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

       for prime in primes:
              if prime in numbers_checked:
                     continue

              lowercase__       =				digit_replacements(A )

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

                     if len(A ) != family_length:
                            continue

                     return min(A )

       return -1


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




