






import argparse

import torch
from datasets import load_dataset
from donut import DonutModel

from transformers import (
    DonutImageProcessor,
    DonutProcessor,
    DonutSwinConfig,
    DonutSwinModel,
    MBartConfig,
    MBartForCausalLM,
    VisionEncoderDecoderModel,
    XLMRobertaTokenizerFast,
)

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  Dict					)		->			str:






	"""simple docstring"""



	UpperCamelCase     :Tuple          =	model.config

	UpperCamelCase     :Optional[int]          =	DonutSwinConfig(
	    image_size=original_config.input_size	,			patch_size=4	,			depths=original_config.encoder_layer	,			num_heads=[4, 8, 16, 32]	,			window_size=original_config.window_size	,			embed_dim=128	,			)
	UpperCamelCase     :str          =	MBartConfig(
	    is_decoder=__magic_name__	,			is_encoder_decoder=__magic_name__	,			add_cross_attention=__magic_name__	,			decoder_layers=original_config.decoder_layer	,			max_position_embeddings=original_config.max_position_embeddings	,			vocab_size=len(
	        model.decoder.tokenizer					)	,			scale_embedding=__magic_name__	,			add_final_layer_norm=__magic_name__	,			)

	return encoder_config, decoder_config

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  List[Any]					)		->			int:






	"""simple docstring"""



	if "encoder.model" in name:
		UpperCamelCase     :Optional[int]          =	name.replace("""encoder.model"""	,			"""encoder"""					)
	if "decoder.model" in name:
		UpperCamelCase     :int          =	name.replace("""decoder.model"""	,			"""decoder"""					)
	if "patch_embed.proj" in name:
		UpperCamelCase     :Dict          =	name.replace("""patch_embed.proj"""	,			"""embeddings.patch_embeddings.projection"""					)
	if "patch_embed.norm" in name:
		UpperCamelCase     :Tuple          =	name.replace("""patch_embed.norm"""	,			"""embeddings.norm"""					)
	if name.startswith("""encoder"""					):
		if "layers" in name:
			UpperCamelCase     :Optional[Any]          =	"""encoder.""" + name
		if "attn.proj" in name:
			UpperCamelCase     :Union[str, Any]          =	name.replace("""attn.proj"""	,			"""attention.output.dense"""					)
		if "attn" in name and "mask" not in name:
			UpperCamelCase     :Tuple          =	name.replace("""attn"""	,			"""attention.self"""					)
		if "norm1" in name:
			UpperCamelCase     :Union[str, Any]          =	name.replace("""norm1"""	,			"""layernorm_before"""					)
		if "norm2" in name:
			UpperCamelCase     :str          =	name.replace("""norm2"""	,			"""layernorm_after"""					)
		if "mlp.fc1" in name:
			UpperCamelCase     :Optional[Any]          =	name.replace("""mlp.fc1"""	,			"""intermediate.dense"""					)
		if "mlp.fc2" in name:
			UpperCamelCase     :Optional[int]          =	name.replace("""mlp.fc2"""	,			"""output.dense"""					)

		if name == "encoder.norm.weight":
			UpperCamelCase     :List[Any]          =	"""encoder.layernorm.weight"""
		if name == "encoder.norm.bias":
			UpperCamelCase     :Optional[Any]          =	"""encoder.layernorm.bias"""

	return name

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  Optional[Any]	,			__magic_name__					:  Tuple					)		->			Optional[int]:






	"""simple docstring"""



	for key in orig_state_dict.copy().keys():
		UpperCamelCase     :str          =	orig_state_dict.pop(__magic_name__					)

		if "qkv" in key:
			UpperCamelCase     :List[Any]          =	key.split("""."""					)
			UpperCamelCase     :Union[str, Any]          =	int(key_split[3]					)
			UpperCamelCase     :Optional[int]          =	int(key_split[5]					)
			UpperCamelCase     :List[Any]          =	model.encoder.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size

			if "weight" in key:
				UpperCamelCase     :Union[str, Any]          =	val[:dim, :]
				UpperCamelCase     :Any          =	val[dim : dim * 2, :]
				UpperCamelCase     :int          =	val[-dim:, :]
			else:
				UpperCamelCase     :Optional[int]          =	val[:dim]
				UpperCamelCase     :Union[str, Any]          =	val[dim : dim * 2]
				UpperCamelCase     :Any          =	val[-dim:]
		elif "attn_mask" in key or key in ["encoder.model.norm.weight", "encoder.model.norm.bias"]:
			# HuggingFace implementation doesn't use attn_mask buffer
			# and model doesn't use final LayerNorms for the encoder
			pass
		else:
			UpperCamelCase     :Optional[int]          =	val

	return orig_state_dict

def    SCREAMING_SNAKE_CASE_							(							__magic_name__					:  List[Any]	,			__magic_name__					:  str=None	,			__magic_name__					:  Union[str, Any]=False					)		->			Optional[int]:






	"""simple docstring"""



	UpperCamelCase     :Optional[int]          =	DonutModel.from_pretrained(__magic_name__					).eval()

	# load HuggingFace model
	UpperCamelCase     ,      UpperCamelCase     :int          =	get_configs(__magic_name__					)
	UpperCamelCase     :Tuple          =	DonutSwinModel(__magic_name__					)
	UpperCamelCase     :List[Any]          =	MBartForCausalLM(__magic_name__					)
	UpperCamelCase     :str          =	VisionEncoderDecoderModel(encoder=__magic_name__	,			decoder=__magic_name__					)
	model.eval()

	UpperCamelCase     :List[Any]          =	original_model.state_dict()
	UpperCamelCase     :Optional[int]          =	convert_state_dict(__magic_name__	,			__magic_name__					)
	model.load_state_dict(__magic_name__					)

	# verify results on scanned document
	UpperCamelCase     :int          =	load_dataset("""hf-internal-testing/example-documents"""					)
	UpperCamelCase     :Optional[int]          =	dataset["""test"""][0]["""image"""].convert("""RGB"""					)

	UpperCamelCase     :Optional[Any]          =	XLMRobertaTokenizerFast.from_pretrained(__magic_name__	,			from_slow=__magic_name__					)
	UpperCamelCase     :Optional[int]          =	DonutImageProcessor(
	    do_align_long_axis=original_model.config.align_long_axis	,			size=original_model.config.input_size[::-1]					)
	UpperCamelCase     :Dict          =	DonutProcessor(__magic_name__	,			__magic_name__					)
	UpperCamelCase     :List[str]          =	processor(__magic_name__	,			return_tensors="""pt"""					).pixel_values

	if model_name == "naver-clova-ix/donut-base-finetuned-docvqa":
		UpperCamelCase     :List[Any]          =	"""<s_docvqa><s_question>{user_input}</s_question><s_answer>"""
		UpperCamelCase     :str          =	"""When is the coffee break?"""
		UpperCamelCase     :Dict          =	task_prompt.replace("""{user_input}"""	,			__magic_name__					)
	elif model_name == "naver-clova-ix/donut-base-finetuned-rvlcdip":
		UpperCamelCase     :Optional[Any]          =	"""<s_rvlcdip>"""
	elif model_name in [
	    "naver-clova-ix/donut-base-finetuned-cord-v1",
	    "naver-clova-ix/donut-base-finetuned-cord-v1-2560",
	]:
		UpperCamelCase     :int          =	"""<s_cord>"""
	elif model_name == "naver-clova-ix/donut-base-finetuned-cord-v2":
		UpperCamelCase     :str          =	"""s_cord-v2>"""
	elif model_name == "naver-clova-ix/donut-base-finetuned-zhtrainticket":
		UpperCamelCase     :Optional[int]          =	"""<s_zhtrainticket>"""
	elif model_name in ["naver-clova-ix/donut-proto", "naver-clova-ix/donut-base"]:
		# use a random prompt
		UpperCamelCase     :List[str]          =	"""hello world"""
	else:
		raise ValueError("""Model name not supported"""					)
	UpperCamelCase     :Union[str, Any]          =	original_model.decoder.tokenizer(__magic_name__	,			add_special_tokens=__magic_name__	,			return_tensors="""pt"""					)[
	    """input_ids"""
	]

	UpperCamelCase     :Tuple          =	original_model.encoder.model.patch_embed(__magic_name__					)
	UpperCamelCase     ,      UpperCamelCase     :Dict          =	model.encoder.embeddings(__magic_name__					)
	assert torch.allclose(__magic_name__	,			__magic_name__	,			atol=1E-3					)

	# verify encoder hidden states
	UpperCamelCase     :List[str]          =	original_model.encoder(__magic_name__					)
	UpperCamelCase     :str          =	model.encoder(__magic_name__					).last_hidden_state
	assert torch.allclose(__magic_name__	,			__magic_name__	,			atol=1E-2					)

	# verify decoder hidden states
	UpperCamelCase     :str          =	original_model(__magic_name__	,			__magic_name__	,			__magic_name__					).logits
	UpperCamelCase     :List[str]          =	model(__magic_name__	,			decoder_input_ids=__magic_name__					).logits
	assert torch.allclose(__magic_name__	,			__magic_name__	,			atol=1E-3					)
	print("""Looks ok!"""					)

	if pytorch_dump_folder_path is not None:
		print(f"""Saving model and processor to {pytorch_dump_folder_path}"""					)
		model.save_pretrained(__magic_name__					)
		processor.save_pretrained(__magic_name__					)

	if push_to_hub:
		model.push_to_hub("""nielsr/""" + model_name.split("""/"""					)[-1]	,			commit_message="""Update model"""					)
		processor.push_to_hub("""nielsr/""" + model_name.split("""/"""					)[-1]	,			commit_message="""Update model"""					)


if __name__ == "__main__":
	UpperCAmelCase_ :						int      =      argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '''--model_name''',
	    default='''naver-clova-ix/donut-base-finetuned-docvqa''',
	    required=False,
	    type=str,
	    help='''Name of the original model you\'d like to convert.''',
	)
	parser.add_argument(
	    '''--pytorch_dump_folder_path''',
	    default=None,
	    required=False,
	    type=str,
	    help='''Path to the output PyTorch model directory.''',
	)
	parser.add_argument(
	    '''--push_to_hub''',
	    action='''store_true''',
	    help='''Whether or not to push the converted model and processor to the 🤗 hub.''',
	)

	UpperCAmelCase_ :						List[Any]      =      parser.parse_args()
	convert_donut_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

'''simple docstring'''

def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    Optional[int]  =					1
 for i in range(1		,     num + 1     ):
  fact *= i
 return fact
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    Optional[Any]  =					0
 while number > 0:
  lowercase__				:    str  =					number % 10
  sum_of_digits += last_digit
  lowercase__				:    List[str]  =					number // 10  # Removing the last_digit from the given number
 return sum_of_digits
def 			__UpperCamelCase       (   UpperCAmelCase = 100     ):
 lowercase__				:    Optional[int]  =					factorial(UpperCAmelCase     )
 lowercase__				:    Dict  =					split_and_add(UpperCAmelCase     )
 return result


if __name__ == "__main__":
  print(solution(int(input("""Enter the Number: """).strip())))

