


import numpy as np



def 			_a      (    __UpperCamelCase	,	__UpperCamelCase="utf-8"	,	__UpperCamelCase="surrogatepass"			):
     a_     :  Union[str, Any]				      =     bin(int.from_bytes(text.encode(__UpperCamelCase	,	__UpperCamelCase			)	,	"""big"""			)			)[2:]
     return bits.zfill(8 * ((len(__UpperCamelCase			) + 7) // 8)			)



def 			_a      (    __UpperCamelCase	,	__UpperCamelCase="utf-8"	,	__UpperCamelCase="surrogatepass"			):
     a_     :  int				      =     int(__UpperCamelCase	,	2			)
     return n.to_bytes((n.bit_length() + 7) // 8	,	"""big"""			).decode(__UpperCamelCase	,	__UpperCamelCase			) or "\0"



def 			_a      (    __UpperCamelCase	,	__UpperCamelCase			):
     if size_par + len(__UpperCamelCase			) <= 2**size_par - (len(__UpperCamelCase			) - 1):
          raise ValueError("""size of parity don't match with size of data"""			)

     a_     :  Tuple				      =     []
     a_     :  int				      =     []
     a_     :  Any				      =     [bin(__UpperCamelCase			)[2:] for x in range(1	,	size_par + len(__UpperCamelCase			) + 1			)]

     # sorted information data for the size of the output data
     a_     :  int				      =     []
     # data position template + parity
     a_     :  Tuple				      =     []
     # parity bit counter
     a_     :  List[str]				      =     0
     # counter position of data bits
     a_     :  List[Any]				      =     0

     for x in range(1	,	size_par + len(__UpperCamelCase			) + 1			):
          # Performs a template of bit positions - who should be given,
          # and who should be parity
          if qtd_bp < size_par:
               if (np.log(__UpperCamelCase			) / np.log(2			)).is_integer():
                    data_out_gab.append("""P"""			)
                    a_     :  Union[str, Any]				      =     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(__UpperCamelCase			)

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

          qtd_bp += 1

     # Mount the message
     a_     :  Any				      =     0  # parity bit counter
     for x in range(0	,	size_par + len(__UpperCamelCase			)			):
          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 			_a      (    __UpperCamelCase	,	__UpperCamelCase			):
     a_     :  Any				      =     []
     # Parity bit counter
     a_     :  List[str]				      =     0
     # Counter p data bit reading
     a_     :  Tuple				      =     0
     # list of parity received
     a_     :  Optional[int]				      =     []
     a_     :  Union[str, Any]				      =     []

     for x in range(1	,	len(__UpperCamelCase			) + 1			):
          # Performs a template of bit positions - who should be given,
          #  and who should be parity
          if qtd_bp < size_par and (np.log(__UpperCamelCase			) / np.log(2			)).is_integer():
               data_out_gab.append("""P"""			)
               a_     :  str				      =     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
     a_     :  Optional[int]				      =     []
     a_     :  List[Any]				      =     []
     a_     :  Union[str, Any]				      =     [bin(__UpperCamelCase			)[2:] for x in range(1	,	size_par + len(__UpperCamelCase			) + 1			)]

     #  sorted information data for the size of the output data
     a_     :  Any				      =     []
     # Data position feedback + parity
     a_     :  Union[str, Any]				      =     []
     # Parity bit counter
     a_     :  Tuple				      =     0
     # Counter p data bit reading
     a_     :  Optional[int]				      =     0

     for x in range(1	,	size_par + len(__UpperCamelCase			) + 1			):
          # Performs a template position of bits - who should be given,
          # and who should be parity
          if qtd_bp < size_par and (np.log(__UpperCamelCase			) / np.log(2			)).is_integer():
               data_out_gab.append("""P"""			)
               a_     :  Union[str, Any]				      =     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(__UpperCamelCase			)

    # Calculates parity
     a_     :  Tuple				      =     0  # parity bit counter
     for bp in range(1	,	size_par + 1			):
          # Bit counter one for a certain parity
          a_     :  Tuple				      =     0
          # Counter to control loop reading
          a_     :  Optional[int]				      =     0
          for x in data_ord:
               if x is not None:
                    try:
                         a_     :  Optional[Any]				      =     (bin_pos[cont_loop])[-1 * (bp)]
                    except IndexError:
                         a_     :  Any				      =     """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
     a_     :  Any				      =     0  # Parity bit counter
     for x in range(0	,	size_par + len(__UpperCamelCase			)			):
          if data_ord[x] is None:
               data_out.append(str(parity[cont_bp]			)			)
               cont_bp += 1
          else:
               data_out.append(data_ord[x]			)

     a_     :  List[str]				      =     parity_received == parity
     return data_output, ack








"""simple docstring"""






import math


def 							A__ (     UpperCamelCase__    ):


  '''simple docstring'''


  if not isinstance(UpperCamelCase__       ,							UpperCamelCase__    ):
    _SCREAMING_SNAKE_CASE        =			F'''Input value of [number={number}] must be an integer'''
    raise TypeError(UpperCamelCase__    )
  if number < 1:
    _SCREAMING_SNAKE_CASE        =			F'''Input value of [number={number}] must be a positive integer'''
    raise ValueError(UpperCamelCase__    )
  _SCREAMING_SNAKE_CASE        =			[number]
  while number != 1:
    if number % 2 == 0:
      _SCREAMING_SNAKE_CASE        =			math.floor(math.sqrt(UpperCamelCase__    )    )
    else:
      _SCREAMING_SNAKE_CASE        =			math.floor(
          math.sqrt(UpperCamelCase__    ) * math.sqrt(UpperCamelCase__    ) * math.sqrt(UpperCamelCase__    )    )
    sequence.append(UpperCamelCase__    )
  return sequence


if __name__ == "__main__":
    import doctest

    doctest.testmod()
