
import gc
import importlib.metadata
import tempfile
import unittest

from packaging import version

from transformers import (
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    BitsAndBytesConfig,
    pipeline,
)
from transformers.testing_utils import (
    is_torch_available,
    require_accelerate,
    require_bitsandbytes,
    require_torch,
    require_torch_gpu,
    require_torch_multi_gpu,
    slow,
)







def     A__   (  lowerCamelCase  )					->		Any:
				if model.config.model_type == "gpt2":
								return model.transformer.h[0].mlp.c_fc
				return model.transformer.h[0].mlp.dense_ah_to_h


if is_torch_available():
							import torch
							import torch.nn as nn

							class     _UpperCamelCase			(   nn.Module					):






										'''simple docstring'''

										def __init__(    self	:    Any  ,		snake_case_	:    nn.Module  ,		snake_case_	:    int ):
														super().__init__()
														UpperCamelCase_:							str		=  module
														UpperCamelCase_:							Optional[int]		=  nn.Sequential(
														    nn.Linear(module.in_features  ,		snake_case_  ,		bias=snake_case_ )  ,		nn.Linear(snake_case_  ,		module.out_features  ,		bias=snake_case_ )  ,		)
														UpperCamelCase_:							Union[str, Any]		=  (2.0 / (5 * min(module.in_features  ,		module.out_features ))) ** 0.5
														nn.init.normal_(self.adapter[0].weight  ,		std=snake_case_ )
														nn.init.zeros_(self.adapter[1].weight )
														self.adapter.to(module.weight.device )




										def  lowerCAmelCase__		(    self	:    Any  ,		snake_case_	:    int  ,		*snake_case_	:    List[Any]  ,		**snake_case_	:    Union[str, Any] ):
														return self.module(snake_case_  ,		*snake_case_  ,		**snake_case_ ) + self.adapter(snake_case_ )

@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class     _UpperCamelCase			(   unittest.TestCase					):






			'''simple docstring'''

			__UpperCamelCase :  List[Any]    =	"""bigscience/bloom-1b7"""

			# Constant values
			__UpperCamelCase :  Optional[Any]    =	2.109_659_552_692_574

			__UpperCamelCase :  List[Any]    =	"""Hello my name is"""
			__UpperCamelCase :  Dict    =	set()
			EXPECTED_OUTPUTS.add("""Hello my name is John and I am a professional photographer. I"""					)
			EXPECTED_OUTPUTS.add("""Hello my name is John.\nI am a friend of your father.\n"""					)
			EXPECTED_OUTPUTS.add("""Hello my name is John Doe, I am a student at the University"""					)
			__UpperCamelCase :  List[str]    =	10

			def  lowerCAmelCase__		(    self	:    Dict ):
							# Models and tokenizer
							UpperCamelCase_:							Any		=  AutoTokenizer.from_pretrained(self.model_name )




class     _UpperCamelCase			(   _A					):






			'''simple docstring'''

			def  lowerCAmelCase__		(    self	:    Optional[Any] ):
							super().setUp()

							# Models and tokenizer
							UpperCamelCase_:							Optional[int]		=  AutoModelForCausalLM.from_pretrained(
							    self.model_name  ,		torch_dtype=torch.floataa  ,		device_map="""auto""" )
							UpperCamelCase_:							Union[str, Any]		=  AutoModelForCausalLM.from_pretrained(self.model_name  ,		load_in_abit=snake_case_  ,		device_map="""auto""" )

			def  lowerCAmelCase__		(    self	:    Union[str, Any] ):
							del self.model_fpaa
							del self.model_abit

							gc.collect()
							torch.cuda.empty_cache()

			def  lowerCAmelCase__		(    self	:    str ):
							UpperCamelCase_:							List[str]		=  self.model_abit.config

							self.assertTrue(hasattr(snake_case_  ,		"""quantization_config""" ) )

							UpperCamelCase_:							Optional[Any]		=  config.to_dict()
							UpperCamelCase_:							List[Any]		=  config.to_diff_dict()

							UpperCamelCase_:							List[str]		=  config.to_json_string()

			def  lowerCAmelCase__		(    self	:    Optional[Any] ):
							from bitsandbytes.nn import Paramsabit

							UpperCamelCase_:							List[str]		=  self.model_fpaa.get_memory_footprint()
							UpperCamelCase_:							Union[str, Any]		=  self.model_abit.get_memory_footprint()

							self.assertAlmostEqual(mem_fpaa / mem_abit  ,		self.EXPECTED_RELATIVE_DIFFERENCE )
							UpperCamelCase_:							Dict		=  get_some_linear_layer(self.model_abit )
							self.assertTrue(linear.weight.__class__ == Paramsabit )

			def  lowerCAmelCase__		(    self	:    List[Any] ):
							from transformers import TaPreTrainedModel

							self.model_fpaa.get_memory_footprint()
							self.model_abit.get_memory_footprint()

							for name, module in self.model_abit.named_modules():
											if isinstance(snake_case_  ,		torch.nn.Linear ):
															if name not in ["lm_head"] + TaPreTrainedModel._keep_in_fpaa_modules:
																			# 4-bit parameters are packed in uint8 variables
																			self.assertTrue(module.weight.dtype == torch.uinta )

			def  lowerCAmelCase__		(    self	:    int ):
							UpperCamelCase_:							List[str]		=  self.tokenizer(self.input_text  ,		return_tensors="""pt""" )
							UpperCamelCase_:							Union[str, Any]		=  self.model_abit.generate(input_ids=encoded_input["""input_ids"""].to(0 )  ,		max_new_tokens=10 )

							self.assertIn(self.tokenizer.decode(output_sequences[0]  ,		skip_special_tokens=snake_case_ )  ,		self.EXPECTED_OUTPUTS )

			def  lowerCAmelCase__		(    self	:    List[str] ):
							UpperCamelCase_:							int		=  BitsAndBytesConfig()
							UpperCamelCase_:							Union[str, Any]		=  True

							UpperCamelCase_:							Optional[int]		=  AutoModelForCausalLM.from_pretrained(
							    self.model_name  ,		quantization_config=snake_case_  ,		device_map="""auto""" )

							UpperCamelCase_:							str		=  self.tokenizer(self.input_text  ,		return_tensors="""pt""" )
							UpperCamelCase_:							List[Any]		=  model_abit_from_config.generate(
							    input_ids=encoded_input["""input_ids"""].to(0 )  ,		max_new_tokens=10 )

							self.assertIn(self.tokenizer.decode(output_sequences[0]  ,		skip_special_tokens=snake_case_ )  ,		self.EXPECTED_OUTPUTS )

			def  lowerCAmelCase__		(    self	:    Optional[int] ):
							with self.assertRaises(snake_case_ ), tempfile.TemporaryDirectory() as tmpdirname:
											self.model_abit.save_pretrained(snake_case_ )

			def  lowerCAmelCase__		(    self	:    Dict ):
							UpperCamelCase_:							Optional[int]		=  BitsAndBytesConfig()

							with self.assertRaises(snake_case_ ):
											UpperCamelCase_:							int		=  AutoModelForCausalLM.from_pretrained(
											    self.model_name  ,		quantization_config=snake_case_  ,		load_in_abit=snake_case_  ,		device_map="""auto"""  ,		bnb_abit_quant_type="""nf4"""  ,		)

			def  lowerCAmelCase__		(    self	:    List[str] ):
							with self.assertRaises(snake_case_ ):
											# Tries with `str`
											self.model_abit.to("""cpu""" )

							with self.assertRaises(snake_case_ ):
											# Tries with a `dtype``
											self.model_abit.to(torch.floataa )

							with self.assertRaises(snake_case_ ):
											# Tries with a `device`
											self.model_abit.to(torch.device("""cuda:0""" ) )

							with self.assertRaises(snake_case_ ):
											# Tries with a `device`
											self.model_abit.float()

							with self.assertRaises(snake_case_ ):
											# Tries with a `device`
											self.model_abit.half()

							# Test if we did not break anything
							UpperCamelCase_:							int		=  self.tokenizer(self.input_text  ,		return_tensors="""pt""" )

							UpperCamelCase_:							Any		=  self.model_fpaa.to(torch.floataa )
							UpperCamelCase_:							List[str]		=  self.model_fpaa.generate(input_ids=encoded_input["""input_ids"""].to(0 )  ,		max_new_tokens=10 )

							# Check this does not throw an error
							UpperCamelCase_:							List[str]		=  self.model_fpaa.to("""cpu""" )

							# Check this does not throw an error
							UpperCamelCase_:							Tuple		=  self.model_fpaa.half()

							# Check this does not throw an error
							UpperCamelCase_:							List[Any]		=  self.model_fpaa.float()




			def  lowerCAmelCase__		(    self	:    Tuple ):
							UpperCamelCase_:							Union[str, Any]		=  AutoModelForSeqaSeqLM.from_pretrained("""t5-small"""  ,		load_in_abit=snake_case_  ,		device_map="""auto""" )
							self.assertTrue(model.decoder.block[0].layer[2].DenseReluDense.wo.weight.dtype == torch.floataa )




@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class     _UpperCamelCase			(   unittest.TestCase					):






			'''simple docstring'''

			@classmethod
			def  lowerCAmelCase__		(    cls	:    Union[str, Any] ):
							UpperCamelCase_:							int		=  """t5-small"""
							UpperCamelCase_:							Union[str, Any]		=  """google/flan-t5-small"""  # flan-t5 uses dense-act instead of dense-relu-dense
							UpperCamelCase_:							Any		=  AutoTokenizer.from_pretrained(cls.model_name )
							UpperCamelCase_:							Optional[int]		=  """Translate in German: Hello, my dog is cute"""

			def  lowerCAmelCase__		(    self	:    Any ):
							gc.collect()
							torch.cuda.empty_cache()

			def  lowerCAmelCase__		(    self	:    Any ):
							from transformers import TaForConditionalGeneration

							UpperCamelCase_:							Optional[Any]		=  TaForConditionalGeneration._keep_in_fpaa_modules
							UpperCamelCase_:							Any		=  None

							# test with `t5-small`
							UpperCamelCase_:							Dict		=  TaForConditionalGeneration.from_pretrained(self.model_name  ,		load_in_abit=snake_case_  ,		device_map="""auto""" )
							UpperCamelCase_:							Tuple		=  self.tokenizer(self.input_text  ,		return_tensors="""pt""" ).to(0 )
							UpperCamelCase_:							Union[str, Any]		=  model.generate(**snake_case_ )

							# test with `flan-t5-small`
							UpperCamelCase_:							Union[str, Any]		=  TaForConditionalGeneration.from_pretrained(
							    self.dense_act_model_name  ,		load_in_abit=snake_case_  ,		device_map="""auto""" )
							UpperCamelCase_:							List[str]		=  self.tokenizer(self.input_text  ,		return_tensors="""pt""" ).to(0 )
							UpperCamelCase_:							str		=  model.generate(**snake_case_ )
							UpperCamelCase_:							Optional[Any]		=  modules




			def  lowerCAmelCase__		(    self	:    str ):
							import bitsandbytes as bnb

							from transformers import TaForConditionalGeneration

							# test with `t5-small`
							UpperCamelCase_:							Optional[int]		=  TaForConditionalGeneration.from_pretrained(self.model_name  ,		load_in_abit=snake_case_  ,		device_map="""auto""" )

							# there was a bug with decoders - this test checks that it is fixed
							self.assertTrue(isinstance(model.decoder.block[0].layer[0].SelfAttention.q  ,		bnb.nn.Linearabit ) )

							UpperCamelCase_:							Dict		=  self.tokenizer(self.input_text  ,		return_tensors="""pt""" ).to(0 )
							UpperCamelCase_:							List[str]		=  model.generate(**snake_case_ )

							# test with `flan-t5-small`
							UpperCamelCase_:							str		=  TaForConditionalGeneration.from_pretrained(
							    self.dense_act_model_name  ,		load_in_abit=snake_case_  ,		device_map="""auto""" )
							UpperCamelCase_:							List[str]		=  self.tokenizer(self.input_text  ,		return_tensors="""pt""" ).to(0 )
							UpperCamelCase_:							Optional[int]		=  model.generate(**snake_case_ )




class     _UpperCamelCase			(   _A					):






			'''simple docstring'''

			def  lowerCAmelCase__		(    self	:    str ):
							super().setUp()
							# model_name
							UpperCamelCase_:							Optional[int]		=  """bigscience/bloom-560m"""
							UpperCamelCase_:							str		=  """t5-small"""

							# Different types of model

							UpperCamelCase_:							List[Any]		=  AutoModel.from_pretrained(self.model_name  ,		load_in_abit=snake_case_  ,		device_map="""auto""" )
							# Sequence classification model
							UpperCamelCase_:							int		=  AutoModelForSequenceClassification.from_pretrained(
							    self.model_name  ,		load_in_abit=snake_case_  ,		device_map="""auto""" )
							# CausalLM model
							UpperCamelCase_:							Tuple		=  AutoModelForCausalLM.from_pretrained(self.model_name  ,		load_in_abit=snake_case_  ,		device_map="""auto""" )
							# Seq2seq model
							UpperCamelCase_:							List[Any]		=  AutoModelForSeqaSeqLM.from_pretrained(
							    self.seq_to_seq_name  ,		load_in_abit=snake_case_  ,		device_map="""auto""" )

			def  lowerCAmelCase__		(    self	:    Union[str, Any] ):
							del self.base_model
							del self.sequence_model
							del self.model_abit
							del self.seq_to_seq_model

							gc.collect()
							torch.cuda.empty_cache()




			def  lowerCAmelCase__		(    self	:    Dict ):
							from bitsandbytes.nn import Paramsabit

							self.assertTrue(self.base_model.h[-1].mlp.dense_ah_to_h.weight.__class__ == Paramsabit )

							# Other heads should be nn.Parameter
							self.assertTrue(self.model_abit.lm_head.weight.__class__ == torch.nn.Parameter )
							self.assertTrue(self.sequence_model.score.weight.__class__ == torch.nn.Parameter )
							self.assertTrue(self.seq_to_seq_model.lm_head.weight.__class__ == torch.nn.Parameter )




class     _UpperCamelCase			(   _A					):






			'''simple docstring'''

			def  lowerCAmelCase__		(    self	:    List[str] ):
							super().setUp()

			def  lowerCAmelCase__		(    self	:    int ):
							del self.pipe

							gc.collect()
							torch.cuda.empty_cache()




			def  lowerCAmelCase__		(    self	:    Any ):
							UpperCamelCase_:							Union[str, Any]		=  pipeline(
							    """text-generation"""  ,		model=self.model_name  ,		model_kwargs={"""device_map""": """auto""", """load_in_4bit""": True, """torch_dtype""": torch.floataa}  ,		max_new_tokens=self.MAX_NEW_TOKENS  ,		)

							# Real second forward pass
							UpperCamelCase_:							Optional[Any]		=  self.pipe(self.input_text )
							self.assertIn(pipeline_output[0]["""generated_text"""]  ,		self.EXPECTED_OUTPUTS )




@require_torch_multi_gpu
class     _UpperCamelCase			(   _A					):






			'''simple docstring'''

			def  lowerCAmelCase__		(    self	:    List[Any] ):
							super().setUp()




			def  lowerCAmelCase__		(    self	:    str ):
							UpperCamelCase_:							List[Any]		=  AutoModelForCausalLM.from_pretrained(
							    self.model_name  ,		load_in_abit=snake_case_  ,		device_map="""balanced""" )

							# Check correct device map
							self.assertEqual(set(model_parallel.hf_device_map.values() )  ,		{0, 1} )

							# Check that inference pass works on the model
							UpperCamelCase_:							List[str]		=  self.tokenizer(self.input_text  ,		return_tensors="""pt""" )

							# Second real batch
							UpperCamelCase_:							Any		=  model_parallel.generate(input_ids=encoded_input["""input_ids"""].to(0 )  ,		max_new_tokens=10 )
							self.assertIn(self.tokenizer.decode(output_parallel[0]  ,		skip_special_tokens=snake_case_ )  ,		self.EXPECTED_OUTPUTS )




class     _UpperCamelCase			(   _A					):






			'''simple docstring'''

			def  lowerCAmelCase__		(    self	:    Union[str, Any] ):
							UpperCamelCase_:							int		=  """facebook/opt-350m"""
							super().setUp()




			def  lowerCAmelCase__		(    self	:    List[str] ):
							if version.parse(importlib.metadata.version("""bitsandbytes""" ) ) < version.parse("""0.37.0""" ):
											return

							# Step 1: freeze all parameters
							UpperCamelCase_:							Tuple		=  AutoModelForCausalLM.from_pretrained(self.model_name  ,		load_in_abit=snake_case_ )

							self.assertEqual(set(model.hf_device_map.values() )  ,		{torch.cuda.current_device()} )

							for param in model.parameters():
											UpperCamelCase_:							int		=  False  # freeze the model - train adapters later
											if param.ndim == 1:
															# cast the small parameters (e.g. layernorm) to fp32 for stability
															UpperCamelCase_:							Optional[Any]		=  param.data.to(torch.floataa )

        # Step 2: add adapters
							for _, module in model.named_modules():
											if "OPTAttention" in repr(type(snake_case_ ) ):
															UpperCamelCase_:							int		=  LoRALayer(module.q_proj  ,		rank=16 )
															UpperCamelCase_:							List[str]		=  LoRALayer(module.k_proj  ,		rank=16 )
															UpperCamelCase_:							Optional[int]		=  LoRALayer(module.v_proj  ,		rank=16 )

        # Step 3: dummy batch
							UpperCamelCase_:							Optional[int]		=  self.tokenizer("""Test batch """  ,		return_tensors="""pt""" ).to(0 )

							# Step 4: Check if the gradient is not None
							with torch.cuda.amp.autocast():
											UpperCamelCase_:							List[Any]		=  model.forward(**snake_case_ )
											out.logits.norm().backward()

							for module in model.modules():
											if isinstance(snake_case_  ,		snake_case_ ):
															self.assertTrue(module.adapter[1].weight.grad is not None )
															self.assertTrue(module.adapter[1].weight.grad.norm().item() > 0 )
											elif isinstance(snake_case_  ,		nn.Embedding ):
															self.assertTrue(module.weight.grad is None )




class     _UpperCamelCase			(   _A					):






			'''simple docstring'''

			__UpperCamelCase :  str    =	"""gpt2-xl"""
			__UpperCamelCase :  List[Any]    =	3.3_191_854_854_152_187








from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching







def     A__   (  )					->		Union[str, Any]:
				import os as original_os
				from os import path as original_path
				from os import rename as original_rename
				from os.path import dirname as original_dirname
				from os.path import join as original_join

				assert _test_patching.os is original_os
				assert _test_patching.path is original_path
				assert _test_patching.join is original_join

				assert _test_patching.renamed_os is original_os
				assert _test_patching.renamed_path is original_path
				assert _test_patching.renamed_join is original_join

				UpperCamelCase_:							Optional[int]		=  """__test_patch_submodule_mock__"""
				with patch_submodule(_test_patching       ,      """os.path.join"""       ,      lowerCamelCase  ):
								# Every way to access os.path.join must be patched, and the rest must stay untouched

								# check os.path.join
								assert isinstance(_test_patching.os       ,      _PatchedModuleObj  )
								assert isinstance(_test_patching.os.path       ,      _PatchedModuleObj  )
								assert _test_patching.os.path.join is mock

								# check path.join
								assert isinstance(_test_patching.path       ,      _PatchedModuleObj  )
								assert _test_patching.path.join is mock

								# check join
								assert _test_patching.join is mock

								# check that the other attributes are untouched
								assert _test_patching.os.rename is original_rename
								assert _test_patching.path.dirname is original_dirname
								assert _test_patching.os.path.dirname is original_dirname

								# Even renamed modules or objects must be patched

								# check renamed_os.path.join
								assert isinstance(_test_patching.renamed_os       ,      _PatchedModuleObj  )
								assert isinstance(_test_patching.renamed_os.path       ,      _PatchedModuleObj  )
								assert _test_patching.renamed_os.path.join is mock

								# check renamed_path.join
								assert isinstance(_test_patching.renamed_path       ,      _PatchedModuleObj  )
								assert _test_patching.renamed_path.join is mock

								# check renamed_join
								assert _test_patching.renamed_join is mock

								# check that the other attributes are untouched
								assert _test_patching.renamed_os.rename is original_rename
								assert _test_patching.renamed_path.dirname is original_dirname
								assert _test_patching.renamed_os.path.dirname is original_dirname

				# check that everthing is back to normal when the patch is over

				assert _test_patching.os is original_os
				assert _test_patching.path is original_path
				assert _test_patching.join is original_join

				assert _test_patching.renamed_os is original_os
				assert _test_patching.renamed_path is original_path
				assert _test_patching.renamed_join is original_join







def     A__   (  )					->		Union[str, Any]:
				assert _test_patching.open is open

				UpperCamelCase_:							List[Any]		=  """__test_patch_submodule_builtin_mock__"""
				# _test_patching has "open" in its globals
				assert _test_patching.open is open
				with patch_submodule(_test_patching       ,      """open"""       ,      lowerCamelCase  ):
								assert _test_patching.open is mock

				# check that everthing is back to normal when the patch is over

				assert _test_patching.open is open







def     A__   (  )					->		Optional[Any]:
				# pandas.read_csv is not present in _test_patching
				UpperCamelCase_:							Optional[Any]		=  """__test_patch_submodule_missing_mock__"""
				with patch_submodule(_test_patching       ,      """pandas.read_csv"""       ,      lowerCamelCase  ):
								pass







def     A__   (  )					->		Any:
				# builtin should always be mocked even if they're not in the globals
				# in case they're loaded at one point
				UpperCamelCase_:							List[Any]		=  """__test_patch_submodule_missing_builtin_mock__"""
				# _test_patching doesn't have "len" in its globals
				assert getattr(_test_patching       ,      """len"""       ,      lowerCamelCase  ) is None
				with patch_submodule(_test_patching       ,      """len"""       ,      lowerCamelCase  ):
								assert _test_patching.len is mock
				assert _test_patching.len is len







def     A__   (  )					->		Any:
				UpperCamelCase_:							Dict		=  """__test_patch_submodule_start_and_stop_mock__"""
				UpperCamelCase_:							List[str]		=  patch_submodule(_test_patching       ,      """open"""       ,      lowerCamelCase  )
				assert _test_patching.open is open
				patch.start()
				assert _test_patching.open is mock
				patch.stop()
				assert _test_patching.open is open







def     A__   (  )					->		List[str]:
				from os import rename as original_rename
				from os.path import dirname as original_dirname
				from os.path import join as original_join

				UpperCamelCase_:							Optional[Any]		=  """__test_patch_submodule_successive_join__"""
				UpperCamelCase_:							Any		=  """__test_patch_submodule_successive_dirname__"""
				UpperCamelCase_:							Dict		=  """__test_patch_submodule_successive_rename__"""
				assert _test_patching.os.path.join is original_join
				assert _test_patching.os.path.dirname is original_dirname
				assert _test_patching.os.rename is original_rename

				with patch_submodule(_test_patching       ,      """os.path.join"""       ,      lowerCamelCase  ):
								with patch_submodule(_test_patching       ,      """os.rename"""       ,      lowerCamelCase  ):
												with patch_submodule(_test_patching       ,      """os.path.dirname"""       ,      lowerCamelCase  ):
																assert _test_patching.os.path.join is mock_join
																assert _test_patching.os.path.dirname is mock_dirname
																assert _test_patching.os.rename is mock_rename

    # try another order
				with patch_submodule(_test_patching       ,      """os.rename"""       ,      lowerCamelCase  ):
								with patch_submodule(_test_patching       ,      """os.path.join"""       ,      lowerCamelCase  ):
												with patch_submodule(_test_patching       ,      """os.path.dirname"""       ,      lowerCamelCase  ):
																assert _test_patching.os.path.join is mock_join
																assert _test_patching.os.path.dirname is mock_dirname
																assert _test_patching.os.rename is mock_rename

				assert _test_patching.os.path.join is original_join
				assert _test_patching.os.path.dirname is original_dirname
				assert _test_patching.os.rename is original_rename







def     A__   (  )					->		Union[str, Any]:
				UpperCamelCase_:							Dict		=  """__test_patch_submodule_doesnt_exist_mock__"""
				with patch_submodule(_test_patching       ,      """__module_that_doesn_exist__.__attribute_that_doesn_exist__"""       ,      lowerCamelCase  ):
								pass
				with patch_submodule(_test_patching       ,      """os.__attribute_that_doesn_exist__"""       ,      lowerCamelCase  ):
								pass






