






"""simple docstring"""



import numpy as np
def 						_SCREAMING_SNAKE_CASE			(   __snake_case      :  Dict		, __snake_case      :  str="utf-8"		, __snake_case      :  Tuple="surrogatepass"   ):





  '''simple docstring'''





  lowercase							   =	bin(int.from_bytes(text.encode(__snake_case		, __snake_case   )		, 'big'   )   )[2:]
  return bits.zfill(8 * ((len(__snake_case   ) + 7) // 8)   )
def 						_SCREAMING_SNAKE_CASE			(   __snake_case      :  int		, __snake_case      :  List[str]="utf-8"		, __snake_case      :  Tuple="surrogatepass"   ):





  '''simple docstring'''





  lowercase							   =	int(__snake_case		, 2   )
  return n.to_bytes((n.bit_length() + 7) // 8		, 'big'   ).decode(__snake_case		, __snake_case   ) or "\0"
def 						_SCREAMING_SNAKE_CASE			(   __snake_case      :  List[str]		, __snake_case      :  int   ):





  '''simple docstring'''





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

  lowercase							   =	[]
  lowercase							   =	[]
  lowercase							   =	[bin(__snake_case   )[2:] for x in range(1		, size_par + len(__snake_case   ) + 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(__snake_case   ) + 1   ):
    # Performs a template of bit positions - who should be given,
    # and who should be parity
    if qtd_bp < size_par:
      if (np.log(__snake_case   ) / 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(__snake_case   )

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

    # 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(__snake_case   )   ):
    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"""



def 						_SCREAMING_SNAKE_CASE			(   ):





  '''simple docstring'''





  for a in range(3_00   ):
    for b in range(a + 1		, 4_00   ):
      for c in range(b + 1		, 5_00   ):
        if (a + b + c) == 10_00 and (a**2) + (b**2) == (c**2):
          return a * b * c

  return -1
def 						_SCREAMING_SNAKE_CASE			(   ):





  '''simple docstring'''





  for a in range(3_00   ):
    for b in range(4_00   ):
      lowercase							   =	10_00 - a - b
      if a < b < c and (a**2) + (b**2) == (c**2):
        return a * b * c

  return -1
def 						_SCREAMING_SNAKE_CASE			(   ):





  '''simple docstring'''





  import timeit

  print(
      timeit.timeit('solution()'		, setup='from __main__ import solution'		, number=10_00   )   )
  print(
      timeit.timeit(
          'solution_fast()'		, setup='from __main__ import solution_fast'		, number=10_00   )   )


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


