
'''simple docstring'''







import argparse

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    CLIPTokenizer,
    CLIPTokenizerFast,
    VideoMAEImageProcessor,
    XCLIPConfig,
    XCLIPModel,
    XCLIPProcessor,
    XCLIPTextConfig,
    XCLIPVisionConfig,
)







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A			) ->			List[Any]:
	_snake_case     		=	XCLIPTextConfig()

	# derive patch size from model name
	_snake_case     		=	model_name.find('patch'			)
	_snake_case     		=	int(model_name[start_idx + len('patch'			) : start_idx + len('patch'			) + 2]			)
	_snake_case     		=	XCLIPVisionConfig(patch_size=_SCREAMING_SNAKE_CASE    ,       num_frames=_SCREAMING_SNAKE_CASE			)

	if "large" in model_name:
		_snake_case     		=	768
		_snake_case     		=	3_072
		_snake_case     		=	12

		_snake_case     		=	1_024
		_snake_case     		=	4_096
		_snake_case     		=	16
		_snake_case     		=	24
		_snake_case     		=	768
		_snake_case     		=	3_072

	if model_name == "xclip-large-patch14-16-frames":
		_snake_case     		=	336

	_snake_case     		=	XCLIPConfig.from_text_vision_configs(_SCREAMING_SNAKE_CASE    ,       _SCREAMING_SNAKE_CASE			)

	if "large" in model_name:
		_snake_case     		=	768

	return config







def        SCREAMING_SNAKE_CASE__			(     __A			) ->			Union[str, Any]:
	# text encoder
	if name == "token_embedding.weight":
		_snake_case     		=	name.replace('token_embedding.weight'    ,       'text_model.embeddings.token_embedding.weight'			)
	if name == "positional_embedding":
		_snake_case     		=	name.replace('positional_embedding'    ,       'text_model.embeddings.position_embedding.weight'			)
	if "ln_1" in name:
		_snake_case     		=	name.replace('ln_1'    ,       'layer_norm1'			)
	if "ln_2" in name:
		_snake_case     		=	name.replace('ln_2'    ,       'layer_norm2'			)
	if "c_fc" in name:
		_snake_case     		=	name.replace('c_fc'    ,       'fc1'			)
	if "c_proj" in name:
		_snake_case     		=	name.replace('c_proj'    ,       'fc2'			)
	if name.startswith('transformer.resblocks'			):
		_snake_case     		=	name.replace('transformer.resblocks'    ,       'text_model.encoder.layers'			)
	if "attn.out_proj" in name and "message" not in name:
		_snake_case     		=	name.replace('attn.out_proj'    ,       'self_attn.out_proj'			)
	if "ln_final" in name:
		_snake_case     		=	name.replace('ln_final'    ,       'text_model.final_layer_norm'			)
	# visual encoder
	if name == "visual.class_embedding":
		_snake_case     		=	name.replace('visual.class_embedding'    ,       'vision_model.embeddings.class_embedding'			)
	if name == "visual.positional_embedding":
		_snake_case     		=	name.replace('visual.positional_embedding'    ,       'vision_model.embeddings.position_embedding.weight'			)
	if name.startswith('visual.transformer.resblocks'			):
		_snake_case     		=	name.replace('visual.transformer.resblocks'    ,       'vision_model.encoder.layers'			)
	if "visual.conv1" in name:
		_snake_case     		=	name.replace('visual.conv1'    ,       'vision_model.embeddings.patch_embedding'			)
	if "visual.ln_pre" in name:
		_snake_case     		=	name.replace('visual.ln_pre'    ,       'vision_model.pre_layernorm'			)
	if "visual.ln_post" in name:
		_snake_case     		=	name.replace('visual.ln_post'    ,       'vision_model.post_layernorm'			)
	if "visual.proj" in name:
		_snake_case     		=	name.replace('visual.proj'    ,       'visual_projection.weight'			)
	if "text_projection" in name:
		_snake_case     		=	name.replace('text_projection'    ,       'text_projection.weight'			)
	# things on top
	if "prompts_visual_proj" in name:
		_snake_case     		=	name.replace('prompts_visual_proj'    ,       'prompts_visual_projection'			)
	if "prompts_visual_ln" in name:
		_snake_case     		=	name.replace('prompts_visual_ln'    ,       'prompts_visual_layernorm'			)
	# mit
	if name == "mit.positional_embedding":
		_snake_case     		=	name.replace('positional'    ,       'position'			)
	if name.startswith('mit.resblocks'			):
		_snake_case     		=	name.replace('mit.resblocks'    ,       'mit.encoder.layers'			)
	# prompts generator
	if name.startswith('prompts_generator.norm'			):
		_snake_case     		=	name.replace('prompts_generator.norm'    ,       'prompts_generator.layernorm'			)

	return name







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A			) ->			List[str]:
	for key in orig_state_dict.copy().keys():
		_snake_case     		=	orig_state_dict.pop(_SCREAMING_SNAKE_CASE			)

		if "attn.in_proj" in key:
			_snake_case     		=	key.split('.'			)
			if key.startswith('visual'			):
				_snake_case     		=	key_split[3]
				_snake_case     		=	config.vision_config.hidden_size
				if "message_attn" in key:
					if "weight" in key:
						_snake_case     		=	val[
						    :dim, :
						]
						_snake_case     		=	val[
						    dim : dim * 2, :
						]
						_snake_case     		=	val[
						    -dim:, :
						]
					else:
						_snake_case     		=	val[
						    :dim
						]
						_snake_case     		=	val[
						    dim : dim * 2
						]
						_snake_case     		=	val[
						    -dim:
						]
				else:
					if "weight" in key:
						_snake_case     		=	val[
						    :dim, :
						]
						_snake_case     		=	val[
						    dim : dim * 2, :
						]
						_snake_case     		=	val[
						    -dim:, :
						]
					else:
						_snake_case     		=	val[:dim]
						_snake_case     		=	val[
						    dim : dim * 2
						]
						_snake_case     		=	val[-dim:]
			elif key.startswith('mit'			):
				_snake_case     		=	key_split[2]
				_snake_case     		=	config.vision_config.mit_hidden_size
				if "weight" in key:
					_snake_case     		=	val[:dim, :]
					_snake_case     		=	val[dim : dim * 2, :]
					_snake_case     		=	val[-dim:, :]
				else:
					_snake_case     		=	val[:dim]
					_snake_case     		=	val[dim : dim * 2]
					_snake_case     		=	val[-dim:]
			else:
				_snake_case     		=	key_split[2]
				_snake_case     		=	config.text_config.hidden_size
				if "weight" in key:
					_snake_case     		=	val[:dim, :]
					_snake_case     		=	val[
					    dim : dim * 2, :
					]
					_snake_case     		=	val[-dim:, :]
				else:
					_snake_case     		=	val[:dim]
					_snake_case     		=	val[
					    dim : dim * 2
					]
					_snake_case     		=	val[-dim:]
		else:
			_snake_case     		=	rename_key(_SCREAMING_SNAKE_CASE			)
			if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
				_snake_case     		=	val.T
			_snake_case     		=	val

	return orig_state_dict







def        SCREAMING_SNAKE_CASE__			(     __A			) ->			str:
	if num_frames == 8:
		_snake_case     		=	'eating_spaghetti_8_frames.npy'
	elif num_frames == 16:
		_snake_case     		=	'eating_spaghetti.npy'
	elif num_frames == 32:
		_snake_case     		=	'eating_spaghetti_32_frames.npy'
	_snake_case     		=	hf_hub_download(
	    repo_id='hf-internal-testing/spaghetti-video'    ,       filename=_SCREAMING_SNAKE_CASE    ,       repo_type='dataset'    ,       )
	_snake_case     		=	np.load(_SCREAMING_SNAKE_CASE			)
	return list(_SCREAMING_SNAKE_CASE			)







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A=None    ,       __A=False			) ->			List[str]:
	_snake_case     		=	{
	    # fully supervised kinetics-400 checkpoints
	    'xclip-base-patch32': 'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth',
	    'xclip-base-patch32-16-frames': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth'
	    ),
	    'xclip-base-patch16': 'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth',
	    'xclip-base-patch16-16-frames': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth'
	    ),
	    'xclip-large-patch14': 'https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb',
	    'xclip-large-patch14-16-frames': 'https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f',
	    # fully supervised kinetics-600 checkpoints
	    'xclip-base-patch16-kinetics-600': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth'
	    ),
	    'xclip-base-patch16-kinetics-600-16-frames': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth'
	    ),
	    'xclip-large-patch14-kinetics-600': 'https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be',
	    # few shot
	    'xclip-base-patch16-hmdb-2-shot': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth'
	    ),
	    'xclip-base-patch16-hmdb-4-shot': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth'
	    ),
	    'xclip-base-patch16-hmdb-8-shot': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth'
	    ),
	    'xclip-base-patch16-hmdb-16-shot': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth'
	    ),
	    'xclip-base-patch16-ucf-2-shot': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth'
	    ),
	    'xclip-base-patch16-ucf-4-shot': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth'
	    ),
	    'xclip-base-patch16-ucf-8-shot': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth'
	    ),
	    'xclip-base-patch16-ucf-16-shot': (
	        'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth'
	    ),
	    # zero shot
	    'xclip-base-patch16-zero-shot': 'https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth',
	}

	_snake_case     		=	model_to_url[model_name]
	_snake_case     		=	8
	if "16-frames" in model_name:
		_snake_case     		=	16
	elif "shot" in model_name:
		_snake_case     		=	32

	_snake_case     		=	get_xclip_config(_SCREAMING_SNAKE_CASE    ,       _SCREAMING_SNAKE_CASE			)
	_snake_case     		=	XCLIPModel(_SCREAMING_SNAKE_CASE			)
	model.eval()

	if "drive" in checkpoint_url:
		_snake_case     		=	'pytorch_model.bin'
		gdown.cached_download(_SCREAMING_SNAKE_CASE    ,       _SCREAMING_SNAKE_CASE    ,       quiet=_SCREAMING_SNAKE_CASE			)
		_snake_case     		=	torch.load(_SCREAMING_SNAKE_CASE    ,       map_location='cpu'			)['model']
	else:
		_snake_case     		=	torch.hub.load_state_dict_from_url(_SCREAMING_SNAKE_CASE			)['model']

	_snake_case     		=	convert_state_dict(_SCREAMING_SNAKE_CASE    ,       _SCREAMING_SNAKE_CASE			)

	_snake_case     		=	XCLIPModel(_SCREAMING_SNAKE_CASE			)
	_snake_case		,				_snake_case     		=	model.load_state_dict(_SCREAMING_SNAKE_CASE    ,       strict=_SCREAMING_SNAKE_CASE			)
	assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
	model.eval()

	_snake_case     		=	336 if model_name == 'xclip-large-patch14-16-frames' else 224
	_snake_case     		=	VideoMAEImageProcessor(size=_SCREAMING_SNAKE_CASE			)
	_snake_case     		=	CLIPTokenizer.from_pretrained('openai/clip-vit-base-patch32'			)
	_snake_case     		=	CLIPTokenizerFast.from_pretrained('openai/clip-vit-base-patch32'			)
	_snake_case     		=	XCLIPProcessor(image_processor=_SCREAMING_SNAKE_CASE    ,       tokenizer=_SCREAMING_SNAKE_CASE			)

	_snake_case     		=	prepare_video(_SCREAMING_SNAKE_CASE			)
	_snake_case     		=	processor(
	    text=['playing sports', 'eating spaghetti', 'go shopping']    ,       videos=_SCREAMING_SNAKE_CASE    ,       return_tensors='pt'    ,       padding=_SCREAMING_SNAKE_CASE			)

	print('Shape of pixel values:'    ,       inputs.pixel_values.shape			)

	with torch.no_grad():
		_snake_case     		=	model(**_SCREAMING_SNAKE_CASE			)

	# Verify outputs
	_snake_case     		=	outputs.logits_per_video
	_snake_case     		=	logits_per_video.softmax(dim=1			)
	print('Probs:'    ,       _SCREAMING_SNAKE_CASE			)
	# kinetics-400
	if model_name == "xclip-base-patch32":
		_snake_case     		=	torch.tensor([[0.0_0_1_9, 0.9_9_5_1, 0.0_0_3_0]]			)
	elif model_name == "xclip-base-patch32-16-frames":
		_snake_case     		=	torch.tensor([[7.0999e-04, 9.9883e-01, 4.5580e-04]]			)
	elif model_name == "xclip-base-patch16":
		_snake_case     		=	torch.tensor([[0.0_0_8_3, 0.9_6_8_1, 0.0_2_3_6]]			)
	elif model_name == "xclip-base-patch16-16-frames":
		_snake_case     		=	torch.tensor([[7.6937e-04, 9.9728e-01, 1.9473e-03]]			)
	elif model_name == "xclip-large-patch14":
		_snake_case     		=	torch.tensor([[0.0_0_6_2, 0.9_8_6_4, 0.0_0_7_5]]			)
	elif model_name == "xclip-large-patch14-16-frames":
		_snake_case     		=	torch.tensor([[3.3877e-04, 9.9937e-01, 2.8888e-04]]			)
	# kinetics-600
	elif model_name == "xclip-base-patch16-kinetics-600":
		_snake_case     		=	torch.tensor([[0.0_5_5_5, 0.8_9_1_4, 0.0_5_3_1]]			)
	elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
		_snake_case     		=	torch.tensor([[3.8554e-04, 9.9929e-01, 3.2754e-04]]			)
	elif model_name == "xclip-large-patch14-kinetics-600":
		_snake_case     		=	torch.tensor([[0.0_0_3_6, 0.9_9_2_0, 0.0_0_4_5]]			)
	# few shot
	elif model_name == "xclip-base-patch16-hmdb-2-shot":
		_snake_case     		=	torch.tensor([[7.1890e-06, 9.9994e-01, 5.6559e-05]]			)
	elif model_name == "xclip-base-patch16-hmdb-4-shot":
		_snake_case     		=	torch.tensor([[1.0320e-05, 9.9993e-01, 6.2435e-05]]			)
	elif model_name == "xclip-base-patch16-hmdb-8-shot":
		_snake_case     		=	torch.tensor([[4.1377e-06, 9.9990e-01, 9.8386e-05]]			)
	elif model_name == "xclip-base-patch16-hmdb-16-shot":
		_snake_case     		=	torch.tensor([[4.1347e-05, 9.9962e-01, 3.3411e-04]]			)
	elif model_name == "xclip-base-patch16-ucf-2-shot":
		_snake_case     		=	torch.tensor([[8.5857e-05, 9.9928e-01, 6.3291e-04]]			)
	elif model_name == "xclip-base-patch16-ucf-4-shot":
		_snake_case     		=	torch.tensor([[8.5857e-05, 9.9928e-01, 6.3291e-04]]			)
	elif model_name == "xclip-base-patch16-ucf-8-shot":
		_snake_case     		=	torch.tensor([[0.0_0_2_7, 0.9_9_0_4, 0.0_0_7_0]]			)
	elif model_name == "xclip-base-patch16-ucf-16-shot":
		_snake_case     		=	torch.tensor([[9.8219e-04, 9.9593e-01, 3.0863e-03]]			)
	# zero shot
	elif model_name == "xclip-base-patch16-zero-shot":
		_snake_case     		=	torch.tensor([[3.5082e-04, 9.9785e-01, 1.7966e-03]]			)
	else:
		raise ValueError(F'Model name {model_name} not supported'			)
	assert torch.allclose(_SCREAMING_SNAKE_CASE    ,       _SCREAMING_SNAKE_CASE    ,       atol=1e-3			)
	print('Looks ok!'			)

	if pytorch_dump_folder_path is not None:
		print(F'Saving model {model_name} to {pytorch_dump_folder_path}'			)
		model.save_pretrained(_SCREAMING_SNAKE_CASE			)

	if push_to_hub:
		print('Pushing model, processor and slow tokenizer files to the hub...'			)
		model.push_to_hub(_SCREAMING_SNAKE_CASE    ,       organization='nielsr'			)
		processor.push_to_hub(_SCREAMING_SNAKE_CASE    ,       organization='nielsr'			)
		slow_tokenizer.push_to_hub(_SCREAMING_SNAKE_CASE    ,       organization='nielsr'			)


if __name__ == "__main__":
					lowercase					:							Dict   =      argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    "--model_name",
					    default="xclip-base-patch32",
					    type=str,
					    help="Name of the model.",
					)
					parser.add_argument(
					    "--pytorch_dump_folder_path", default=None, 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 to the 🤗 hub."
					)

					lowercase					:							Dict   =      parser.parse_args()
					convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)



'''simple docstring'''







import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


lowercase					:							str   =      version.parse(importlib_metadata.version("nltk"))
if NLTK_VERSION >= version.Version("3.6.4"):
					from nltk import word_tokenize


lowercase					:							int   =      "\\n@inproceedings{banarjee2005,\n  title     = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n  author    = {Banerjee, Satanjeev  and Lavie, Alon},\n  booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n  month     = jun,\n  year      = {2005},\n  address   = {Ann Arbor, Michigan},\n  publisher = {Association for Computational Linguistics},\n  url       = {https://www.aclweb.org/anthology/W05-0909},\n  pages     = {65--72},\n}\n"

lowercase					:							Any   =      "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n"

lowercase					:							Optional[Any]   =      "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n    predictions: list of predictions to score. Each prediction\n        should be a string with tokens separated by spaces.\n    references: list of reference for each prediction. Each\n        reference should be a string with tokens separated by spaces.\n    alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n    beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n    gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n    'meteor': meteor score.\nExamples:\n\n    >>> meteor = datasets.load_metric('meteor')\n    >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n    >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n    >>> results = meteor.compute(predictions=predictions, references=references)\n    >>> print(round(results[\"meteor\"], 4))\n    0.6944\n"


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION		,     _KWARGS_DESCRIPTION		)
class 		__UpperCAmelCase   (      datasets.Metric		):


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								return datasets.MetricInfo(
								    description=_DESCRIPTION					,     citation=_CITATION					,     inputs_description=_KWARGS_DESCRIPTION					,     features=datasets.Features(
								        {
								            'predictions': datasets.Value('string'					,     id='sequence'						),
								            'references': datasets.Value('string'					,     id='sequence'						),
								        }						)					,     codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py']					,     reference_urls=[
								        'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score',
								        'https://en.wikipedia.org/wiki/METEOR',
								    ]					,     )


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								import nltk

								nltk.download('wordnet'						)
								if NLTK_VERSION >= version.Version('3.6.5'						):
									nltk.download('punkt'						)
								if NLTK_VERSION >= version.Version('3.6.6'						):
									nltk.download('omw-1.4'						)




							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_=0.9					,     lowerCAmelCase_=3					,     lowerCAmelCase_=0.5						):





								"""simple docstring"""






								if NLTK_VERSION >= version.Version('3.6.5'						):
									_snake_case     		=	[
									    meteor_score.single_meteor_score(
									        word_tokenize(lowerCAmelCase_						)					,     word_tokenize(lowerCAmelCase_						)					,     alpha=lowerCAmelCase_					,     beta=lowerCAmelCase_					,     gamma=lowerCAmelCase_						)
									    for ref, pred in zip(lowerCAmelCase_					,     lowerCAmelCase_						)
									]
								else:
									_snake_case     		=	[
									    meteor_score.single_meteor_score(lowerCAmelCase_					,     lowerCAmelCase_					,     alpha=lowerCAmelCase_					,     beta=lowerCAmelCase_					,     gamma=lowerCAmelCase_						)
									    for ref, pred in zip(lowerCAmelCase_					,     lowerCAmelCase_						)
									]

								return {"meteor": np.mean(lowerCAmelCase_						)}

