


'''simple docstring'''



__UpperCAmelCase      :Tuple			    =       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"




def      _a     (						_lowercase :     bytes  ):





     '''simple docstring'''






     if not isinstance(_lowercase      , _lowercase  ):
          __UpperCAmelCase     :			Dict  							=      F'a bytes-like object is required, not \'{data.__class__.__name__}\''
          raise TypeError(_lowercase  )

     __UpperCAmelCase     :			Optional[Any]  							=      ''''''.join(bin(_lowercase  )[2:].zfill(8  ) for byte in data  )

     __UpperCAmelCase     :			Union[str, Any]  							=      len(_lowercase  ) % 6 != 0

     if padding_needed:
          # The padding that will be added later
          __UpperCAmelCase     :			List[Any]  							=      b'''=''' * ((6 - len(_lowercase  ) % 6) // 2)

          # Append binary_stream with arbitrary binary digits (0's by default) to make its
          # length a multiple of 6.
          binary_stream += "0" * (6 - len(_lowercase  ) % 6)
     else:
          __UpperCAmelCase     :			Tuple  							=      b''''''

     # Encode every 6 binary digits to their corresponding Base64 character
     return (
         "".join(
             B64_CHARSET[int(binary_stream[index : index + 6]      , 2  )]
             for index in range(0      , len(_lowercase  )      , 6  )  ).encode()
         + padding
     )




def      _a     (						_lowercase :     str  ):





     '''simple docstring'''






     if not isinstance(_lowercase      , _lowercase  ) and not isinstance(_lowercase      , _lowercase  ):
          __UpperCAmelCase     :			str  							=      (
              '''argument should be a bytes-like object or ASCII string, '''
              F'not \'{encoded_data.__class__.__name__}\''
          )
          raise TypeError(_lowercase  )

     # In case encoded_data is a bytes-like object, make sure it contains only
     # ASCII characters so we convert it to a string object
     if isinstance(_lowercase      , _lowercase  ):
          try:
               __UpperCAmelCase     :			Tuple  							=      encoded_data.decode('''utf-8'''  )
          except UnicodeDecodeError:
               raise ValueError('''base64 encoded data should only contain ASCII characters'''  )

     __UpperCAmelCase     :			List[Any]  							=      encoded_data.count('''='''  )

     # Check if the encoded string contains non base64 characters
     if padding:
          assert all(
              char in B64_CHARSET for char in encoded_data[:-padding]  ), "Invalid base64 character(s) found."
     else:
          assert all(
              char in B64_CHARSET for char in encoded_data  ), "Invalid base64 character(s) found."

     # Check the padding
     assert len(_lowercase  ) % 4 == 0 and padding < 3, "Incorrect padding"

     if padding:
          # Remove padding if there is one
          __UpperCAmelCase     :			str  							=      encoded_data[:-padding]

          __UpperCAmelCase     :			str  							=      ''''''.join(
              bin(B64_CHARSET.index(_lowercase  )  )[2:].zfill(6  ) for char in encoded_data  )[: -padding * 2]
     else:
          __UpperCAmelCase     :			Tuple  							=      ''''''.join(
              bin(B64_CHARSET.index(_lowercase  )  )[2:].zfill(6  ) for char in encoded_data  )

     __UpperCAmelCase     :			Optional[int]  							=      [
         int(binary_stream[index : index + 8]      , 2  )
         for index in range(0      , len(_lowercase  )      , 8  )
     ]

     return bytes(_lowercase  )


if __name__ == "__main__":
      import doctest

      doctest.testmod()



'''simple docstring'''



def      _a     (						_lowercase :     int = 600851475143  ):





     '''simple docstring'''






     try:
          __UpperCAmelCase     :			str  							=      int(_lowercase  )
     except (TypeError, ValueError):
          raise TypeError('''Parameter n must be int or castable to int.'''  )
     if n <= 0:
          raise ValueError('''Parameter n must be greater than or equal to one.'''  )
     __UpperCAmelCase     :			Dict  							=      1
     __UpperCAmelCase     :			List[str]  							=      2
     while i * i <= n:
          while n % i == 0:
               __UpperCAmelCase     :			int  							=      i
               n //= i
          i += 1
     if n > 1:
          __UpperCAmelCase     :			List[str]  							=      n
     return int(_lowercase  )


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