





import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


UpperCamelCase__         =      logging.get_logger(__name__)  # pylint: disable=invalid-name
class       a__   ( snake_case__				):






						def __init__(       self		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      ):




											"""simple docstring"""



											super().__init__()
											self.register_modules(
											    vae=_A		,      text_encoder=_A		,      tokenizer=_A		,      unet=_A		,      scheduler=_A		,      safety_checker=_A		,      feature_extractor=_A		,      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A = "auto"      ):




											"""simple docstring"""



											if slice_size == "auto":
																# half the attention head size is usually a good trade-off between
																# speed and memory
																__lowerCAmelCase           =	self.unet.config.attention_head_dim // 2
											self.unet.set_attention_slice(_A      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											self.enable_attention_slicing(_A      )






						@torch.no_grad()
						def __call__(       self		,      _A		,      _A = 5_1_2		,      _A = 5_1_2		,      _A = 5_0		,      _A = 7.5		,      _A = None		,      _A = 1		,      _A = 0.0		,      _A = None		,      _A = None		,      _A = "pil"		,      _A = True		,      _A = None		,      _A = 1		,      _A = None		,      **_A		,      ):




											"""simple docstring"""



											if isinstance(_A		,      _A      ):
																__lowerCAmelCase           =	1
											elif isinstance(_A		,      _A      ):
																__lowerCAmelCase           =	len(_A      )
											else:
																raise ValueError(f"""`prompt` has to be of type `str` or `list` but is {type(_A      )}"""      )

											if height % 8 != 0 or width % 8 != 0:
																raise ValueError(f"""`height` and `width` have to be divisible by 8 but are {height} and {width}."""      )

											if (callback_steps is None) or (
											    callback_steps is not None and (not isinstance(_A		,      _A      ) or callback_steps <= 0)
											):
																raise ValueError(
																    f"""`callback_steps` has to be a positive integer but is {callback_steps} of type"""
																    f""" {type(_A      )}."""      )

											# get prompt text embeddings
											__lowerCAmelCase           =	self.tokenizer(
											    _A		,      padding="max_length"		,      max_length=self.tokenizer.model_max_length		,      return_tensors="pt"		,      )
											__lowerCAmelCase           =	text_inputs.input_ids

											if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
																__lowerCAmelCase           =	self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]      )
																logger.warning(
																    "The following part of your input was truncated because CLIP can only handle sequences up to"
																    f""" {self.tokenizer.model_max_length} tokens: {removed_text}"""      )
																__lowerCAmelCase           =	text_input_ids[:, : self.tokenizer.model_max_length]

											if text_embeddings is None:
																__lowerCAmelCase           =	self.text_encoder(text_input_ids.to(self.device      )      )[0]

											# duplicate text embeddings for each generation per prompt, using mps friendly method
											__lowerCAmelCase       ,							__lowerCAmelCase       ,							__lowerCAmelCase           =	text_embeddings.shape
											__lowerCAmelCase           =	text_embeddings.repeat(1		,      _A		,      1      )
											__lowerCAmelCase           =	text_embeddings.view(bs_embed * num_images_per_prompt		,      _A		,      -1      )

											# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
											# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
											# corresponds to doing no classifier free guidance.
											__lowerCAmelCase           =	guidance_scale > 1.0
											# get unconditional embeddings for classifier free guidance
											if do_classifier_free_guidance:
																__lowerCAmelCase           =	4_2
																if negative_prompt is None:
																					__lowerCAmelCase           =	[""]
																elif type(_A      ) is not type(_A      ):
																					raise TypeError(
																					    f"""`negative_prompt` should be the same type to `prompt`, but got {type(_A      )} !="""
																					    f""" {type(_A      )}."""      )
																elif isinstance(_A		,      _A      ):
																					__lowerCAmelCase           =	[negative_prompt]
																elif batch_size != len(_A      ):
																					raise ValueError(
																					    f"""`negative_prompt`: {negative_prompt} has batch size {len(_A      )}, but `prompt`:"""
																					    f""" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"""
																					    " the batch size of `prompt`."      )
																else:
																					__lowerCAmelCase           =	negative_prompt

																__lowerCAmelCase           =	text_input_ids.shape[-1]
																__lowerCAmelCase           =	self.tokenizer(
																    _A		,      padding="max_length"		,      max_length=_A		,      truncation=_A		,      return_tensors="pt"		,      )
																__lowerCAmelCase           =	self.text_encoder(uncond_input.input_ids.to(self.device      )      )[0]

																# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
																__lowerCAmelCase           =	uncond_embeddings.shape[1]
																__lowerCAmelCase           =	uncond_embeddings.repeat(_A		,      _A		,      1      )
																__lowerCAmelCase           =	uncond_embeddings.view(batch_size * num_images_per_prompt		,      _A		,      -1      )

																# For classifier free guidance, we need to do two forward passes.
																# Here we concatenate the unconditional and text embeddings into a single batch
																# to avoid doing two forward passes
																__lowerCAmelCase           =	torch.cat([uncond_embeddings, text_embeddings]      )

											# get the initial random noise unless the user supplied it

											# Unlike in other pipelines, latents need to be generated in the target device
											# for 1-to-1 results reproducibility with the CompVis implementation.
											# However this currently doesn't work in `mps`.
											__lowerCAmelCase           =	(batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
											__lowerCAmelCase           =	(batch_size * num_images_per_prompt, self.unet.config.in_channels, 6_4, 6_4)
											__lowerCAmelCase           =	text_embeddings.dtype
											if latents is None:
																if self.device.type == "mps":
																					# randn does not exist on mps
																					__lowerCAmelCase           =	torch.randn(
																					    _A		,      generator=_A		,      device="cpu"		,      dtype=_A      ).to(self.device      )
																					__lowerCAmelCase           =	torch.randn(_A		,      generator=_A		,      device="cpu"		,      dtype=_A      ).to(
																					    self.device      )
																else:
																					__lowerCAmelCase           =	torch.randn(
																					    _A		,      generator=_A		,      device=self.device		,      dtype=_A      )
																					__lowerCAmelCase           =	torch.randn(_A		,      generator=_A		,      device=self.device		,      dtype=_A      )
											else:
																if latents_reference.shape != latents_shape:
																					raise ValueError(f"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}"""      )
																__lowerCAmelCase           =	latents_reference.to(self.device      )
																__lowerCAmelCase           =	latents.to(self.device      )

											# This is the key part of the pipeline where we
											# try to ensure that the generated images w/ the same seed
											# but different sizes actually result in similar images
											__lowerCAmelCase           =	(latents_shape[3] - latents_shape_reference[3]) // 2
											__lowerCAmelCase           =	(latents_shape[2] - latents_shape_reference[2]) // 2
											__lowerCAmelCase           =	latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
											__lowerCAmelCase           =	latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
											__lowerCAmelCase           =	0 if dx < 0 else dx
											__lowerCAmelCase           =	0 if dy < 0 else dy
											__lowerCAmelCase           =	max(-dx		,      0      )
											__lowerCAmelCase           =	max(-dy		,      0      )
											# import pdb
											# pdb.set_trace()
											__lowerCAmelCase           =	latents_reference[:, :, dy : dy + h, dx : dx + w]

											# set timesteps
											self.scheduler.set_timesteps(_A      )

											# Some schedulers like PNDM have timesteps as arrays
											# It's more optimized to move all timesteps to correct device beforehand
											__lowerCAmelCase           =	self.scheduler.timesteps.to(self.device      )

											# scale the initial noise by the standard deviation required by the scheduler
											__lowerCAmelCase           =	latents * self.scheduler.init_noise_sigma

											# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
											# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
											# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
											# and should be between [0, 1]
											__lowerCAmelCase           =	"eta" in set(inspect.signature(self.scheduler.step      ).parameters.keys()      )
											__lowerCAmelCase           =	{}
											if accepts_eta:
																__lowerCAmelCase           =	eta

											for i, t in enumerate(self.progress_bar(_A      )      ):
																# expand the latents if we are doing classifier free guidance
																__lowerCAmelCase           =	torch.cat([latents] * 2      ) if do_classifier_free_guidance else latents
																__lowerCAmelCase           =	self.scheduler.scale_model_input(_A		,      _A      )

																# predict the noise residual
																__lowerCAmelCase           =	self.unet(_A		,      _A		,      encoder_hidden_states=_A      ).sample

																# perform guidance
																if do_classifier_free_guidance:
																					__lowerCAmelCase       ,							__lowerCAmelCase           =	noise_pred.chunk(2      )
																					__lowerCAmelCase           =	noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

																# compute the previous noisy sample x_t -> x_t-1
																__lowerCAmelCase           =	self.scheduler.step(_A		,      _A		,      _A		,      **_A      ).prev_sample

																# call the callback, if provided
																if callback is not None and i % callback_steps == 0:
																					callback(_A		,      _A		,      _A      )

											__lowerCAmelCase           =	1 / 0.1_82_15 * latents
											__lowerCAmelCase           =	self.vae.decode(_A      ).sample

											__lowerCAmelCase           =	(image / 2 + 0.5).clamp(0		,      1      )

											# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
											__lowerCAmelCase           =	image.cpu().permute(0		,      2		,      3		,      1      ).float().numpy()

											if self.safety_checker is not None:
																__lowerCAmelCase           =	self.feature_extractor(self.numpy_to_pil(_A      )		,      return_tensors="pt"      ).to(
																    self.device      )
																__lowerCAmelCase       ,							__lowerCAmelCase           =	self.safety_checker(
																    images=_A		,      clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype      )      )
											else:
																__lowerCAmelCase           =	None

											if output_type == "pil":
																__lowerCAmelCase           =	self.numpy_to_pil(_A      )

											if not return_dict:
																return (image, has_nsfw_concept)

											return StableDiffusionPipelineOutput(images=_A		,      nsfw_content_detected=_A      )










from typing import Any, Dict, Optional

import torch
import torch.nn.functional as F
from torch import nn

from ..utils import maybe_allow_in_graph
from .activations import get_activation
from .attention_processor import Attention
from .embeddings import CombinedTimestepLabelEmbeddings
@maybe_allow_in_graph
class       a__   ( nn.Module				):






						def __init__(       self		,      _A		,      _A		,      _A		,      _A=0.0		,      _A = None		,      _A = "geglu"		,      _A = None		,      _A = False		,      _A = False		,      _A = False		,      _A = False		,      _A = True		,      _A = "layer_norm"		,      _A = False		,      ):




											"""simple docstring"""



											super().__init__()
											__lowerCAmelCase           =	only_cross_attention

											__lowerCAmelCase           =	(num_embeds_ada_norm is not None) and norm_type == "ada_norm_zero"
											__lowerCAmelCase           =	(num_embeds_ada_norm is not None) and norm_type == "ada_norm"

											if norm_type in ("ada_norm", "ada_norm_zero") and num_embeds_ada_norm is None:
																raise ValueError(
																    f"""`norm_type` is set to {norm_type}, but `num_embeds_ada_norm` is not defined. Please make sure to"""
																    f""" define `num_embeds_ada_norm` if setting `norm_type` to {norm_type}."""      )

											# Define 3 blocks. Each block has its own normalization layer.
											# 1. Self-Attn
											if self.use_ada_layer_norm:
																__lowerCAmelCase           =	AdaLayerNorm(_A		,      _A      )
											elif self.use_ada_layer_norm_zero:
																__lowerCAmelCase           =	AdaLayerNormZero(_A		,      _A      )
											else:
																__lowerCAmelCase           =	nn.LayerNorm(_A		,      elementwise_affine=_A      )
											__lowerCAmelCase           =	Attention(
											    query_dim=_A		,      heads=_A		,      dim_head=_A		,      dropout=_A		,      bias=_A		,      cross_attention_dim=cross_attention_dim if only_cross_attention else None		,      upcast_attention=_A		,      )

											# 2. Cross-Attn
											if cross_attention_dim is not None or double_self_attention:
																# We currently only use AdaLayerNormZero for self attention where there will only be one attention block.
																# I.e. the number of returned modulation chunks from AdaLayerZero would not make sense if returned during
																# the second cross attention block.
																__lowerCAmelCase           =	(
																    AdaLayerNorm(_A		,      _A      )
																    if self.use_ada_layer_norm
																    else nn.LayerNorm(_A		,      elementwise_affine=_A      )
																)
																__lowerCAmelCase           =	Attention(
																    query_dim=_A		,      cross_attention_dim=cross_attention_dim if not double_self_attention else None		,      heads=_A		,      dim_head=_A		,      dropout=_A		,      bias=_A		,      upcast_attention=_A		,      )  # is self-attn if encoder_hidden_states is none
											else:
																__lowerCAmelCase           =	None
																__lowerCAmelCase           =	None

											# 3. Feed-forward
											__lowerCAmelCase           =	nn.LayerNorm(_A		,      elementwise_affine=_A      )
											__lowerCAmelCase           =	FeedForward(_A		,      dropout=_A		,      activation_fn=_A		,      final_dropout=_A      )

											# let chunk size default to None
											__lowerCAmelCase           =	None
											__lowerCAmelCase           =	0






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	chunk_size
											__lowerCAmelCase           =	dim






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A = None		,      _A = None		,      _A = None		,      _A = None		,      _A = None		,      _A = None		,      ):




											"""simple docstring"""



											if self.use_ada_layer_norm:
																__lowerCAmelCase           =	self.norma(_A		,      _A      )
											elif self.use_ada_layer_norm_zero:
																__lowerCAmelCase       ,							__lowerCAmelCase       ,							__lowerCAmelCase       ,							__lowerCAmelCase       ,							__lowerCAmelCase           =	self.norma(
																    _A		,      _A		,      _A		,      hidden_dtype=hidden_states.dtype      )
											else:
																__lowerCAmelCase           =	self.norma(_A      )

											__lowerCAmelCase           =	cross_attention_kwargs if cross_attention_kwargs is not None else {}

											__lowerCAmelCase           =	self.attna(
											    _A		,      encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None		,      attention_mask=_A		,      **_A		,      )
											if self.use_ada_layer_norm_zero:
																__lowerCAmelCase           =	gate_msa.unsqueeze(1      ) * attn_output
											__lowerCAmelCase           =	attn_output + hidden_states

											# 2. Cross-Attention
											if self.attna is not None:
																__lowerCAmelCase           =	(
																    self.norma(_A		,      _A      ) if self.use_ada_layer_norm else self.norma(_A      )
																)

																__lowerCAmelCase           =	self.attna(
																    _A		,      encoder_hidden_states=_A		,      attention_mask=_A		,      **_A		,      )
																__lowerCAmelCase           =	attn_output + hidden_states

											# 3. Feed-forward
											__lowerCAmelCase           =	self.norma(_A      )

											if self.use_ada_layer_norm_zero:
																__lowerCAmelCase           =	norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None]

											if self._chunk_size is not None:
																# "feed_forward_chunk_size" can be used to save memory
																if norm_hidden_states.shape[self._chunk_dim] % self._chunk_size != 0:
																					raise ValueError(
																					    f"""`hidden_states` dimension to be chunked: {norm_hidden_states.shape[self._chunk_dim]} has to be divisible by chunk size: {self._chunk_size}. Make sure to set an appropriate `chunk_size` when calling `unet.enable_forward_chunking`."""      )

																__lowerCAmelCase           =	norm_hidden_states.shape[self._chunk_dim] // self._chunk_size
																__lowerCAmelCase           =	torch.cat(
																    [self.ff(_A      ) for hid_slice in norm_hidden_states.chunk(_A		,      dim=self._chunk_dim      )]		,      dim=self._chunk_dim		,      )
											else:
																__lowerCAmelCase           =	self.ff(_A      )

											if self.use_ada_layer_norm_zero:
																__lowerCAmelCase           =	gate_mlp.unsqueeze(1      ) * ff_output

											__lowerCAmelCase           =	ff_output + hidden_states

											return hidden_states






class       a__   ( nn.Module				):






						def __init__(       self		,      _A		,      _A = None		,      _A = 4		,      _A = 0.0		,      _A = "geglu"		,      _A = False		,      ):




											"""simple docstring"""



											super().__init__()
											__lowerCAmelCase           =	int(dim * mult      )
											__lowerCAmelCase           =	dim_out if dim_out is not None else dim

											if activation_fn == "gelu":
																__lowerCAmelCase           =	GELU(_A		,      _A      )
											if activation_fn == "gelu-approximate":
																__lowerCAmelCase           =	GELU(_A		,      _A		,      approximate="tanh"      )
											elif activation_fn == "geglu":
																__lowerCAmelCase           =	GEGLU(_A		,      _A      )
											elif activation_fn == "geglu-approximate":
																__lowerCAmelCase           =	ApproximateGELU(_A		,      _A      )

											__lowerCAmelCase           =	nn.ModuleList([]      )
											# project in
											self.net.append(_A      )
											# project dropout
											self.net.append(nn.Dropout(_A      )      )
											# project out
											self.net.append(nn.Linear(_A		,      _A      )      )
											# FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout
											if final_dropout:
																self.net.append(nn.Dropout(_A      )      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A      ):




											"""simple docstring"""



											for module in self.net:
																__lowerCAmelCase           =	module(_A      )
											return hidden_states






class       a__   ( nn.Module				):






						def __init__(       self		,      _A		,      _A		,      _A = "none"      ):




											"""simple docstring"""



											super().__init__()
											__lowerCAmelCase           =	nn.Linear(_A		,      _A      )
											__lowerCAmelCase           =	approximate






						def     __SCREAMING_SNAKE_CASE(       self		,      _A      ):




											"""simple docstring"""



											if gate.device.type != "mps":
																return F.gelu(_A		,      approximate=self.approximate      )
											# mps: gelu is not implemented for float16
											return F.gelu(gate.to(dtype=torch.floataa      )		,      approximate=self.approximate      ).to(dtype=gate.dtype      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.proj(_A      )
											__lowerCAmelCase           =	self.gelu(_A      )
											return hidden_states






class       a__   ( nn.Module				):






						def __init__(       self		,      _A		,      _A      ):




											"""simple docstring"""



											super().__init__()
											__lowerCAmelCase           =	nn.Linear(_A		,      dim_out * 2      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A      ):




											"""simple docstring"""



											if gate.device.type != "mps":
																return F.gelu(_A      )
											# mps: gelu is not implemented for float16
											return F.gelu(gate.to(dtype=torch.floataa      )      ).to(dtype=gate.dtype      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase       ,							__lowerCAmelCase           =	self.proj(_A      ).chunk(2		,      dim=-1      )
											return hidden_states * self.gelu(_A      )






class       a__   ( nn.Module				):






						def __init__(       self		,      _A		,      _A      ):




											"""simple docstring"""



											super().__init__()
											__lowerCAmelCase           =	nn.Linear(_A		,      _A      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.proj(_A      )
											return x * torch.sigmoid(1.7_02 * x      )






class       a__   ( nn.Module				):






						def __init__(       self		,      _A		,      _A      ):




											"""simple docstring"""



											super().__init__()
											__lowerCAmelCase           =	nn.Embedding(_A		,      _A      )
											__lowerCAmelCase           =	nn.SiLU()
											__lowerCAmelCase           =	nn.Linear(_A		,      embedding_dim * 2      )
											__lowerCAmelCase           =	nn.LayerNorm(_A		,      elementwise_affine=_A      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.linear(self.silu(self.emb(_A      )      )      )
											__lowerCAmelCase       ,							__lowerCAmelCase           =	torch.chunk(_A		,      2      )
											__lowerCAmelCase           =	self.norm(_A      ) * (1 + scale) + shift
											return x






class       a__   ( nn.Module				):






						def __init__(       self		,      _A		,      _A      ):




											"""simple docstring"""



											super().__init__()

											__lowerCAmelCase           =	CombinedTimestepLabelEmbeddings(_A		,      _A      )

											__lowerCAmelCase           =	nn.SiLU()
											__lowerCAmelCase           =	nn.Linear(_A		,      6 * embedding_dim		,      bias=_A      )
											__lowerCAmelCase           =	nn.LayerNorm(_A		,      elementwise_affine=_A		,      eps=1E-6      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A=None      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.linear(self.silu(self.emb(_A		,      _A		,      hidden_dtype=_A      )      )      )
											__lowerCAmelCase       ,							__lowerCAmelCase       ,							__lowerCAmelCase       ,							__lowerCAmelCase       ,							__lowerCAmelCase       ,							__lowerCAmelCase           =	emb.chunk(6		,      dim=1      )
											__lowerCAmelCase           =	self.norm(_A      ) * (1 + scale_msa[:, None]) + shift_msa[:, None]
											return x, gate_msa, shift_mlp, scale_mlp, gate_mlp






class       a__   ( nn.Module				):






						def __init__(       self		,      _A		,      _A		,      _A		,      _A = None		,      _A = 1E-5      ):




											"""simple docstring"""



											super().__init__()
											__lowerCAmelCase           =	num_groups
											__lowerCAmelCase           =	eps

											if act_fn is None:
																__lowerCAmelCase           =	None
											else:
																__lowerCAmelCase           =	get_activation(_A      )

											__lowerCAmelCase           =	nn.Linear(_A		,      out_dim * 2      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A      ):




											"""simple docstring"""



											if self.act:
																__lowerCAmelCase           =	self.act(_A      )
											__lowerCAmelCase           =	self.linear(_A      )
											__lowerCAmelCase           =	emb[:, :, None, None]
											__lowerCAmelCase       ,							__lowerCAmelCase           =	emb.chunk(2		,      dim=1      )

											__lowerCAmelCase           =	F.group_norm(_A		,      self.num_groups		,      eps=self.eps      )
											__lowerCAmelCase           =	x * (1 + scale) + shift
											return x




