
def   UpperCamelCase__     (    SCREAMING_SNAKE_CASE_  :  list[list[int]]					)     ->    str:
						if len(SCREAMING_SNAKE_CASE_					) == 0 or not all(len(SCREAMING_SNAKE_CASE_					) == 2 for pair in coordinates					):
												raise ValueError("""The program cannot work out a fitting polynomial."""					)

						if len({tuple(SCREAMING_SNAKE_CASE_					) for pair in coordinates}					) != len(SCREAMING_SNAKE_CASE_					):
												raise ValueError("""The program cannot work out a fitting polynomial."""					)

						_lowercase									=				{x for x, _ in coordinates}
						if len(SCREAMING_SNAKE_CASE_					) == 1:
												return f"""x={coordinates[0][0]}"""

						if len(SCREAMING_SNAKE_CASE_					) != len(SCREAMING_SNAKE_CASE_					):
												raise ValueError("""The program cannot work out a fitting polynomial."""					)

						_lowercase									=				len(SCREAMING_SNAKE_CASE_					)

						_lowercase									=				0
						_lowercase									=				[]
						# put the x and x to the power values in a matrix
						while count_of_line < x:
												_lowercase									=				0
												_lowercase									=				coordinates[count_of_line][0]
												_lowercase									=				[]
												while count_in_line < x:
																		count_line.append(a ** (x - (count_in_line + 1))					)
																		count_in_line += 1
												matrix.append(SCREAMING_SNAKE_CASE_					)
												count_of_line += 1

						_lowercase									=				0
						# put the y values into a vector
						_lowercase									=				[]
						while count_of_line < x:
												vector.append(coordinates[count_of_line][1]					)
												count_of_line += 1

						_lowercase									=				0

						while count < x:
												_lowercase									=				0
												while zahlen < x:
																		if count == zahlen:
																								zahlen += 1
																		if zahlen == x:
																								break
																		_lowercase									=				matrix[zahlen][count] / matrix[count][count]
																		for counting_columns, item in enumerate(matrix[count]					):
																								# manipulating all the values in the matrix
																								matrix[zahlen][counting_columns] -= item * bruch
																		# manipulating the values in the vector
																		vector[zahlen] -= vector[count] * bruch
																		zahlen += 1
												count += 1

						_lowercase									=				0
						# make solutions
						_lowercase									=				[]
						while count < x:
												solution.append(str(vector[count] / matrix[count][count]					)					)
												count += 1

						_lowercase									=				0
						_lowercase									=				"""f(x)="""

						while count < x:
												_lowercase									=				solution[count].split("""E"""					)
												if len(SCREAMING_SNAKE_CASE_					) > 1:
																		_lowercase									=				f"""{remove_e[0]}*10^{remove_e[1]}"""
												solved += f"""x^{x - (count + 1)}*{solution[count]}"""
												if count + 1 != x:
																		solved += "+"
												count += 1

						return solved


if __name__ == "__main__":
		print(points_to_polynomial([]))
		print(points_to_polynomial([[]]))
		print(points_to_polynomial([[1, 0], [2, 0], [3, 0]]))
		print(points_to_polynomial([[1, 1], [2, 1], [3, 1]]))
		print(points_to_polynomial([[1, 3], [2, 3], [3, 3]]))
		print(points_to_polynomial([[1, 1], [2, 2], [3, 3]]))
		print(points_to_polynomial([[1, 1], [2, 4], [3, 9]]))
		print(points_to_polynomial([[1, 3], [2, 6], [3, 11]]))
		print(points_to_polynomial([[1, -3], [2, -6], [3, -11]]))
		print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))






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


A		:   List[Any]         =    logging.get_logger(__name__)

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



class       a_   ( _a						):
			a  : str				      =       '''videomae'''






			def __init__(			self							, __UpperCamelCase=224							, __UpperCamelCase=16							, __UpperCamelCase=3							, __UpperCamelCase=16							, __UpperCamelCase=2							, __UpperCamelCase=768							, __UpperCamelCase=12							, __UpperCamelCase=12							, __UpperCamelCase=3_072							, __UpperCamelCase="gelu"							, __UpperCamelCase=0.0							, __UpperCamelCase=0.0							, __UpperCamelCase=0.02							, __UpperCamelCase=1E-12							, __UpperCamelCase=True							, __UpperCamelCase=True							, __UpperCamelCase=6							, __UpperCamelCase=384							, __UpperCamelCase=4							, __UpperCamelCase=1_536							, __UpperCamelCase=True							, **__UpperCamelCase							, ):
									super().__init__(**__UpperCamelCase     )

									_lowercase									=				image_size
									_lowercase									=				patch_size
									_lowercase									=				num_channels
									_lowercase									=				num_frames
									_lowercase									=				tubelet_size

									_lowercase									=				hidden_size
									_lowercase									=				num_hidden_layers
									_lowercase									=				num_attention_heads
									_lowercase									=				intermediate_size
									_lowercase									=				hidden_act
									_lowercase									=				hidden_dropout_prob
									_lowercase									=				attention_probs_dropout_prob
									_lowercase									=				initializer_range
									_lowercase									=				layer_norm_eps
									_lowercase									=				qkv_bias
									_lowercase									=				use_mean_pooling

									_lowercase									=				decoder_num_attention_heads
									_lowercase									=				decoder_hidden_size
									_lowercase									=				decoder_num_hidden_layers
									_lowercase									=				decoder_intermediate_size
									_lowercase									=				norm_pix_loss