from string import ascii_uppercase
def 					UpperCamelCase__		(							A__     ,					A__     ,					A__ = False     ,					A__ = ascii_uppercase       )  ->   str:
				snake_case__   :      Union[str, Any]   				= keyword.upper()
				snake_case__   :      int   				= plaintext.upper()
				snake_case__   :      Any   				= set(__lowercase       )

				# create a list of unique characters in the keyword - their order matters
				# it determines how we will map plaintext characters to the ciphertext
				snake_case__   :      int   				= []
				for char in keyword:
								if char in alphabet_set and char not in unique_chars:
												unique_chars.append(__lowercase       )
    # the number of those unique characters will determine the number of rows
				snake_case__   :      str   				= len(__lowercase       )

				# create a shifted version of the alphabet
				snake_case__   :      Any   				= unique_chars + [
				    char for char in alphabet if char not in unique_chars
				]

				# create a modified alphabet by splitting the shifted alphabet into rows
				snake_case__   :      Optional[Any]   				= [
				    shifted_alphabet[k : k + num_unique_chars_in_keyword]
				    for k in range(0     ,					26     ,					__lowercase       )
				]

				# map the alphabet characters to the modified alphabet characters
				# going 'vertically' through the modified alphabet - consider columns first
				snake_case__   :      List[str]   				= {}
				snake_case__   :      Union[str, Any]   				= 0
				for column in range(__lowercase       ):
								for row in modified_alphabet:
												# if current row (the last one) is too short, break out of loop
												if len(__lowercase       ) <= column:
																break

												# map current letter to letter in modified alphabet
												snake_case__   :      Any   				= row[column]
												letter_index += 1

				if verbose:
								print(__lowercase       )
				# create the encrypted text by mapping the plaintext to the modified alphabet
				return "".join(mapping[char] if char in mapping else char for char in plaintext       )


if __name__ == "__main__":
				# example use
				print(mixed_keyword('''college''', '''UNIVERSITY'''))







from ...configuration_utils import PretrainedConfig
from ...utils import logging


snake_case     :    Any						=    logging.get_logger(__name__)

snake_case     :    List[str]						=    {
    'MCG-NJU/videomae-base': 'https://huggingface.co/MCG-NJU/videomae-base/resolve/main/config.json',
}




class 				lowerCAmelCase__	(						UpperCamelCase    ):
					__A  :     str     =    'videomae'







					def __init__(							self   :  Optional[Any]      ,		_A   :  str=224      ,		_A   :  Union[str, Any]=16      ,		_A   :  int=3      ,		_A   :  Tuple=16      ,		_A   :  int=2      ,		_A   :  List[Any]=768      ,		_A   :  List[Any]=12      ,		_A   :  Tuple=12      ,		_A   :  List[Any]=3072      ,		_A   :  Union[str, Any]="gelu"      ,		_A   :  Any=0.0      ,		_A   :  str=0.0      ,		_A   :  Tuple=0.02      ,		_A   :  Optional[Any]=1e-12      ,		_A   :  Tuple=True      ,		_A   :  Dict=True      ,		_A   :  str=6      ,		_A   :  Optional[int]=384      ,		_A   :  Any=4      ,		_A   :  Any=1536      ,		_A   :  Optional[int]=True      ,		**_A   :  Tuple      ,		):
											super().__init__(**_A)

											A__						:				List[str]         =			image_size
											A__						:				Union[str, Any]         =			patch_size
											A__						:				Optional[int]         =			num_channels
											A__						:				int         =			num_frames
											A__						:				List[Any]         =			tubelet_size

											A__						:				str         =			hidden_size
											A__						:				Optional[Any]         =			num_hidden_layers
											A__						:				int         =			num_attention_heads
											A__						:				List[Any]         =			intermediate_size
											A__						:				Optional[int]         =			hidden_act
											A__						:				Any         =			hidden_dropout_prob
											A__						:				str         =			attention_probs_dropout_prob
											A__						:				List[Any]         =			initializer_range
											A__						:				str         =			layer_norm_eps
											A__						:				Any         =			qkv_bias
											A__						:				Union[str, Any]         =			use_mean_pooling

											A__						:				int         =			decoder_num_attention_heads
											A__						:				Tuple         =			decoder_hidden_size
											A__						:				int         =			decoder_num_hidden_layers
											A__						:				int         =			decoder_intermediate_size
											A__						:				Any         =			norm_pix_loss