





"""simple docstring"""




import numpy as np





def  a_       (							_lowercase ,		_lowercase="utf-8" ,		_lowercase="surrogatepass"     ):
						_UpperCamelCase    :      List[Any]						     =					bin(int.from_bytes(text.encode(_lowercase ,		_lowercase     ) ,		'''big'''     )     )[2:]
						return bits.zfill(8 * ((len(_lowercase     ) + 7) // 8)     )





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





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

						_UpperCamelCase    :      str						     =					[]
						_UpperCamelCase    :      Optional[Any]						     =					[]
						_UpperCamelCase    :      Any						     =					[bin(_lowercase     )[2:] for x in range(1 ,		size_par + len(_lowercase     ) + 1     )]

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

						for x in range(1 ,		size_par + len(_lowercase     ) + 1     ):
												# Performs a template of bit positions - who should be given,
												# and who should be parity
												if qtd_bp < size_par:
																		if (np.log(_lowercase     ) / np.log(2     )).is_integer():
																								data_out_gab.append('''P'''     )
																								_UpperCamelCase    :      List[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(_lowercase     )

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

												qtd_bp += 1

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

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

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

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

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

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










"""simple docstring"""




def  a_       (							_lowercase     ):
						return 1 if input_a == 0 else 0





def  a_       (							):
						assert not_gate(0     ) == 1
						assert not_gate(1     ) == 0


if __name__ == "__main__":
						print(not_gate(0))
						print(not_gate(1))



