
"""simple docstring"""





import numpy as np







def 			__a  (	__lowerCamelCase,	__lowerCamelCase="utf-8",	__lowerCamelCase="surrogatepass"						):
   UpperCAmelCase_      :      int      =					bin(int.from_bytes(text.encode(__lowerCamelCase,	__lowerCamelCase						),	"big"						)						)[2:]
   return bits.zfill(8 * ((len(__lowerCamelCase						) + 7) // 8)						)







def 			__a  (	__lowerCamelCase,	__lowerCamelCase="utf-8",	__lowerCamelCase="surrogatepass"						):
   UpperCAmelCase_      :      Union[str, Any]      =					int(__lowerCamelCase,	2						)
   return n.to_bytes((n.bit_length() + 7) // 8,	"big"						).decode(__lowerCamelCase,	__lowerCamelCase						) or "\0"







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

   UpperCAmelCase_      :      Tuple      =					[]
   UpperCAmelCase_      :      Dict      =					[]
   UpperCAmelCase_      :      Optional[int]      =					[bin(__lowerCamelCase						)[2:] for x in range(1,	size_par + len(__lowerCamelCase						) + 1						)]

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

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

      # Calculates parity
   UpperCAmelCase_      :      Any      =					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_      :      Tuple      =					0
      for x in data_ord:
         if x is not None:
            try:
               UpperCAmelCase_      :      int      =					(bin_pos[cont_loop])[-1 * (bp)]
            except IndexError:
               UpperCAmelCase_      :      Optional[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
   UpperCAmelCase_      :      List[str]      =					0  # parity bit counter
   for x in range(0,	size_par + len(__lowerCamelCase						)						):
      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  (	__lowerCamelCase,	__lowerCamelCase						):
   UpperCAmelCase_      :      List[str]      =					[]
   # Parity bit counter
   UpperCAmelCase_      :      int      =					0
   # Counter p data bit reading
   UpperCAmelCase_      :      Optional[Any]      =					0
   # list of parity received
   UpperCAmelCase_      :      Tuple      =					[]
   UpperCAmelCase_      :      Optional[int]      =					[]

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

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

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

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

      # Calculates parity
   UpperCAmelCase_      :      Any      =					0  # parity bit counter
   for bp in range(1,	size_par + 1						):
      # Bit counter one for a certain parity
      UpperCAmelCase_      :      Optional[int]      =					0
      # Counter to control loop reading
      UpperCAmelCase_      :      Optional[Any]      =					0
      for x in data_ord:
         if x is not None:
            try:
               UpperCAmelCase_      :      Union[str, Any]      =					(bin_pos[cont_loop])[-1 * (bp)]
            except IndexError:
               UpperCAmelCase_      :      Optional[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
   UpperCAmelCase_      :      str      =					0  # Parity bit counter
   for x in range(0,	size_par + len(__lowerCamelCase						)						):
      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  (	__lowerCamelCase = 1000						):
   UpperCAmelCase_      :      List[Any]      =					0
   UpperCAmelCase_      :      List[str]      =					(n - 1) // 3
   total += ((terms) * (6 + (terms - 1) * 3)) // 2  # total of an A.P.
   UpperCAmelCase_      :      Any      =					(n - 1) // 5
   total += ((terms) * (10 + (terms - 1) * 5)) // 2
   UpperCAmelCase_      :      Optional[int]      =					(n - 1) // 15
   total -= ((terms) * (30 + (terms - 1) * 15)) // 2
   return total


if __name__ == "__main__":
    print(f"""{solution() = }""")


