





from typing import Optional

import torch
from PIL import Image
from tqdm.auto import tqdm
from transformers import CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, DiffusionPipeline, UNetaDConditionModel
from diffusers.image_processor import VaeImageProcessor
from diffusers.utils import (
    deprecate,
)







class 		_lowerCAmelCase(		_a):

  """simple docstring"""







  def __init__(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase = 0.93    ,							UpperCAmelCase = True    ,							)->   List[Any]:
     __A    =  mixing_coeff
     __A    =  leapfrog_steps

     super().__init__()
     self.register_modules(
         vae=UpperCAmelCase    ,							text_encoder=UpperCAmelCase    ,							tokenizer=UpperCAmelCase    ,							unet=UpperCAmelCase    ,							scheduler=UpperCAmelCase    ,							)

     __A    =  2 ** (len(self.vae.config.block_out_channels      ) - 1)
     __A    =  VaeImageProcessor(vae_scale_factor=self.vae_scale_factor      )

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase = None    ,							UpperCAmelCase = False      )->   List[str]:
     __A    =  self.tokenizer(
         UpperCAmelCase    ,							padding='''max_length'''    ,							max_length=self.tokenizer.model_max_length    ,							truncation=UpperCAmelCase    ,							return_tensors='''pt'''    ,							)

     __A    =  self.text_encoder(text_inputs.input_ids.to(self.device      )      ).last_hidden_state

     __A    =  prompt_embeds.to(dtype=self.text_encoder.dtype    ,							device=self.device      )

     if do_classifier_free_guidance:
        __A    =  '''''' if negative_prompt is None else negative_prompt

        __A    =  self.tokenizer(
            UpperCAmelCase    ,							padding='''max_length'''    ,							max_length=self.tokenizer.model_max_length    ,							truncation=UpperCAmelCase    ,							return_tensors='''pt'''    ,							)

        __A    =  self.text_encoder(uncond_input.input_ids.to(self.device      )      ).last_hidden_state

        __A    =  torch.cat([negative_prompt_embeds, prompt_embeds]      )

     return prompt_embeds

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase      )->   Dict:
     __A    =  self.mixing_coeff * x + (1 - self.mixing_coeff) * y
     __A    =  self.mixing_coeff * y + (1 - self.mixing_coeff) * x

     return [x, y]

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase      )->   Dict:
     __A    =  (y - (1 - self.mixing_coeff) * x) / self.mixing_coeff
     __A    =  (x - (1 - self.mixing_coeff) * y) / self.mixing_coeff

     return [x, y]

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase      )->   Optional[int]:
     # as self.alphas_cumprod is always in cpu
     __A    =  int(UpperCAmelCase      )

     __A    =  self.scheduler.alphas_cumprod[t] if t >= 0 else self.scheduler.final_alpha_cumprod

     return alpha_prod, 1 - alpha_prod

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							)->   Optional[int]:
     __A    =  timestep - self.scheduler.config.num_train_timesteps / self.scheduler.num_inference_steps

     __A   ,		__A    =  self._get_alpha_and_beta(UpperCAmelCase      )
     __A   ,		__A    =  self._get_alpha_and_beta(UpperCAmelCase      )

     __A    =  (alpha_prod_t_prev / alpha_prod_t) ** 0.5
     __A    =  -a_t * (beta_prod_t**0.5) + beta_prod_t_prev**0.5

     __A    =  (base - b_t * model_output) / a_t

     return model_input, next_model_input.to(base.dtype      )

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							)->   Optional[int]:
     __A    =  timestep - self.scheduler.config.num_train_timesteps / self.scheduler.num_inference_steps

     __A   ,		__A    =  self._get_alpha_and_beta(UpperCAmelCase      )
     __A   ,		__A    =  self._get_alpha_and_beta(UpperCAmelCase      )

     __A    =  (alpha_prod_t_prev / alpha_prod_t) ** 0.5
     __A    =  -a_t * (beta_prod_t**0.5) + beta_prod_t_prev**0.5
     __A    =  a_t * base + b_t * model_output

     return model_input, next_model_input.to(base.dtype      )

  @torch.no_grad()
  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase      )->   Union[str, Any]:
     __A    =  1 / self.vae.config.scaling_factor * latents
     __A    =  self.vae.decode(UpperCAmelCase      ).sample
     __A    =  (image / 2 + 0.5).clamp(0    ,							1      )
     return image

  @torch.no_grad()
  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase = None    ,							)->   Dict:
     __A    =  guidance_scale > 1.0

     __A    =  image.to(device=self.device    ,							dtype=text_embeds.dtype      )
     __A    =  self.vae.encode(UpperCAmelCase      ).latent_dist.sample(UpperCAmelCase      )

     __A    =  self.vae.config.scaling_factor * latent

     __A    =  [latent.clone(), latent.clone()]

     for i, t in tqdm(enumerate(UpperCAmelCase      )    ,							total=len(UpperCAmelCase      )      ):
        __A    =  self.noise_mixing_layer(x=coupled_latents[0]    ,							y=coupled_latents[1]      )

        # j - model_input index, k - base index
        for j in range(2      ):
           __A    =  j ^ 1

           if self.leapfrog_steps:
              if i % 2 == 0:
                 __A   ,		__A    =  j, k

           __A    =  coupled_latents[j]
           __A    =  coupled_latents[k]

           __A    =  torch.cat([model_input] * 2      ) if do_classifier_free_guidance else model_input

           __A    =  self.unet(UpperCAmelCase    ,							UpperCAmelCase    ,							encoder_hidden_states=UpperCAmelCase      ).sample

           if do_classifier_free_guidance:
              __A   ,		__A    =  noise_pred.chunk(2      )
              __A    =  noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

           __A   ,		__A    =  self.noise_step(
               base=UpperCAmelCase    ,							model_input=UpperCAmelCase    ,							model_output=UpperCAmelCase    ,							timestep=UpperCAmelCase    ,							)

           __A    =  model_input

     return coupled_latents





  @torch.no_grad()
  def __call__(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase = 3.0    ,							UpperCAmelCase = 50    ,							UpperCAmelCase = 0.8    ,							UpperCAmelCase = None    ,							UpperCAmelCase = None    ,							UpperCAmelCase = "pil"    ,							)->   Union[str, Any]:
     __A    =  guidance_scale > 1.0

     __A    =  self.image_processor.preprocess(UpperCAmelCase      )

     __A    =  self._encode_prompt(UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase      )
     __A    =  self._encode_prompt(UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase      )

     self.scheduler.set_timesteps(UpperCAmelCase    ,							self.device      )

     __A    =  num_inference_steps - int(num_inference_steps * strength      )
     __A    =  self.scheduler.timesteps[t_limit:]
     __A    =  fwd_timesteps.flip(0      )

     __A    =  self.prepare_latents(UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase      )

     for i, t in tqdm(enumerate(UpperCAmelCase      )    ,							total=len(UpperCAmelCase      )      ):
        # j - model_input index, k - base index
        for k in range(2      ):
           __A    =  k ^ 1

           if self.leapfrog_steps:
              if i % 2 == 1:
                 __A   ,		__A    =  j, k

           __A    =  coupled_latents[j]
           __A    =  coupled_latents[k]

           __A    =  torch.cat([model_input] * 2      ) if do_classifier_free_guidance else model_input

           __A    =  self.unet(UpperCAmelCase    ,							UpperCAmelCase    ,							encoder_hidden_states=UpperCAmelCase      ).sample

           if do_classifier_free_guidance:
              __A   ,		__A    =  noise_pred.chunk(2      )
              __A    =  noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

           __A   ,		__A    =  self.denoise_step(
               base=UpperCAmelCase    ,							model_input=UpperCAmelCase    ,							model_output=UpperCAmelCase    ,							timestep=UpperCAmelCase    ,							)

           __A    =  model_input

        __A    =  self.denoise_mixing_layer(x=coupled_latents[0]    ,							y=coupled_latents[1]      )

     # either one is fine
     __A    =  coupled_latents[0]

     if output_type not in ["latent", "pt", "np", "pil"]:
        __A    =  (
            f"the output_type {output_type} is outdated. Please make sure to set it to one of these instead: "
            '''`pil`, `np`, `pt`, `latent`'''
        )
        deprecate('''Unsupported output_type'''    ,							'''1.0.0'''    ,							UpperCAmelCase    ,							standard_warn=UpperCAmelCase      )
        __A    =  '''np'''

     if output_type == "latent":
        __A    =  final_latent
     else:
        __A    =  self.decode_latents(UpperCAmelCase      )
        __A    =  self.image_processor.postprocess(UpperCAmelCase    ,							output_type=UpperCAmelCase      )

     return image








from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import (
        TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFXLMForMultipleChoice,
        TFXLMForQuestionAnsweringSimple,
        TFXLMForSequenceClassification,
        TFXLMForTokenClassification,
        TFXLMModel,
        TFXLMWithLMHeadModel,
        XLMConfig,
    )







class 		_lowerCAmelCase:

  """simple docstring"""







  def __init__(   self    ,							UpperCAmelCase    ,							)->   List[Any]:
     __A    =  parent
     __A    =  13
     __A    =  7
     __A    =  True
     __A    =  True
     __A    =  True
     __A    =  True
     __A    =  True
     __A    =  False
     __A    =  False
     __A    =  False
     __A    =  2
     __A    =  99
     __A    =  0
     __A    =  32
     __A    =  2
     __A    =  4
     __A    =  0.1
     __A    =  0.1
     __A    =  5_12
     __A    =  16
     __A    =  2
     __A    =  0.02
     __A    =  3
     __A    =  4
     __A    =  '''last'''
     __A    =  True
     __A    =  None
     __A    =  0

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[Any]:
     __A    =  ids_tensor([self.batch_size, self.seq_length]    ,							self.vocab_size      )
     __A    =  random_attention_mask([self.batch_size, self.seq_length]    ,							dtype=tf.floataa      )

     __A    =  None
     if self.use_input_lengths:
        __A    =  (
            ids_tensor([self.batch_size]    ,							vocab_size=2      ) + self.seq_length - 2
        )  # small variation of seq_length

     __A    =  None
     if self.use_token_type_ids:
        __A    =  ids_tensor([self.batch_size, self.seq_length]    ,							self.n_langs      )

     __A    =  None
     __A    =  None
     __A    =  None
     if self.use_labels:
        __A    =  ids_tensor([self.batch_size]    ,							self.type_sequence_label_size      )
        __A    =  ids_tensor([self.batch_size, self.seq_length]    ,							self.num_labels      )
        __A    =  ids_tensor([self.batch_size]    ,							2    ,							dtype=tf.floataa      )
        __A    =  ids_tensor([self.batch_size]    ,							self.num_choices      )

     __A    =  XLMConfig(
         vocab_size=self.vocab_size    ,							n_special=self.n_special    ,							emb_dim=self.hidden_size    ,							n_layers=self.num_hidden_layers    ,							n_heads=self.num_attention_heads    ,							dropout=self.hidden_dropout_prob    ,							attention_dropout=self.attention_probs_dropout_prob    ,							gelu_activation=self.gelu_activation    ,							sinusoidal_embeddings=self.sinusoidal_embeddings    ,							asm=self.asm    ,							causal=self.causal    ,							n_langs=self.n_langs    ,							max_position_embeddings=self.max_position_embeddings    ,							initializer_range=self.initializer_range    ,							summary_type=self.summary_type    ,							use_proj=self.use_proj    ,							bos_token_id=self.bos_token_id    ,							)

     return (
         config,
         input_ids,
         token_type_ids,
         input_lengths,
         sequence_labels,
         token_labels,
         is_impossible_labels,
         choice_labels,
         input_mask,
     )

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							)->   Optional[Any]:
     __A    =  TFXLMModel(config=UpperCAmelCase      )
     __A    =  {'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
     __A    =  model(UpperCAmelCase      )

     __A    =  [input_ids, input_mask]
     __A    =  model(UpperCAmelCase      )
     self.parent.assertEqual(result.last_hidden_state.shape    ,							(self.batch_size, self.seq_length, self.hidden_size)      )

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							)->   Tuple:
     __A    =  TFXLMWithLMHeadModel(UpperCAmelCase      )

     __A    =  {'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
     __A    =  model(UpperCAmelCase      )

     __A    =  outputs

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

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							)->   Dict:
     __A    =  TFXLMForQuestionAnsweringSimple(UpperCAmelCase      )

     __A    =  {'''input_ids''': input_ids, '''lengths''': input_lengths}

     __A    =  model(UpperCAmelCase      )

     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    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							)->   Union[str, Any]:
     __A    =  TFXLMForSequenceClassification(UpperCAmelCase      )

     __A    =  {'''input_ids''': input_ids, '''lengths''': input_lengths}

     __A    =  model(UpperCAmelCase      )

     self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.type_sequence_label_size)      )

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							)->   Tuple:
     __A    =  self.num_labels
     __A    =  TFXLMForTokenClassification(config=UpperCAmelCase      )
     __A    =  {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
     __A    =  model(UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.seq_length, self.num_labels)      )

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							)->   Union[str, Any]:
     __A    =  self.num_choices
     __A    =  TFXLMForMultipleChoice(config=UpperCAmelCase      )
     __A    =  tf.tile(tf.expand_dims(UpperCAmelCase    ,							1      )    ,							(1, self.num_choices, 1)      )
     __A    =  tf.tile(tf.expand_dims(UpperCAmelCase    ,							1      )    ,							(1, self.num_choices, 1)      )
     __A    =  tf.tile(tf.expand_dims(UpperCAmelCase    ,							1      )    ,							(1, self.num_choices, 1)      )
     __A    =  {
         '''input_ids''': multiple_choice_inputs_ids,
         '''attention_mask''': multiple_choice_input_mask,
         '''token_type_ids''': multiple_choice_token_type_ids,
     }
     __A    =  model(UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.num_choices)      )





  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[Any]:
     __A    =  self.prepare_config_and_inputs()
     (
         (
         __A
     )   ,		(
         __A
     )   ,		(
         __A
     )   ,		(
         __A
     )   ,		(
         __A
     )   ,		(
         __A
     )   ,		(
         __A
     )   ,		(
         __A
     )   ,		(
         __A
     )   ,		
     )    =  config_and_inputs
     __A    =  {
         '''input_ids''': input_ids,
         '''token_type_ids''': token_type_ids,
         '''langs''': token_type_ids,
         '''lengths''': input_lengths,
     }
     return config, inputs_dict







@require_tf
class 		_lowerCAmelCase(		_a						,       _a						,       unittest.TestCase):

  """simple docstring"""







  lowerCamelCase__     	=       (
      (
          TFXLMModel,
          TFXLMWithLMHeadModel,
          TFXLMForSequenceClassification,
          TFXLMForQuestionAnsweringSimple,
          TFXLMForTokenClassification,
          TFXLMForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  lowerCamelCase__     	=       (
      (TFXLMWithLMHeadModel,) if is_tf_available() else ()
  )  # TODO (PVP): Check other models whether language generation is also applicable
  lowerCamelCase__     	=       (
      {
          '''feature-extraction''': TFXLMModel,
          '''fill-mask''': TFXLMWithLMHeadModel,
          '''question-answering''': TFXLMForQuestionAnsweringSimple,
          '''text-classification''': TFXLMForSequenceClassification,
          '''text-generation''': TFXLMWithLMHeadModel,
          '''token-classification''': TFXLMForTokenClassification,
          '''zero-shot''': TFXLMForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  lowerCamelCase__     	=       False
  lowerCamelCase__     	=       False

  def 						SCREAMING_SNAKE_CASE__			(   self    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase    ,							UpperCAmelCase      )->   List[Any]:
     if (
         pipeline_test_casse_name == "QAPipelineTests"
         and tokenizer_name is not None
         and not tokenizer_name.endswith('''Fast'''      )
     ):
        # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
        # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
        # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
        return True

     return False

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Any:
     __A    =  TFXLMModelTester(self      )
     __A    =  ConfigTester(self    ,							config_class=UpperCAmelCase    ,							emb_dim=37      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   List[str]:
     self.config_tester.run_common_tests()

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Any:
     __A    =  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_model(*UpperCAmelCase      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Any:
     __A    =  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_lm_head(*UpperCAmelCase      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   List[Any]:
     __A    =  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_qa(*UpperCAmelCase      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Any:
     __A    =  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_sequence_classif(*UpperCAmelCase      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Tuple:
     __A    =  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_for_token_classification(*UpperCAmelCase      )

  def 						SCREAMING_SNAKE_CASE__			(   self      )->   int:
     __A    =  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCAmelCase      )





  @slow
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   Optional[int]:
     for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        __A    =  TFXLMModel.from_pretrained(UpperCAmelCase      )
        self.assertIsNotNone(UpperCAmelCase      )







@require_tf
class 		_lowerCAmelCase(		unittest.TestCase):

  """simple docstring"""







  @slow
  def 						SCREAMING_SNAKE_CASE__			(   self      )->   int:
     __A    =  TFXLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''      )
     __A    =  tf.convert_to_tensor([[14, 4_47]]    ,							dtype=tf.intaa      )  # the president
     __A    =  [
         14,
         4_47,
         14,
         4_47,
         14,
         4_47,
         14,
         4_47,
         14,
         4_47,
         14,
         4_47,
         14,
         4_47,
         14,
         4_47,
         14,
         4_47,
         14,
         4_47,
     ]  # the president the president the president the president the president the president the president the president the president the president
     # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
     __A    =  model.generate(UpperCAmelCase    ,							do_sample=UpperCAmelCase      )
     self.assertListEqual(output_ids[0].numpy().tolist()    ,							UpperCAmelCase      )

