





'''simple docstring'''




_A:					Any							=				"""ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"""







def _lowerCAmelCase     (      _lowerCAmelCase    )->     bytes:
 # Make sure the supplied data is a bytes-like object
 if not isinstance(a_       ,    a_    ):
  __UpperCAmelCase					=   F'a bytes-like object is required, not \'{data.__class__.__name__}\''
  raise TypeError(a_    )

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

 __UpperCAmelCase					=   len(a_    ) % 6 != 0

 if padding_needed:
  # The padding that will be added later
  __UpperCAmelCase					=   b'''=''' * ((6 - len(a_    ) % 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(a_    ) % 6)
 else:
  __UpperCAmelCase					=   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(a_    )       ,    6    )    ).encode()
     + padding
 )







def _lowerCAmelCase     (      _lowerCAmelCase    )->     bytes:
 # Make sure encoded_data is either a string or a bytes-like object
 if not isinstance(a_       ,    a_    ) and not isinstance(a_       ,    a_    ):
  __UpperCAmelCase					=   (
      '''argument should be a bytes-like object or ASCII string, '''
      F'not \'{encoded_data.__class__.__name__}\''
  )
  raise TypeError(a_    )

 # 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(a_       ,    a_    ):
  try:
   __UpperCAmelCase					=   encoded_data.decode('utf-8'    )
  except UnicodeDecodeError:
   raise ValueError('base64 encoded data should only contain ASCII characters'    )

 __UpperCAmelCase					=   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(a_    ) % 4 == 0 and padding < 3, "Incorrect padding"

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

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

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

 return bytes(a_    )


if __name__ == "__main__":
    import doctest

    doctest.testmod()












'''simple docstring'''




from __future__ import annotations







def _lowerCAmelCase     (      _lowerCAmelCase    )->     int:
 if not nums:
  return 0
 __UpperCAmelCase					=   nums[0]
 __UpperCAmelCase					=   0
 for num in nums[1:]:
  __UpperCAmelCase					,    __UpperCAmelCase					=   (
      max_excluding + num,
      max(_lowerCAmelCase       ,    _lowerCAmelCase    ),
  )
 return max(_lowerCAmelCase       ,    _lowerCAmelCase    )


if __name__ == "__main__":
    import doctest

    doctest.testmod()





