



'''simple docstring'''

import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding

class __snake_case(      _lowerCAmelCase					):


						'''simple docstring'''



						UpperCAmelCase							:    Any           =		["image_processor", "tokenizer"]
						UpperCAmelCase							:    Union[str, Any]           =		"VideoMAEImageProcessor"
						UpperCAmelCase							:    Any           =		("CLIPTokenizer", "CLIPTokenizerFast")


						def __init__(					self	,       A_=None	,       A_=None	,       **A_      )	->	Dict:
							lowerCAmelCase    =	None
							if "feature_extractor" in kwargs:
								warnings.warn(
								    """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
								    """ instead."""	,       A_	,       )
								lowerCAmelCase    =	kwargs.pop("""feature_extractor"""      )

							lowerCAmelCase    =	image_processor if image_processor is not None else feature_extractor
							if image_processor is None:
								raise ValueError("""You need to specify an `image_processor`."""      )
							if tokenizer is None:
								raise ValueError("""You need to specify a `tokenizer`."""      )

							super().__init__(A_	,       A_      )
							lowerCAmelCase    =	self.image_processor


						def __call__(					self	,       A_=None	,       A_=None	,       A_=None	,       **A_      )	->	Dict:

							if text is None and videos is None:
								raise ValueError("""You have to specify either text or videos. Both cannot be none."""      )

							if text is not None:
								lowerCAmelCase    =	self.tokenizer(A_	,       return_tensors=A_	,       **A_      )

							if videos is not None:
								lowerCAmelCase    =	self.image_processor(A_	,       return_tensors=A_	,       **A_      )

							if text is not None and videos is not None:
								lowerCAmelCase    =	image_features.pixel_values
								return encoding
							elif text is not None:
								return encoding
							else:
								return BatchEncoding(data=dict(**A_      )	,       tensor_type=A_      )


						def 				__snake_case    (					self	,       *A_	,       **A_      )	->	List[Any]:
							return self.tokenizer.batch_decode(*A_	,       **A_      )


						def 				__snake_case    (					self	,       *A_	,       **A_      )	->	List[Any]:
							return self.tokenizer.decode(*A_	,       **A_      )


						@property
						def 				__snake_case    (					self      )	->	List[str]:
							return ["input_ids", "attention_mask", "position_ids", "pixel_values"]


						@property
						def 				__snake_case    (					self      )	->	Dict:
							warnings.warn(
							    """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""	,       A_	,       )
							return self.image_processor_class




						@property
						def 				__snake_case    (					self      )	->	Dict:
							warnings.warn(
							    """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""	,       A_	,       )
							return self.image_processor




'''simple docstring'''

def 		_snake_case		(					_SCREAMING_SNAKE_CASE     :						int = 4_000_000							)			->						int:







	"""simple docstring"""
	lowerCAmelCase    =	1
	lowerCAmelCase    =	2
	lowerCAmelCase    =	0
	while j <= n:
		if j % 2 == 0:
			total += j
		lowerCAmelCase,   lowerCAmelCase    =	j, i + j

	return total


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