






import argparse
import json
from collections import OrderedDict
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import PoolFormerConfig, PoolFormerForImageClassification, PoolFormerImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
a_		:						int             =    logging.get_logger(__name__)






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase							,       _UpperCAmelCase							,       _UpperCAmelCase):

			'''simple docstring'''





			SCREAMING_SNAKE_CASE						= original_name.split('.')[0]
			SCREAMING_SNAKE_CASE						= key.split('.')
			SCREAMING_SNAKE_CASE						= int(key_list[key_list.index(_UpperCAmelCase) - 2])
			SCREAMING_SNAKE_CASE						= int(key_list[key_list.index(_UpperCAmelCase) - 1])
			SCREAMING_SNAKE_CASE						= orig_block_num - offset

			SCREAMING_SNAKE_CASE						= key.replace(F'''{orig_block_num}.{layer_num}.{original_name}'''							,       F'''block.{new_block_num}.{layer_num}.{new_name}''')
			return key






def 				lowerCamelCase__				(_UpperCAmelCase):

			'''simple docstring'''





			SCREAMING_SNAKE_CASE						= OrderedDict()
			SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						= 0, 0
			for key, value in state_dict.items():
						if key.startswith('network'):
									SCREAMING_SNAKE_CASE						= key.replace('network'							,       'poolformer.encoder')
						if "proj" in key:
									# Works for the first embedding as well as the internal embedding layers
									if key.endswith('bias') and "patch_embed" not in key:
												patch_emb_offset += 1
									SCREAMING_SNAKE_CASE						= key[: key.find('proj')]
									SCREAMING_SNAKE_CASE						= key.replace(_UpperCAmelCase							,       F'''patch_embeddings.{total_embed_found}.''')
									SCREAMING_SNAKE_CASE						= key.replace('proj'							,       'projection')
									if key.endswith('bias'):
												total_embed_found += 1
						if "patch_embeddings" in key:
									SCREAMING_SNAKE_CASE						= 'poolformer.encoder.' + key
						if "mlp.fc1" in key:
									SCREAMING_SNAKE_CASE						= replace_key_with_offset(_UpperCAmelCase							,       _UpperCAmelCase							,       'mlp.fc1'							,       'output.conv1')
						if "mlp.fc2" in key:
									SCREAMING_SNAKE_CASE						= replace_key_with_offset(_UpperCAmelCase							,       _UpperCAmelCase							,       'mlp.fc2'							,       'output.conv2')
						if "norm1" in key:
									SCREAMING_SNAKE_CASE						= replace_key_with_offset(_UpperCAmelCase							,       _UpperCAmelCase							,       'norm1'							,       'before_norm')
						if "norm2" in key:
									SCREAMING_SNAKE_CASE						= replace_key_with_offset(_UpperCAmelCase							,       _UpperCAmelCase							,       'norm2'							,       'after_norm')
						if "layer_scale_1" in key:
									SCREAMING_SNAKE_CASE						= replace_key_with_offset(_UpperCAmelCase							,       _UpperCAmelCase							,       'layer_scale_1'							,       'layer_scale_1')
						if "layer_scale_2" in key:
									SCREAMING_SNAKE_CASE						= replace_key_with_offset(_UpperCAmelCase							,       _UpperCAmelCase							,       'layer_scale_2'							,       'layer_scale_2')
						if "head" in key:
									SCREAMING_SNAKE_CASE						= key.replace('head'							,       'classifier')
						SCREAMING_SNAKE_CASE						= value
			return new_state_dict






def 				lowerCamelCase__				():

			'''simple docstring'''





			SCREAMING_SNAKE_CASE						= 'http://images.cocodataset.org/val2017/000000039769.jpg'
			SCREAMING_SNAKE_CASE						= Image.open(requests.get(_UpperCAmelCase							,       stream=_UpperCAmelCase).raw)

			return image






@torch.no_grad()
def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase							,       _UpperCAmelCase):

			'''simple docstring'''





			SCREAMING_SNAKE_CASE						= PoolFormerConfig()

			# set attributes based on model_name
			SCREAMING_SNAKE_CASE						= 'huggingface/label-files'
			SCREAMING_SNAKE_CASE						= model_name[-3:]
			SCREAMING_SNAKE_CASE						= 1000
			SCREAMING_SNAKE_CASE						= 'imagenet-1k-id2label.json'
			SCREAMING_SNAKE_CASE						= (1, 1000)

			# set config attributes
			SCREAMING_SNAKE_CASE						= json.load(open(hf_hub_download(_UpperCAmelCase							,       _UpperCAmelCase							,       repo_type='dataset')							,       'r'))
			SCREAMING_SNAKE_CASE						= {int(_UpperCAmelCase): v for k, v in idalabel.items()}
			SCREAMING_SNAKE_CASE						= idalabel
			SCREAMING_SNAKE_CASE						= {v: k for k, v in idalabel.items()}
			if size == "s12":
						SCREAMING_SNAKE_CASE						= [2, 2, 6, 2]
						SCREAMING_SNAKE_CASE						= [64, 128, 320, 512]
						SCREAMING_SNAKE_CASE						= 4.0
						SCREAMING_SNAKE_CASE						= 0.9
			elif size == "s24":
						SCREAMING_SNAKE_CASE						= [4, 4, 12, 4]
						SCREAMING_SNAKE_CASE						= [64, 128, 320, 512]
						SCREAMING_SNAKE_CASE						= 4.0
						SCREAMING_SNAKE_CASE						= 0.9
			elif size == "s36":
						SCREAMING_SNAKE_CASE						= [6, 6, 18, 6]
						SCREAMING_SNAKE_CASE						= [64, 128, 320, 512]
						SCREAMING_SNAKE_CASE						= 4.0
						SCREAMING_SNAKE_CASE						= 1e-6
						SCREAMING_SNAKE_CASE						= 0.9
			elif size == "m36":
						SCREAMING_SNAKE_CASE						= [6, 6, 18, 6]
						SCREAMING_SNAKE_CASE						= [96, 192, 384, 768]
						SCREAMING_SNAKE_CASE						= 4.0
						SCREAMING_SNAKE_CASE						= 1e-6
						SCREAMING_SNAKE_CASE						= 0.95
			elif size == "m48":
						SCREAMING_SNAKE_CASE						= [8, 8, 24, 8]
						SCREAMING_SNAKE_CASE						= [96, 192, 384, 768]
						SCREAMING_SNAKE_CASE						= 4.0
						SCREAMING_SNAKE_CASE						= 1e-6
						SCREAMING_SNAKE_CASE						= 0.95
			else:
						raise ValueError(F'''Size {size} not supported''')

			# load image processor
			SCREAMING_SNAKE_CASE						= PoolFormerImageProcessor(crop_pct=_UpperCAmelCase)

			# Prepare image
			SCREAMING_SNAKE_CASE						= prepare_img()
			SCREAMING_SNAKE_CASE						= image_processor(images=_UpperCAmelCase							,       return_tensors='pt').pixel_values

			logger.info(F'''Converting model {model_name}...''')

			# load original state dict
			SCREAMING_SNAKE_CASE						= torch.load(_UpperCAmelCase							,       map_location=torch.device('cpu'))

			# rename keys
			SCREAMING_SNAKE_CASE						= rename_keys(_UpperCAmelCase)

			# create HuggingFace model and load state dict
			SCREAMING_SNAKE_CASE						= PoolFormerForImageClassification(_UpperCAmelCase)
			model.load_state_dict(_UpperCAmelCase)
			model.eval()

			# Define image processor
			SCREAMING_SNAKE_CASE						= PoolFormerImageProcessor(crop_pct=_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= image_processor(images=prepare_img()							,       return_tensors='pt').pixel_values

			# forward pass
			SCREAMING_SNAKE_CASE						= model(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= outputs.logits

			# define expected logit slices for different models
			if size == "s12":
						SCREAMING_SNAKE_CASE						= torch.tensor([-0.30_45, -0.67_58, -0.48_69])
			elif size == "s24":
						SCREAMING_SNAKE_CASE						= torch.tensor([0.44_02, -0.13_74, -0.80_45])
			elif size == "s36":
						SCREAMING_SNAKE_CASE						= torch.tensor([-0.60_80, -0.51_33, -0.58_98])
			elif size == "m36":
						SCREAMING_SNAKE_CASE						= torch.tensor([0.39_52, 0.22_63, -1.26_68])
			elif size == "m48":
						SCREAMING_SNAKE_CASE						= torch.tensor([0.11_67, -0.06_56, -0.34_23])
			else:
						raise ValueError(F'''Size {size} not supported''')

			# verify logits
			assert logits.shape == expected_shape
			assert torch.allclose(logits[0, :3]							,       _UpperCAmelCase							,       atol=1e-2)

			# finally, save model and image processor
			logger.info(F'''Saving PyTorch model and image processor to {pytorch_dump_folder_path}...''')
			Path(_UpperCAmelCase).mkdir(exist_ok=_UpperCAmelCase)
			model.save_pretrained(_UpperCAmelCase)
			print(F'''Saving image processor to {pytorch_dump_folder_path}''')
			image_processor.save_pretrained(_UpperCAmelCase)


if __name__ == "__main__":
				a_		:						Tuple             =    argparse.ArgumentParser()

				parser.add_argument(
				    '--model_name',
				    default='poolformer_s12',
				    type=str,
				    help='Name of the model you\'d like to convert.',
				)
				parser.add_argument(
				    '--checkpoint_path', default=None, type=str, help='Path to the original PyTorch checkpoint (.pth file).'
				)
				parser.add_argument(
				    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the folder to output PyTorch model.'
				)
				a_		:						int             =    parser.parse_args()
				convert_poolformer_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path)












import unittest

from transformers import DebertaVaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import (
				    DebertaVaForMaskedLM,
				    DebertaVaForMultipleChoice,
				    DebertaVaForQuestionAnswering,
				    DebertaVaForSequenceClassification,
				    DebertaVaForTokenClassification,
				    DebertaVaModel,
				)
				from transformers.models.deberta_va.modeling_deberta_va import DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST

class 		_snake_case  (  A__					):






			def __init__(       self		,					a		,					a=13		,					a=7		,					a=True		,					a=True		,					a=True		,					a=True		,					a=99		,					a=32		,					a=5		,					a=4		,					a=37		,					a="gelu"		,					a=0.1		,					a=0.1		,					a=512		,					a=16		,					a=2		,					a=0.02		,					a=False		,					a=True		,					a="None"		,					a=3		,					a=4		,					a=None		,					)      ->       int:
						SCREAMING_SNAKE_CASE						= parent
						SCREAMING_SNAKE_CASE						= batch_size
						SCREAMING_SNAKE_CASE						= seq_length
						SCREAMING_SNAKE_CASE						= is_training
						SCREAMING_SNAKE_CASE						= use_input_mask
						SCREAMING_SNAKE_CASE						= use_token_type_ids
						SCREAMING_SNAKE_CASE						= use_labels
						SCREAMING_SNAKE_CASE						= vocab_size
						SCREAMING_SNAKE_CASE						= hidden_size
						SCREAMING_SNAKE_CASE						= num_hidden_layers
						SCREAMING_SNAKE_CASE						= num_attention_heads
						SCREAMING_SNAKE_CASE						= intermediate_size
						SCREAMING_SNAKE_CASE						= hidden_act
						SCREAMING_SNAKE_CASE						= hidden_dropout_prob
						SCREAMING_SNAKE_CASE						= attention_probs_dropout_prob
						SCREAMING_SNAKE_CASE						= max_position_embeddings
						SCREAMING_SNAKE_CASE						= type_vocab_size
						SCREAMING_SNAKE_CASE						= type_sequence_label_size
						SCREAMING_SNAKE_CASE						= initializer_range
						SCREAMING_SNAKE_CASE						= num_labels
						SCREAMING_SNAKE_CASE						= num_choices
						SCREAMING_SNAKE_CASE						= relative_attention
						SCREAMING_SNAKE_CASE						= position_biased_input
						SCREAMING_SNAKE_CASE						= pos_att_type
						SCREAMING_SNAKE_CASE						= scope






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       List[str]:
						SCREAMING_SNAKE_CASE						= ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size)

						SCREAMING_SNAKE_CASE						= None
						if self.use_input_mask:
									SCREAMING_SNAKE_CASE						= ids_tensor([self.batch_size, self.seq_length]		,					vocab_size=2)

						SCREAMING_SNAKE_CASE						= None
						if self.use_token_type_ids:
									SCREAMING_SNAKE_CASE						= ids_tensor([self.batch_size, self.seq_length]		,					self.type_vocab_size)

						SCREAMING_SNAKE_CASE						= None
						SCREAMING_SNAKE_CASE						= None
						SCREAMING_SNAKE_CASE						= None
						if self.use_labels:
									SCREAMING_SNAKE_CASE						= ids_tensor([self.batch_size]		,					self.type_sequence_label_size)
									SCREAMING_SNAKE_CASE						= ids_tensor([self.batch_size, self.seq_length]		,					self.num_labels)
									SCREAMING_SNAKE_CASE						= ids_tensor([self.batch_size]		,					self.num_choices)

						SCREAMING_SNAKE_CASE						= self.get_config()

						return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       int:
						return DebertaVaConfig(
						    vocab_size=self.vocab_size		,					hidden_size=self.hidden_size		,					num_hidden_layers=self.num_hidden_layers		,					num_attention_heads=self.num_attention_heads		,					intermediate_size=self.intermediate_size		,					hidden_act=self.hidden_act		,					hidden_dropout_prob=self.hidden_dropout_prob		,					attention_probs_dropout_prob=self.attention_probs_dropout_prob		,					max_position_embeddings=self.max_position_embeddings		,					type_vocab_size=self.type_vocab_size		,					initializer_range=self.initializer_range		,					relative_attention=self.relative_attention		,					position_biased_input=self.position_biased_input		,					pos_att_type=self.pos_att_type		,					)






			def    SCREAMING_SNAKE_CASE__    (       self		,					a)      ->       int:
						self.parent.assertListEqual(list(result.loss.size())		,					[])






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a		,					a		,					a		,					a		,					a)      ->       int:
						SCREAMING_SNAKE_CASE						= DebertaVaModel(config=a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= model(a		,					attention_mask=a		,					token_type_ids=a)[0]
						SCREAMING_SNAKE_CASE						= model(a		,					token_type_ids=a)[0]
						SCREAMING_SNAKE_CASE						= model(a)[0]

						self.parent.assertListEqual(list(sequence_output.size())		,					[self.batch_size, self.seq_length, self.hidden_size])






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a		,					a		,					a		,					a		,					a)      ->       Dict:
						SCREAMING_SNAKE_CASE						= DebertaVaForMaskedLM(config=a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= model(a		,					attention_mask=a		,					token_type_ids=a		,					labels=a)

						self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.seq_length, self.vocab_size))






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a		,					a		,					a		,					a		,					a)      ->       str:
						SCREAMING_SNAKE_CASE						= self.num_labels
						SCREAMING_SNAKE_CASE						= DebertaVaForSequenceClassification(a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= model(a		,					attention_mask=a		,					token_type_ids=a		,					labels=a)
						self.parent.assertListEqual(list(result.logits.size())		,					[self.batch_size, self.num_labels])
						self.check_loss_output(a)






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a		,					a		,					a		,					a		,					a)      ->       int:
						SCREAMING_SNAKE_CASE						= self.num_labels
						SCREAMING_SNAKE_CASE						= DebertaVaForTokenClassification(config=a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= model(a		,					attention_mask=a		,					token_type_ids=a		,					labels=a)
						self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.seq_length, self.num_labels))






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a		,					a		,					a		,					a		,					a)      ->       Optional[int]:
						SCREAMING_SNAKE_CASE						= DebertaVaForQuestionAnswering(config=a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= model(
						    a		,					attention_mask=a		,					token_type_ids=a		,					start_positions=a		,					end_positions=a		,					)
						self.parent.assertEqual(result.start_logits.shape		,					(self.batch_size, self.seq_length))
						self.parent.assertEqual(result.end_logits.shape		,					(self.batch_size, self.seq_length))






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a		,					a		,					a		,					a		,					a)      ->       Any:
						SCREAMING_SNAKE_CASE						= DebertaVaForMultipleChoice(config=a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= input_ids.unsqueeze(1).expand(-1		,					self.num_choices		,					-1).contiguous()
						SCREAMING_SNAKE_CASE						= token_type_ids.unsqueeze(1).expand(-1		,					self.num_choices		,					-1).contiguous()
						SCREAMING_SNAKE_CASE						= input_mask.unsqueeze(1).expand(-1		,					self.num_choices		,					-1).contiguous()
						SCREAMING_SNAKE_CASE						= model(
						    a		,					attention_mask=a		,					token_type_ids=a		,					labels=a		,					)
						self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_choices))







			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Optional[int]:
						SCREAMING_SNAKE_CASE						= self.prepare_config_and_inputs()
						(
						    (
						    SCREAMING_SNAKE_CASE
						)				,						(
						    SCREAMING_SNAKE_CASE
						)				,						(
						    SCREAMING_SNAKE_CASE
						)				,						(
						    SCREAMING_SNAKE_CASE
						)				,						(
						    SCREAMING_SNAKE_CASE
						)				,						(
						    SCREAMING_SNAKE_CASE
						)				,						(
						    SCREAMING_SNAKE_CASE
						)				,						
						)						= config_and_inputs
						SCREAMING_SNAKE_CASE						= {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
						return config, inputs_dict



@require_torch
class 		_snake_case  (  A__   ,    A__   ,    unittest.TestCase					):
			_lowercase		:    Dict			     =							(
			    (
			        DebertaVaModel,
			        DebertaVaForMaskedLM,
			        DebertaVaForSequenceClassification,
			        DebertaVaForTokenClassification,
			        DebertaVaForQuestionAnswering,
			        DebertaVaForMultipleChoice,
			    )
			    if is_torch_available()
			    else ()
			)
			_lowercase		:    Optional[int]			     =							(
			    {
			        '''feature-extraction''': DebertaVaModel,
			        '''fill-mask''': DebertaVaForMaskedLM,
			        '''question-answering''': DebertaVaForQuestionAnswering,
			        '''text-classification''': DebertaVaForSequenceClassification,
			        '''token-classification''': DebertaVaForTokenClassification,
			        '''zero-shot''': DebertaVaForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)

			_lowercase		:    Optional[int]			     =							True
			_lowercase		:    int			     =							False
			_lowercase		:    Dict			     =							False
			_lowercase		:    Optional[int]			     =							False
			_lowercase		:    List[str]			     =							False






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Optional[int]:
						SCREAMING_SNAKE_CASE						= DebertaVaModelTester(self)
						SCREAMING_SNAKE_CASE						= ConfigTester(self		,					config_class=a		,					hidden_size=37)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Dict:
						self.config_tester.run_common_tests()






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Tuple:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_model(*a)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       List[Any]:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_sequence_classification(*a)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Dict:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_masked_lm(*a)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Union[str, Any]:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_question_answering(*a)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       int:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_token_classification(*a)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Union[str, Any]:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_multiple_choice(*a)







			@slow
			def    SCREAMING_SNAKE_CASE__    (       self)      ->       str:
						for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE						= DebertaVaModel.from_pretrained(a)
									self.assertIsNotNone(a)



@require_torch
@require_sentencepiece
@require_tokenizers
class 		_snake_case  (  unittest.TestCase					):






			@unittest.skip(reason='Model not available yet')
			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Union[str, Any]:
						pass







			@slow
			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Union[str, Any]:
						SCREAMING_SNAKE_CASE						= DebertaVaModel.from_pretrained('microsoft/deberta-v2-xlarge')

						SCREAMING_SNAKE_CASE						= torch.tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]])
						SCREAMING_SNAKE_CASE						= torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
						with torch.no_grad():
									SCREAMING_SNAKE_CASE						= model(a		,					attention_mask=a)[0]
						# compare the actual values for a slice.
						SCREAMING_SNAKE_CASE						= torch.tensor(
						    [[[0.23_56, 0.19_48, 0.03_69], [-0.10_63, 0.35_86, -0.51_52], [-0.63_99, -0.02_59, -0.25_25]]])
						self.assertTrue(torch.allclose(output[:, 1:4, 1:4]		,					a		,					atol=1E-4)		,					f'''{output[:, 1:4, 1:4]}''')




