


import numpy as np
def 							_UpperCAmelCase    (UpperCamelCase__					:  Union[str, Any]    ,							UpperCamelCase__					:  int="utf-8"    ,							UpperCamelCase__					:  Union[str, Any]="surrogatepass"						):
       _A				:	List[str]       =			bin(int.from_bytes(text.encode(UpperCamelCase__    ,							UpperCamelCase__						)    ,							"big"						)						)[2:]
       return bits.zfill(8 * ((len(UpperCamelCase__						) + 7) // 8)						)
def 							_UpperCAmelCase    (UpperCamelCase__					:  Tuple    ,							UpperCamelCase__					:  int="utf-8"    ,							UpperCamelCase__					:  List[str]="surrogatepass"						):
       _A				:	str       =			int(UpperCamelCase__    ,							2						)
       return n.to_bytes((n.bit_length() + 7) // 8    ,							"big"						).decode(UpperCamelCase__    ,							UpperCamelCase__						) or "\0"
def 							_UpperCAmelCase    (UpperCamelCase__					:  Optional[int]    ,							UpperCamelCase__					:  Optional[Any]						):
       if size_par + len(UpperCamelCase__						) <= 2**size_par - (len(UpperCamelCase__						) - 1):
              raise ValueError("size of parity don't match with size of data"						)

       _A				:	Optional[Any]       =			[]
       _A				:	List[Any]       =			[]
       _A				:	List[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				:	List[Any]       =			[]
       # data position template + parity
       _A				:	str       =			[]
       # parity bit counter
       _A				:	Any       =			0
       # counter position of data bits
       _A				:	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				:	Optional[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				:	Optional[int]       =			0  # parity bit counter
       for bp in range(1    ,							size_par + 1						):
              # Bit counter one for a given parity
              _A				:	Dict       =			0
              # counter to control the loop reading
              _A				:	List[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				:	Dict       =			"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				:	str       =			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 							_UpperCAmelCase    (UpperCamelCase__					:  List[Any]    ,							UpperCamelCase__					:  Dict						):
       _A				:	Union[str, Any]       =			[]
       # Parity bit counter
       _A				:	Optional[Any]       =			0
       # Counter p data bit reading
       _A				:	Union[str, Any]       =			0
       # list of parity received
       _A				:	str       =			[]
       _A				:	Tuple       =			[]

       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				:	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_output.append(data[cont_data]						)
              else:
                     parity_received.append(data[cont_data]						)
              cont_data += 1

       # -----------calculates the parity with the data
       _A				:	Any       =			[]
       _A				:	List[str]       =			[]
       _A				:	Tuple       =			[bin(UpperCamelCase__						)[2:] for x in range(1    ,							size_par + len(UpperCamelCase__						) + 1						)]

       #  sorted information data for the size of the output data
       _A				:	Optional[Any]       =			[]
       # Data position feedback + parity
       _A				:	int       =			[]
       # Parity bit counter
       _A				:	List[Any]       =			0
       # Counter p data bit reading
       _A				:	Tuple       =			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				:	Optional[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				:	List[str]       =			0  # parity bit counter
       for bp in range(1    ,							size_par + 1						):
              # Bit counter one for a certain parity
              _A				:	str       =			0
              # Counter to control loop reading
              _A				:	str       =			0
              for x in data_ord:
                     if x is not None:
                            try:
                                   _A				:	Optional[Any]       =			(bin_pos[cont_loop])[-1 * (bp)]
                            except IndexError:
                                   _A				:	Tuple       =			"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				:	List[str]       =			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				:	Optional[int]       =			parity_received == parity
       return data_output, ack




from itertools import permutations
def 							_UpperCAmelCase    ():
       _A				:	List[Any]       =			list(map("".join    ,							permutations("0123456789"						)						)						)
       return result[999999]


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