





'''simple docstring'''







import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()
class 				__SCREAMING_SNAKE_CASE  (lowerCamelCase_       ,							lowerCamelCase_       ,							lowerCamelCase_       ,							unittest.TestCase      ):






				"""simple docstring"""







				__a            =StableUnCLIPImgaImgPipeline
				__a            =TEXT_GUIDED_IMAGE_VARIATION_PARAMS
				__a            =TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
				__a            =frozenset(
				    []      )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
				__a            =frozenset([]      )




				def   UpperCamelCase__   (  self     :					Dict					):
								_a								= 32
								_a								= embedder_hidden_size

								# image encoding components

								_a								= CLIPImageProcessor(crop_size=32					,				size=32					)

								torch.manual_seed(0					)
								_a								= CLIPVisionModelWithProjection(
								    CLIPVisionConfig(
								        hidden_size=__a					,				projection_dim=__a					,				num_hidden_layers=5					,				num_attention_heads=4					,				image_size=32					,				intermediate_size=37					,				patch_size=1					,				)					)

								# regular denoising components

								torch.manual_seed(0					)
								_a								= StableUnCLIPImageNormalizer(embedding_dim=__a					)
								_a								= DDPMScheduler(beta_schedule="squaredcos_cap_v2"					)

								torch.manual_seed(0					)
								_a								= CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"					)

								torch.manual_seed(0					)
								_a								= CLIPTextModel(
								    CLIPTextConfig(
								        bos_token_id=0					,				eos_token_id=2					,				hidden_size=__a					,				projection_dim=32					,				intermediate_size=37					,				layer_norm_eps=1e-0_5					,				num_attention_heads=4					,				num_hidden_layers=5					,				pad_token_id=1					,				vocab_size=10_00					,				)					)

								torch.manual_seed(0					)
								_a								= UNetaDConditionModel(
								    sample_size=32					,				in_channels=4					,				out_channels=4					,				down_block_types=("CrossAttnDownBlock2D", "DownBlock2D")					,				up_block_types=("UpBlock2D", "CrossAttnUpBlock2D")					,				block_out_channels=(32, 64)					,				attention_head_dim=(2, 4)					,				class_embed_type="projection"					,				projection_class_embeddings_input_dim=embedder_projection_dim * 2					,				cross_attention_dim=__a					,				layers_per_block=1					,				upcast_attention=__a					,				use_linear_projection=__a					,				)

								torch.manual_seed(0					)
								_a								= DDIMScheduler(
								    beta_schedule="scaled_linear"					,				beta_start=0.00085					,				beta_end=0.012					,				prediction_type="v_prediction"					,				set_alpha_to_one=__a					,				steps_offset=1					,				)

								torch.manual_seed(0					)
								_a								= AutoencoderKL()

								_a								= {
								    # image encoding components
								    "feature_extractor": feature_extractor,
								    "image_encoder": image_encoder.eval(),
								    # image noising components
								    "image_normalizer": image_normalizer.eval(),
								    "image_noising_scheduler": image_noising_scheduler,
								    # regular denoising components
								    "tokenizer": tokenizer,
								    "text_encoder": text_encoder.eval(),
								    "unet": unet.eval(),
								    "scheduler": scheduler,
								    "vae": vae.eval(),
								}

								return components




				def   UpperCamelCase__   (  self     :					Optional[Any]					,				__a     :					Optional[Any]					,				__a     :					List[Any]=0					,				__a     :					Dict=True					):
								if str(__a					).startswith("mps"					):
												_a								= torch.manual_seed(__a					)
								else:
												_a								= torch.Generator(device=__a					).manual_seed(__a					)

								_a								= floats_tensor((1, 3, 32, 32)					,				rng=random.Random(__a					)					).to(__a					)

								if pil_image:
												_a								= input_image * 0.5 + 0.5
												_a								= input_image.clamp(0					,				1					)
												_a								= input_image.cpu().permute(0					,				2					,				3					,				1					).float().numpy()
												_a								= DiffusionPipeline.numpy_to_pil(__a					)[0]

								return {
								    "prompt": "An anime racoon running a marathon",
								    "image": input_image,
								    "generator": generator,
								    "num_inference_steps": 2,
								    "output_type": "np",
								}




				@skip_mps
				def   UpperCamelCase__   (  self     :					Optional[Any]					):
								_a								= "cpu"  # ensure determinism for the device-dependent torch.Generator
								_a								= self.get_dummy_components()
								_a								= StableUnCLIPImgaImgPipeline(**__a					)
								_a								= sd_pipe.to(__a					)
								sd_pipe.set_progress_bar_config(disable=__a					)

								_a								= self.get_dummy_inputs(__a					)
								inputs.update({"image_embeds": None}					)
								_a								= sd_pipe(**__a					).images
								_a								= image[0, -3:, -3:, -1]

								assert image.shape == (1, 32, 32, 3)
								_a								= np.array([0.3872, 0.7224, 0.5601, 0.4741, 0.6872, 0.5814, 0.4636, 0.3867, 0.5078]					)

								assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-3




				def   UpperCamelCase__   (  self     :					List[Any]					):
								_a								= torch_device in ["cpu", "mps"]

								self._test_attention_slicing_forward_pass(test_max_difference=__a					)




				def   UpperCamelCase__   (  self     :					Any					):
								_a								= torch_device in ["cpu", "mps"]

								self._test_inference_batch_single_identical(test_max_difference=__a					)




				@unittest.skipIf(
				    torch_device != "cuda" or not is_xformers_available()					,				reason="XFormers attention is only available with CUDA and `xformers` installed"					,				)
				def   UpperCamelCase__   (  self     :					Union[str, Any]					):
								self._test_xformers_attention_forwardGenerator_pass(test_max_difference=__a					)


@slow
@require_torch_gpu
class 				__SCREAMING_SNAKE_CASE  (unittest.TestCase      ):






				"""simple docstring"""







				def   UpperCamelCase__   (  self     :					Optional[int]					):
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()




				def   UpperCamelCase__   (  self     :					str					):
								_a								= load_image(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"					)

								_a								= load_numpy(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy"					)

								_a								= StableUnCLIPImgaImgPipeline.from_pretrained(
								    "fusing/stable-unclip-2-1-l-img2img"					,				torch_dtype=torch.floataa					)
								pipe.to(__a					)
								pipe.set_progress_bar_config(disable=__a					)
								# stable unclip will oom when integration tests are run on a V100,
								# so turn on memory savings
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								_a								= torch.Generator(device="cpu"					).manual_seed(0					)
								_a								= pipe(__a					,				"anime turle"					,				generator=__a					,				output_type="np"					)

								_a								= output.images[0]

								assert image.shape == (7_68, 7_68, 3)

								assert_mean_pixel_difference(__a					,				__a					)




				def   UpperCamelCase__   (  self     :					Tuple					):
								_a								= load_image(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"					)

								_a								= load_numpy(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy"					)

								_a								= StableUnCLIPImgaImgPipeline.from_pretrained(
								    "fusing/stable-unclip-2-1-h-img2img"					,				torch_dtype=torch.floataa					)
								pipe.to(__a					)
								pipe.set_progress_bar_config(disable=__a					)
								# stable unclip will oom when integration tests are run on a V100,
								# so turn on memory savings
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								_a								= torch.Generator(device="cpu"					).manual_seed(0					)
								_a								= pipe(__a					,				"anime turle"					,				generator=__a					,				output_type="np"					)

								_a								= output.images[0]

								assert image.shape == (7_68, 7_68, 3)

								assert_mean_pixel_difference(__a					,				__a					)




				def   UpperCamelCase__   (  self     :					Any					):
								_a								= load_image(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"					)

								torch.cuda.empty_cache()
								torch.cuda.reset_max_memory_allocated()
								torch.cuda.reset_peak_memory_stats()

								_a								= StableUnCLIPImgaImgPipeline.from_pretrained(
								    "fusing/stable-unclip-2-1-h-img2img"					,				torch_dtype=torch.floataa					)
								_a								= pipe.to(__a					)
								pipe.set_progress_bar_config(disable=__a					)
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								_a								= pipe(
								    __a					,				"anime turtle"					,				num_inference_steps=2					,				output_type="np"					,				)

								_a								= torch.cuda.max_memory_allocated()
								# make sure that less than 7 GB is allocated
								assert mem_bytes < 7 * 10**9




import collections
import gzip
import os
import urllib

import numpy
from tensorflow.python.framework import dtypes, random_seed
from tensorflow.python.platform import gfile
from tensorflow.python.util.deprecation import deprecated

_A		       =						collections.namedtuple('_Datasets', ['train', 'validation', 'test'])

# CVDF mirror of http://yann.lecun.com/exdb/mnist/
_A		       =						'https://storage.googleapis.com/cvdf-datasets/mnist/'

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int				):
     __UpperCamelCase    							=numpy.dtype(numpy.uintaa				).newbyteorder('>'				)
     return numpy.frombuffer(bytestream.read(4				)			,     dtype=SCREAMING_SNAKE_CASE__				)[0]

@deprecated(SCREAMING_SNAKE_CASE__			,     'Please use tf.data to implement this functionality.'				)
def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					Optional[Any]				):
     print('Extracting'			,     f.name				)
     with gzip.GzipFile(fileobj=SCREAMING_SNAKE_CASE__				) as bytestream:
          __UpperCamelCase    							=_readaa(SCREAMING_SNAKE_CASE__				)
          if magic != 20_51:
               raise ValueError(
                   'Invalid magic number %d in MNIST image file: %s' % (magic, f.name)				)
          __UpperCamelCase    							=_readaa(SCREAMING_SNAKE_CASE__				)
          __UpperCamelCase    							=_readaa(SCREAMING_SNAKE_CASE__				)
          __UpperCamelCase    							=_readaa(SCREAMING_SNAKE_CASE__				)
          __UpperCamelCase    							=bytestream.read(rows * cols * num_images				)
          __UpperCamelCase    							=numpy.frombuffer(SCREAMING_SNAKE_CASE__			,     dtype=numpy.uinta				)
          __UpperCamelCase    							=data.reshape(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     1				)
          return data

@deprecated(SCREAMING_SNAKE_CASE__			,     'Please use tf.one_hot on tensors.'				)
def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					Union[str, Any]			,     SCREAMING_SNAKE_CASE__			:					List[Any]				):
     __UpperCamelCase    							=labels_dense.shape[0]
     __UpperCamelCase    							=numpy.arange(SCREAMING_SNAKE_CASE__				) * num_classes
     __UpperCamelCase    							=numpy.zeros((num_labels, num_classes)				)
     __UpperCamelCase    							=1
     return labels_one_hot

@deprecated(SCREAMING_SNAKE_CASE__			,     'Please use tf.data to implement this functionality.'				)
def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					List[str]			,     SCREAMING_SNAKE_CASE__			:					Dict=False			,     SCREAMING_SNAKE_CASE__			:					str=10				):
     print('Extracting'			,     f.name				)
     with gzip.GzipFile(fileobj=SCREAMING_SNAKE_CASE__				) as bytestream:
          __UpperCamelCase    							=_readaa(SCREAMING_SNAKE_CASE__				)
          if magic != 20_49:
               raise ValueError(
                   'Invalid magic number %d in MNIST label file: %s' % (magic, f.name)				)
          __UpperCamelCase    							=_readaa(SCREAMING_SNAKE_CASE__				)
          __UpperCamelCase    							=bytestream.read(SCREAMING_SNAKE_CASE__				)
          __UpperCamelCase    							=numpy.frombuffer(SCREAMING_SNAKE_CASE__			,     dtype=numpy.uinta				)
          if one_hot:
               return _dense_to_one_hot(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)
          return labels






class     UpperCAmelCase__       :



    """simple docstring"""






    @deprecated(
        A_					,   'Please use alternatives such as official/mnist/_DataSet.py'
        ' from tensorflow/models.'					,   )
    def __init__(			self					,   A_					,   A_					,   A_=False					,   A_=False					,   A_=dtypes.floataa					,   A_=True					,   A_=None					,   )  ->       Optional[int]:
         __UpperCamelCase							,      __UpperCamelCase    							=random_seed.get_seed(A_    )
         # If op level seed is not set, use whatever graph level seed is returned
         numpy.random.seed(seeda if seed is None else seeda    )
         __UpperCamelCase    							=dtypes.as_dtype(A_    ).base_dtype
         if dtype not in (dtypes.uinta, dtypes.floataa):
              raise TypeError('Invalid image dtype %r, expected uint8 or float32' % dtype    )
         if fake_data:
              __UpperCamelCase    							=10000
              __UpperCamelCase    							=one_hot
         else:
              assert (
                  images.shape[0] == labels.shape[0]
              ), f'images.shape: {images.shape} labels.shape: {labels.shape}'
              __UpperCamelCase    							=images.shape[0]

              # Convert shape from [num examples, rows, columns, depth]
              # to [num examples, rows*columns] (assuming depth == 1)
              if reshape:
                   assert images.shape[3] == 1
                   __UpperCamelCase    							=images.reshape(
                       images.shape[0]					,   images.shape[1] * images.shape[2]    )
              if dtype == dtypes.floataa:
                   # Convert from [0, 255] -> [0.0, 1.0].
                   __UpperCamelCase    							=images.astype(numpy.floataa    )
                   __UpperCamelCase    							=numpy.multiply(A_					,   1.0 / 255.0    )
         __UpperCamelCase    							=images
         __UpperCamelCase    							=labels
         __UpperCamelCase    							=0
         __UpperCamelCase    							=0






    @property
    def _a					(			self    )  ->       Tuple:
         return self._images






    @property
    def _a					(			self    )  ->       Union[str, Any]:
         return self._labels






    @property
    def _a					(			self    )  ->       Optional[Any]:
         return self._num_examples






    @property
    def _a					(			self    )  ->       List[str]:
         return self._epochs_completed






    def _a					(			self					,   A_					,   A_=False					,   A_=True    )  ->       Optional[Any]:
         if fake_data:
              __UpperCamelCase    							=[1] * 784
              __UpperCamelCase    							=[1] + [0] * 9 if self.one_hot else 0
              return (
                  [fake_image for _ in range(A_    )],
                  [fake_label for _ in range(A_    )],
              )
         __UpperCamelCase    							=self._index_in_epoch
         # Shuffle for the first epoch
         if self._epochs_completed == 0 and start == 0 and shuffle:
              __UpperCamelCase    							=numpy.arange(self._num_examples    )
              numpy.random.shuffle(A_    )
              __UpperCamelCase    							=self.images[perma]
              __UpperCamelCase    							=self.labels[perma]
         # Go to the next epoch
         if start + batch_size > self._num_examples:
              # Finished epoch
              self._epochs_completed += 1
              # Get the rest examples in this epoch
              __UpperCamelCase    							=self._num_examples - start
              __UpperCamelCase    							=self._images[start : self._num_examples]
              __UpperCamelCase    							=self._labels[start : self._num_examples]
              # Shuffle the data
              if shuffle:
                   __UpperCamelCase    							=numpy.arange(self._num_examples    )
                   numpy.random.shuffle(A_    )
                   __UpperCamelCase    							=self.images[perm]
                   __UpperCamelCase    							=self.labels[perm]
              # Start next epoch
              __UpperCamelCase    							=0
              __UpperCamelCase    							=batch_size - rest_num_examples
              __UpperCamelCase    							=self._index_in_epoch
              __UpperCamelCase    							=self._images[start:end]
              __UpperCamelCase    							=self._labels[start:end]
              return (
                  numpy.concatenate((images_rest_part, images_new_part)					,   axis=0    ),
                  numpy.concatenate((labels_rest_part, labels_new_part)					,   axis=0    ),
              )
         else:
              self._index_in_epoch += batch_size
              __UpperCamelCase    							=self._index_in_epoch
              return self._images[start:end], self._labels[start:end]

@deprecated(SCREAMING_SNAKE_CASE__			,     'Please write your own downloading logic.'				)
def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					Tuple			,     SCREAMING_SNAKE_CASE__			:					List[Any]			,     SCREAMING_SNAKE_CASE__			:					str				):
     if not gfile.Exists(SCREAMING_SNAKE_CASE__				):
          gfile.MakeDirs(SCREAMING_SNAKE_CASE__				)
     __UpperCamelCase    							=os.path.join(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)
     if not gfile.Exists(SCREAMING_SNAKE_CASE__				):
          urllib.request.urlretrieve(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)  # noqa: S310
          with gfile.GFile(SCREAMING_SNAKE_CASE__				) as f:
               __UpperCamelCase    							=f.size()
          print('Successfully downloaded'			,     SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     'bytes.'				)
     return filepath





@deprecated(
    SCREAMING_SNAKE_CASE__			,     'Please use alternatives such as:' ' tensorflow_datasets.load(\'mnist\')'				)
def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					Optional[int]			,     SCREAMING_SNAKE_CASE__			:					int=False			,     SCREAMING_SNAKE_CASE__			:					str=False			,     SCREAMING_SNAKE_CASE__			:					Union[str, Any]=dtypes.floataa			,     SCREAMING_SNAKE_CASE__			:					Optional[int]=True			,     SCREAMING_SNAKE_CASE__			:					str=50_00			,     SCREAMING_SNAKE_CASE__			:					List[Any]=None			,     SCREAMING_SNAKE_CASE__			:					str=DEFAULT_SOURCE_URL			,     ):
     if fake_data:

          def fake():
               return _DataSet(
                   []			,     []			,     fake_data=SCREAMING_SNAKE_CASE__			,     one_hot=SCREAMING_SNAKE_CASE__			,     dtype=SCREAMING_SNAKE_CASE__			,     seed=SCREAMING_SNAKE_CASE__				)

          __UpperCamelCase    							=fake()
          __UpperCamelCase    							=fake()
          __UpperCamelCase    							=fake()
          return _Datasets(train=SCREAMING_SNAKE_CASE__			,     validation=SCREAMING_SNAKE_CASE__			,     test=SCREAMING_SNAKE_CASE__				)

     if not source_url:  # empty string check
          __UpperCamelCase    							=DEFAULT_SOURCE_URL

     __UpperCamelCase    							='train-images-idx3-ubyte.gz'
     __UpperCamelCase    							='train-labels-idx1-ubyte.gz'
     __UpperCamelCase    							='t10k-images-idx3-ubyte.gz'
     __UpperCamelCase    							='t10k-labels-idx1-ubyte.gz'

     __UpperCamelCase    							=_maybe_download(
         SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     source_url + train_images_file				)
     with gfile.Open(SCREAMING_SNAKE_CASE__			,     'rb'				) as f:
          __UpperCamelCase    							=_extract_images(SCREAMING_SNAKE_CASE__				)

     __UpperCamelCase    							=_maybe_download(
         SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     source_url + train_labels_file				)
     with gfile.Open(SCREAMING_SNAKE_CASE__			,     'rb'				) as f:
          __UpperCamelCase    							=_extract_labels(SCREAMING_SNAKE_CASE__			,     one_hot=SCREAMING_SNAKE_CASE__				)

     __UpperCamelCase    							=_maybe_download(
         SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     source_url + test_images_file				)
     with gfile.Open(SCREAMING_SNAKE_CASE__			,     'rb'				) as f:
          __UpperCamelCase    							=_extract_images(SCREAMING_SNAKE_CASE__				)

     __UpperCamelCase    							=_maybe_download(
         SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     source_url + test_labels_file				)
     with gfile.Open(SCREAMING_SNAKE_CASE__			,     'rb'				) as f:
          __UpperCamelCase    							=_extract_labels(SCREAMING_SNAKE_CASE__			,     one_hot=SCREAMING_SNAKE_CASE__				)

     if not 0 <= validation_size <= len(SCREAMING_SNAKE_CASE__				):
          __UpperCamelCase    							=(
              'Validation size should be between 0 and '
              F'{len(SCREAMING_SNAKE_CASE__				)}. Received: {validation_size}.'
          )
          raise ValueError(SCREAMING_SNAKE_CASE__				)

     __UpperCamelCase    							=train_images[:validation_size]
     __UpperCamelCase    							=train_labels[:validation_size]
     __UpperCamelCase    							=train_images[validation_size:]
     __UpperCamelCase    							=train_labels[validation_size:]

     __UpperCamelCase    							={'dtype': dtype, 'reshape': reshape, 'seed': seed}

     __UpperCamelCase    							=_DataSet(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     **SCREAMING_SNAKE_CASE__				)
     __UpperCamelCase    							=_DataSet(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     **SCREAMING_SNAKE_CASE__				)
     __UpperCamelCase    							=_DataSet(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     **SCREAMING_SNAKE_CASE__				)

     return _Datasets(train=SCREAMING_SNAKE_CASE__			,     validation=SCREAMING_SNAKE_CASE__			,     test=SCREAMING_SNAKE_CASE__				)





