

'''simple docstring'''

import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







class   UpperCamelCase__   (       snake_case__							,							snake_case__							,							unittest.TestCase       ):


		"""simple docstring"""

		SCREAMING_SNAKE_CASE__  :     int       =							StableDiffusionXLPipeline
		SCREAMING_SNAKE_CASE__  :     str       =							TEXT_TO_IMAGE_PARAMS
		SCREAMING_SNAKE_CASE__  :     int       =							TEXT_TO_IMAGE_BATCH_PARAMS
		SCREAMING_SNAKE_CASE__  :     Optional[Any]       =							TEXT_TO_IMAGE_IMAGE_PARAMS
		SCREAMING_SNAKE_CASE__  :     Dict       =							TEXT_TO_IMAGE_IMAGE_PARAMS







		def 				A_	(			self      ):


							'''simple docstring'''

							torch.manual_seed(0      )
							UpperCAmelCase		:							Dict        =       UNetaDConditionModel(
							    block_out_channels=(3_2, 6_4)   ,      layers_per_block=2   ,      sample_size=3_2   ,      in_channels=4   ,      out_channels=4   ,      down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")   ,      up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")   ,      attention_head_dim=(2, 4)   ,      use_linear_projection=snake_case   ,      addition_embed_type="text_time"   ,      addition_time_embed_dim=8   ,      transformer_layers_per_block=(1, 2)   ,      projection_class_embeddings_input_dim=8_0   ,      cross_attention_dim=6_4   ,      )
							UpperCAmelCase		:							int        =       EulerDiscreteScheduler(
							    beta_start=0.0_0085   ,      beta_end=0.012   ,      steps_offset=1   ,      beta_schedule="scaled_linear"   ,      timestep_spacing="leading"   ,      )
							torch.manual_seed(0      )
							UpperCAmelCase		:							Dict        =       AutoencoderKL(
							    block_out_channels=[3_2, 6_4]   ,      in_channels=3   ,      out_channels=3   ,      down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]   ,      up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]   ,      latent_channels=4   ,      sample_size=1_2_8   ,      )
							torch.manual_seed(0      )
							UpperCAmelCase		:							List[str]        =       CLIPTextConfig(
							    bos_token_id=0   ,      eos_token_id=2   ,      hidden_size=3_2   ,      intermediate_size=3_7   ,      layer_norm_eps=1e-05   ,      num_attention_heads=4   ,      num_hidden_layers=5   ,      pad_token_id=1   ,      vocab_size=1_0_0_0   ,      hidden_act="gelu"   ,      projection_dim=3_2   ,      )
							UpperCAmelCase		:							str        =       CLIPTextModel(snake_case      )
							UpperCAmelCase		:							Tuple        =       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"   ,      local_files_only=snake_case      )

							UpperCAmelCase		:							List[str]        =       CLIPTextModelWithProjection(snake_case      )
							UpperCAmelCase		:							Union[str, Any]        =       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"   ,      local_files_only=snake_case      )

							UpperCAmelCase		:							Any        =       {
							    "unet": unet,
							    "scheduler": scheduler,
							    "vae": vae,
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							    "text_encoder_2": text_encoder_a,
							    "tokenizer_2": tokenizer_a,
							    # "safety_checker": None,
							    # "feature_extractor": None,
							}
							return components







		def 				A_	(			self   ,      snake_case   ,      snake_case=0      ):


							'''simple docstring'''

							if str(snake_case      ).startswith("mps"      ):
												UpperCAmelCase		:							List[str]        =       torch.manual_seed(snake_case      )
							else:
												UpperCAmelCase		:							Tuple        =       torch.Generator(device=snake_case      ).manual_seed(snake_case      )
							UpperCAmelCase		:							int        =       {
							    "prompt": "A painting of a squirrel eating a burger",
							    "generator": generator,
							    "num_inference_steps": 2,
							    "guidance_scale": 5.0,
							    "output_type": "numpy",
							}
							return inputs







		def 				A_	(			self      ):


							'''simple docstring'''

							UpperCAmelCase		:							Tuple        =       "cpu"  # ensure determinism for the device-dependent torch.Generator
							UpperCAmelCase		:							Union[str, Any]        =       self.get_dummy_components()
							UpperCAmelCase		:							Optional[int]        =       StableDiffusionXLPipeline(**snake_case      )
							UpperCAmelCase		:							Optional[Any]        =       sd_pipe.to(snake_case      )
							sd_pipe.set_progress_bar_config(disable=snake_case      )

							UpperCAmelCase		:							Dict        =       self.get_dummy_inputs(snake_case      )
							UpperCAmelCase		:							Optional[Any]        =       sd_pipe(**snake_case      ).images
							UpperCAmelCase		:							List[str]        =       image[0, -3:, -3:, -1]

							assert image.shape == (1, 6_4, 6_4, 3)
							UpperCAmelCase		:							Tuple        =       np.array([0.5873, 0.6128, 0.4797, 0.5122, 0.5674, 0.4639, 0.5227, 0.5149, 0.4747]      )

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







		def 				A_	(			self      ):


							'''simple docstring'''

							UpperCAmelCase		:							Tuple        =       self.get_dummy_components()
							UpperCAmelCase		:							Optional[int]        =       StableDiffusionXLPipeline(**snake_case      )
							UpperCAmelCase		:							List[str]        =       sd_pipe.to(snake_case      )
							UpperCAmelCase		:							Tuple        =       sd_pipe.to(snake_case      )
							sd_pipe.set_progress_bar_config(disable=snake_case      )

							# forward without prompt embeds
							UpperCAmelCase		:							Optional[int]        =       self.get_dummy_inputs(snake_case      )
							UpperCAmelCase		:							int        =       3 * ["this is a negative prompt"]
							UpperCAmelCase		:							List[str]        =       negative_prompt
							UpperCAmelCase		:							Optional[Any]        =       3 * [inputs["prompt"]]

							UpperCAmelCase		:							List[str]        =       sd_pipe(**snake_case      )
							UpperCAmelCase		:							Union[str, Any]        =       output.images[0, -3:, -3:, -1]

							# forward with prompt embeds
							UpperCAmelCase		:							Optional[int]        =       self.get_dummy_inputs(snake_case      )
							UpperCAmelCase		:							Optional[int]        =       3 * ["this is a negative prompt"]
							UpperCAmelCase		:							str        =       3 * [inputs.pop("prompt"      )]

							(
							    UpperCAmelCase  
							)		:							Union[str, Any]        =       sd_pipe.encode_prompt(snake_case   ,      negative_prompt=snake_case      )

							UpperCAmelCase		:							Union[str, Any]        =       sd_pipe(
							    **snake_case   ,      prompt_embeds=snake_case   ,      negative_prompt_embeds=snake_case   ,      pooled_prompt_embeds=snake_case   ,      negative_pooled_prompt_embeds=snake_case   ,      )
							UpperCAmelCase		:							Any        =       output.images[0, -3:, -3:, -1]

							# make sure that it's equal
							assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()      ).max() < 1e-4







		def 				A_	(			self      ):


							'''simple docstring'''

							super().test_attention_slicing_forward_pass(expected_max_diff=3e-3      )







		def 				A_	(			self      ):


							'''simple docstring'''

							super().test_inference_batch_single_identical(expected_max_diff=3e-3      )







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


		"""simple docstring"""

		def 				A_	(			self      ):


							'''simple docstring'''

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







		def 				A_	(			self   ,      snake_case   ,      snake_case="cpu"   ,      snake_case=torch.floataa   ,      snake_case=0      ):


							'''simple docstring'''

							UpperCAmelCase		:							List[Any]        =       torch.Generator(device=snake_case      ).manual_seed(snake_case      )
							UpperCAmelCase		:							Optional[int]        =       np.random.RandomState(snake_case      ).standard_normal((1, 4, 6_4, 6_4)      )
							UpperCAmelCase		:							List[Any]        =       torch.from_numpy(snake_case      ).to(device=snake_case   ,      dtype=snake_case      )
							UpperCAmelCase		:							str        =       {
							    "prompt": "a photograph of an astronaut riding a horse",
							    "latents": latents,
							    "generator": generator,
							    "num_inference_steps": 3,
							    "guidance_scale": 7.5,
							    "output_type": "numpy",
							}
							return inputs







		def 				A_	(			self      ):


							'''simple docstring'''

							UpperCAmelCase		:							str        =       DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-base"      )
							pipe.to(snake_case      )
							pipe.set_progress_bar_config(disable=snake_case      )

							UpperCAmelCase		:							Any        =       self.get_inputs(snake_case      )
							UpperCAmelCase		:							Optional[int]        =       pipe(**snake_case      ).images
							UpperCAmelCase		:							Tuple        =       image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 5_1_2, 5_1_2, 3)
							UpperCAmelCase		:							List[str]        =       np.array([0.4_9493, 0.4_7896, 0.4_0798, 0.5_4214, 0.5_3212, 0.4_8202, 0.4_7656, 0.4_6329, 0.4_8506]      )
							assert np.abs(image_slice - expected_slice      ).max() < 7e-3



'''simple docstring'''

from __future__ import annotations







class   UpperCamelCase__   :


		"""simple docstring"""

		def __init__(			self   ,      snake_case      ):


							'''simple docstring'''

							UpperCAmelCase		:							str        =       data
							UpperCAmelCase		:							Dict        =       None







class   UpperCamelCase__   :


		"""simple docstring"""

		def __init__(			self      ):


							'''simple docstring'''

							UpperCAmelCase		:							str        =       None







		def 				A_	(			self   ,      snake_case      ):


							'''simple docstring'''

							UpperCAmelCase		:							int        =       Node(snake_case      )
							UpperCAmelCase		:							Optional[int]        =       self.head
							UpperCAmelCase		:							Union[str, Any]        =       new_node
							return self.head.data







		def 				A_	(			self      ):


							'''simple docstring'''

							UpperCAmelCase		:							Dict        =       self.head
							UpperCAmelCase		:							str        =       self.head
							if self.head:
												while fast_pointer and fast_pointer.next:
																	UpperCAmelCase		:							List[str]        =       fast_pointer.next.next
																	UpperCAmelCase		:							Any        =       slow_pointer.next
												return slow_pointer.data
							else:
												print("No element found."      )
												return None


if __name__ == "__main__":
				a       :      List[str]  	=			LinkedList()
				for _ in range(int(input().strip())):
								a       :      str  	=			int(input().strip())
								link.push(data)
				print(link.middle_element())
