





__lowerCamelCase       :     int   =     """ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"""



def 		A_				(     _lowerCAmelCase     )						-> bytes:
 # Make sure the supplied data is a bytes-like object
 if not isinstance(_lowerCAmelCase							,   _lowerCAmelCase     ):
  UpperCamelCase	:					Union[str, Any]       	=   F"""a bytes-like object is required, not '{data.__class__.__name__}'"""
  raise TypeError(_lowerCAmelCase     )

 UpperCamelCase	:					Optional[int]       	=   "".join(bin(_lowerCAmelCase     )[2:].zfill(8     ) for byte in data     )

 UpperCamelCase	:					int       	=   len(_lowerCAmelCase     ) % 6 != 0

 if padding_needed:
  # The padding that will be added later
  UpperCamelCase	:					List[str]       	=   b"=" * ((6 - len(_lowerCAmelCase     ) % 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(_lowerCAmelCase     ) % 6)
 else:
  UpperCamelCase	:					List[str]       	=   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(_lowerCAmelCase     )							,   6     )     ).encode()
     + padding
 )



def 		A_				(     _lowerCAmelCase     )						-> bytes:
 # Make sure encoded_data is either a string or a bytes-like object
 if not isinstance(_lowerCAmelCase							,   _lowerCAmelCase     ) and not isinstance(_lowerCAmelCase							,   _lowerCAmelCase     ):
  UpperCamelCase	:					Optional[int]       	=   (
      "argument should be a bytes-like object or ASCII string, "
      F"""not '{encoded_data.__class__.__name__}'"""
  )
  raise TypeError(_lowerCAmelCase     )

 # 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(_lowerCAmelCase							,   _lowerCAmelCase     ):
  try:
   UpperCamelCase	:					Union[str, Any]       	=   encoded_data.decode("utf-8"     )
  except UnicodeDecodeError:
   raise ValueError("base64 encoded data should only contain ASCII characters"     )

 UpperCamelCase	:					Tuple       	=   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(_lowerCAmelCase     ) % 4 == 0 and padding < 3, "Incorrect padding"

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

  UpperCamelCase	:					Optional[Any]       	=   "".join(
      bin(B64_CHARSET.index(_lowerCAmelCase     )     )[2:].zfill(6     ) for char in encoded_data     )[: -padding * 2]
 else:
  UpperCamelCase	:					Optional[int]       	=   "".join(
      bin(B64_CHARSET.index(_lowerCAmelCase     )     )[2:].zfill(6     ) for char in encoded_data     )

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

 return bytes(_lowerCAmelCase     )


if __name__ == "__main__":
    import doctest

    doctest.testmod()







def 		A_				(     _lowerCAmelCase = 50     )						-> int:
 UpperCamelCase	:					List[Any]       	=   [[0] * 3 for _ in range(length + 1     )]

 for row_length in range(length + 1     ):
  for tile_length in range(2							,   5     ):
   for tile_start in range(row_length - tile_length + 1     ):
    different_colour_ways_number[row_length][tile_length - 2] += (
        different_colour_ways_number[row_length - tile_start - tile_length][
            tile_length - 2
        ]
        + 1
    )

 return sum(different_colour_ways_number[length]     )


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