






import gc
import random
import tempfile
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()




class 							__A	(     unittest.TestCase					):





				"""simple docstring"""







				def  __lowercase				(					self       ):




									"""simple docstring"""

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


				@property
				def  __lowercase				(					self       ):




									"""simple docstring"""

									__UpperCamelCase :   Optional[int]									=1
									__UpperCamelCase :   Optional[int]									=3
									__UpperCamelCase :   Dict									=(32, 32)

									__UpperCamelCase :   Optional[Any]									=floats_tensor((batch_size, num_channels) + sizes				,    rng=random.Random(0       )       ).to(lowerCamelCase__       )
									return image


				@property
				def  __lowercase				(					self       ):




									"""simple docstring"""

									torch.manual_seed(0       )
									__UpperCamelCase :   Any									=UNetaDConditionModel(
									    block_out_channels=(32, 64)				,    layers_per_block=2				,    sample_size=32				,    in_channels=4				,    out_channels=4				,    down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')				,    up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')				,    cross_attention_dim=32				,    )
									return model


				@property
				def  __lowercase				(					self       ):




									"""simple docstring"""

									torch.manual_seed(0       )
									__UpperCamelCase :   List[str]									=AutoencoderKL(
									    block_out_channels=[32, 64]				,    in_channels=3				,    out_channels=3				,    down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']				,    up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']				,    latent_channels=4				,    )
									return model


				@property
				def  __lowercase				(					self       ):




									"""simple docstring"""

									torch.manual_seed(0       )
									__UpperCamelCase :   Optional[int]									=CLIPTextConfig(
									    bos_token_id=0				,    eos_token_id=2				,    hidden_size=32				,    intermediate_size=37				,    layer_norm_eps=1E-05				,    num_attention_heads=4				,    num_hidden_layers=5				,    pad_token_id=1				,    vocab_size=1000				,    )
									return CLIPTextModel(lowerCamelCase__       )


				@property
				def  __lowercase				(					self       ):




									"""simple docstring"""

									def extract(*lowerCamelCase__				,    **lowerCamelCase__       ):




														class 							__A	:





																		"""simple docstring"""







																		def __init__(					self       ):




																							"""simple docstring"""

																							__UpperCamelCase :   int									=torch.ones([0]       )







																		def  __lowercase				(					self				,    lowerCamelCase__       ):




																							"""simple docstring"""

																							self.pixel_values.to(lowerCamelCase__       )
																							return self
														return Out()

									return extract


				def  __lowercase				(					self       ):




									"""simple docstring"""

									__UpperCamelCase :   str									='cpu'  # ensure determinism for the device-dependent torch.Generator
									__UpperCamelCase :   List[str]									=self.dummy_cond_unet
									__UpperCamelCase :   List[str]									=DDIMScheduler(
									    beta_start=0.00_085				,    beta_end=0.012				,    beta_schedule='scaled_linear'				,    clip_sample=lowerCamelCase__				,    set_alpha_to_one=lowerCamelCase__				,    )

									__UpperCamelCase :   Dict									=self.dummy_vae
									__UpperCamelCase :   List[str]									=self.dummy_text_encoder
									__UpperCamelCase :   Dict									=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'       )

									# make sure here that pndm scheduler skips prk
									__UpperCamelCase :   Any									=StableDiffusionPipeline(
									    unet=lowerCamelCase__				,    scheduler=lowerCamelCase__				,    vae=lowerCamelCase__				,    text_encoder=lowerCamelCase__				,    tokenizer=lowerCamelCase__				,    safety_checker=lowerCamelCase__				,    feature_extractor=self.dummy_extractor				,    )
									__UpperCamelCase :   List[Any]									=sd_pipe.to(lowerCamelCase__       )
									sd_pipe.set_progress_bar_config(disable=lowerCamelCase__       )

									__UpperCamelCase :   Union[str, Any]									='A painting of a squirrel eating a burger'

									__UpperCamelCase :   Any									=torch.Generator(device=lowerCamelCase__       ).manual_seed(0       )
									__UpperCamelCase :   Any									=sd_pipe([prompt]				,    generator=lowerCamelCase__				,    guidance_scale=6.0				,    num_inference_steps=2				,    output_type='np'       )
									__UpperCamelCase :   Optional[Any]									=output.images

									__UpperCamelCase :   Union[str, Any]									=torch.Generator(device=lowerCamelCase__       ).manual_seed(0       )
									__UpperCamelCase :   int									=sd_pipe(
									    [prompt]				,    generator=lowerCamelCase__				,    guidance_scale=6.0				,    num_inference_steps=2				,    output_type='np'				,    return_dict=lowerCamelCase__				,    )[0]

									__UpperCamelCase :   Optional[int]									=image[0, -3:, -3:, -1]
									__UpperCamelCase :   List[Any]									=image_from_tuple[0, -3:, -3:, -1]

									assert image.shape == (1, 64, 64, 3)
									__UpperCamelCase :   Dict									=np.array([0.5_753, 0.6_114, 0.5_001, 0.5_034, 0.5_470, 0.4_729, 0.4_971, 0.4_867, 0.4_867]       )

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


				def  __lowercase				(					self       ):




									"""simple docstring"""

									__UpperCamelCase :   Optional[int]									='cpu'  # ensure determinism for the device-dependent torch.Generator
									__UpperCamelCase :   Union[str, Any]									=self.dummy_cond_unet
									__UpperCamelCase :   Optional[Any]									=PNDMScheduler(skip_prk_steps=lowerCamelCase__       )
									__UpperCamelCase :   int									=self.dummy_vae
									__UpperCamelCase :   Dict									=self.dummy_text_encoder
									__UpperCamelCase :   Tuple									=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'       )

									# make sure here that pndm scheduler skips prk
									__UpperCamelCase :   Any									=StableDiffusionPipeline(
									    unet=lowerCamelCase__				,    scheduler=lowerCamelCase__				,    vae=lowerCamelCase__				,    text_encoder=lowerCamelCase__				,    tokenizer=lowerCamelCase__				,    safety_checker=lowerCamelCase__				,    feature_extractor=self.dummy_extractor				,    )
									__UpperCamelCase :   Union[str, Any]									=sd_pipe.to(lowerCamelCase__       )
									sd_pipe.set_progress_bar_config(disable=lowerCamelCase__       )

									__UpperCamelCase :   Optional[Any]									='A painting of a squirrel eating a burger'
									__UpperCamelCase :   Tuple									=torch.Generator(device=lowerCamelCase__       ).manual_seed(0       )
									__UpperCamelCase :   List[str]									=sd_pipe([prompt]				,    generator=lowerCamelCase__				,    guidance_scale=6.0				,    num_inference_steps=2				,    output_type='np'       )

									__UpperCamelCase :   str									=output.images

									__UpperCamelCase :   Optional[int]									=torch.Generator(device=lowerCamelCase__       ).manual_seed(0       )
									__UpperCamelCase :   List[Any]									=sd_pipe(
									    [prompt]				,    generator=lowerCamelCase__				,    guidance_scale=6.0				,    num_inference_steps=2				,    output_type='np'				,    return_dict=lowerCamelCase__				,    )[0]

									__UpperCamelCase :   str									=image[0, -3:, -3:, -1]
									__UpperCamelCase :   Optional[int]									=image_from_tuple[0, -3:, -3:, -1]

									assert image.shape == (1, 64, 64, 3)
									__UpperCamelCase :   Union[str, Any]									=np.array([0.5_122, 0.5_712, 0.4_825, 0.5_053, 0.5_646, 0.4_769, 0.5_179, 0.4_894, 0.4_994]       )

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


				def  __lowercase				(					self       ):




									"""simple docstring"""

									__UpperCamelCase :   Optional[int]									=StableDiffusionPipeline.from_pretrained(
									    'hf-internal-testing/tiny-stable-diffusion-lms-pipe'				,    safety_checker=lowerCamelCase__       )
									assert isinstance(lowerCamelCase__				,    lowerCamelCase__       )
									assert isinstance(pipe.scheduler				,    lowerCamelCase__       )
									assert pipe.safety_checker is None

									__UpperCamelCase :   List[Any]									=pipe('example prompt'				,    num_inference_steps=2       ).images[0]
									assert image is not None

									# check that there's no error when saving a pipeline with one of the models being None
									with tempfile.TemporaryDirectory() as tmpdirname:
														pipe.save_pretrained(lowerCamelCase__       )
														__UpperCamelCase :   Union[str, Any]									=StableDiffusionPipeline.from_pretrained(lowerCamelCase__       )

									# sanity check that the pipeline still works
									assert pipe.safety_checker is None
									__UpperCamelCase :   Optional[int]									=pipe('example prompt'				,    num_inference_steps=2       ).images[0]
									assert image is not None







				@unittest.skipIf(torch_device != 'cuda'				,    'This test requires a GPU'       )
				def  __lowercase				(					self       ):




									"""simple docstring"""

									__UpperCamelCase :   str									=self.dummy_cond_unet
									__UpperCamelCase :   Tuple									=PNDMScheduler(skip_prk_steps=lowerCamelCase__       )
									__UpperCamelCase :   int									=self.dummy_vae
									__UpperCamelCase :   List[Any]									=self.dummy_text_encoder
									__UpperCamelCase :   Any									=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'       )

									# put models in fp16
									__UpperCamelCase :   Dict									=unet.half()
									__UpperCamelCase :   Any									=vae.half()
									__UpperCamelCase :   Union[str, Any]									=bert.half()

									# make sure here that pndm scheduler skips prk
									__UpperCamelCase :   int									=StableDiffusionPipeline(
									    unet=lowerCamelCase__				,    scheduler=lowerCamelCase__				,    vae=lowerCamelCase__				,    text_encoder=lowerCamelCase__				,    tokenizer=lowerCamelCase__				,    safety_checker=lowerCamelCase__				,    feature_extractor=self.dummy_extractor				,    )
									__UpperCamelCase :   Tuple									=sd_pipe.to(lowerCamelCase__       )
									sd_pipe.set_progress_bar_config(disable=lowerCamelCase__       )

									__UpperCamelCase :   Union[str, Any]									='A painting of a squirrel eating a burger'
									__UpperCamelCase :   Dict									=sd_pipe([prompt]				,    num_inference_steps=2				,    output_type='np'       ).images

									assert image.shape == (1, 64, 64, 3)




@nightly
@require_torch_gpu
class 							__A	(     unittest.TestCase					):





				"""simple docstring"""







				def  __lowercase				(					self       ):




									"""simple docstring"""

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


				def  __lowercase				(					self       ):




									"""simple docstring"""

									__UpperCamelCase :   Any									='cuda'
									__UpperCamelCase :   int									=StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'       )
									__UpperCamelCase :   Union[str, Any]									=pipe.to(lowerCamelCase__       )
									pipe.set_progress_bar_config(disable=lowerCamelCase__       )

									__UpperCamelCase :   Optional[Any]									='a photo of a cat'
									__UpperCamelCase :   Tuple									={
									    'editing_prompt': ['sunglasses'],
									    'reverse_editing_direction': [False],
									    'edit_warmup_steps': 10,
									    'edit_guidance_scale': 6,
									    'edit_threshold': 0.95,
									    'edit_momentum_scale': 0.5,
									    'edit_mom_beta': 0.6,
									}

									__UpperCamelCase :   Any									=3
									__UpperCamelCase :   Any									=7

									# no sega enabled
									__UpperCamelCase :   Optional[int]									=torch.Generator(lowerCamelCase__       )
									generator.manual_seed(lowerCamelCase__       )
									__UpperCamelCase :   Tuple									=pipe(
									    [prompt]				,    generator=lowerCamelCase__				,    guidance_scale=lowerCamelCase__				,    num_inference_steps=50				,    output_type='np'				,    width=512				,    height=512				,    )

									__UpperCamelCase :   str									=output.images
									__UpperCamelCase :   List[Any]									=image[0, -3:, -3:, -1]
									__UpperCamelCase :   int									=[
									    0.34_673_113,
									    0.38_492_733,
									    0.37_597_352,
									    0.34_086_335,
									    0.35_650_748,
									    0.35_579_205,
									    0.3_384_763,
									    0.34_340_236,
									    0.3_573_271,
									]

									assert image.shape == (1, 512, 512, 3)

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

									# with sega enabled
									# generator = torch.manual_seed(seed)
									generator.manual_seed(lowerCamelCase__       )
									__UpperCamelCase :   List[str]									=pipe(
									    [prompt]				,    generator=lowerCamelCase__				,    guidance_scale=lowerCamelCase__				,    num_inference_steps=50				,    output_type='np'				,    width=512				,    height=512				,    **lowerCamelCase__				,    )

									__UpperCamelCase :   List[Any]									=output.images
									__UpperCamelCase :   List[Any]									=image[0, -3:, -3:, -1]
									__UpperCamelCase :   Optional[Any]									=[
									    0.41_887_826,
									    0.37_728_766,
									    0.30_138_272,
									    0.41_416_335,
									    0.41_664_985,
									    0.36_283_392,
									    0.36_191_246,
									    0.43_364_465,
									    0.43_001_732,
									]

									assert image.shape == (1, 512, 512, 3)

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


				def  __lowercase				(					self       ):




									"""simple docstring"""

									__UpperCamelCase :   Union[str, Any]									='cuda'
									__UpperCamelCase :   int									=StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'       )
									__UpperCamelCase :   Optional[int]									=pipe.to(lowerCamelCase__       )
									pipe.set_progress_bar_config(disable=lowerCamelCase__       )

									__UpperCamelCase :   List[str]									='an image of a crowded boulevard, realistic, 4k'
									__UpperCamelCase :   List[Any]									={
									    'editing_prompt': 'crowd, crowded, people',
									    'reverse_editing_direction': True,
									    'edit_warmup_steps': 10,
									    'edit_guidance_scale': 8.3,
									    'edit_threshold': 0.9,
									    'edit_momentum_scale': 0.5,
									    'edit_mom_beta': 0.6,
									}

									__UpperCamelCase :   Any									=9
									__UpperCamelCase :   Union[str, Any]									=7

									# no sega enabled
									__UpperCamelCase :   Union[str, Any]									=torch.Generator(lowerCamelCase__       )
									generator.manual_seed(lowerCamelCase__       )
									__UpperCamelCase :   List[str]									=pipe(
									    [prompt]				,    generator=lowerCamelCase__				,    guidance_scale=lowerCamelCase__				,    num_inference_steps=50				,    output_type='np'				,    width=512				,    height=512				,    )

									__UpperCamelCase :   Dict									=output.images
									__UpperCamelCase :   List[str]									=image[0, -3:, -3:, -1]
									__UpperCamelCase :   Tuple									=[
									    0.43_497_998,
									    0.91_814_065,
									    0.7_540_739,
									    0.55_580_205,
									    0.8_467_265,
									    0.5_389_691,
									    0.62_574_506,
									    0.58_897_763,
									    0.50_926_757,
									]

									assert image.shape == (1, 512, 512, 3)

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

									# with sega enabled
									# generator = torch.manual_seed(seed)
									generator.manual_seed(lowerCamelCase__       )
									__UpperCamelCase :   Any									=pipe(
									    [prompt]				,    generator=lowerCamelCase__				,    guidance_scale=lowerCamelCase__				,    num_inference_steps=50				,    output_type='np'				,    width=512				,    height=512				,    **lowerCamelCase__				,    )

									__UpperCamelCase :   List[Any]									=output.images
									__UpperCamelCase :   int									=image[0, -3:, -3:, -1]
									__UpperCamelCase :   Optional[int]									=[
									    0.3_089_719,
									    0.30_500_144,
									    0.29_016_042,
									    0.30_630_964,
									    0.325_687,
									    0.29_419_225,
									    0.2_908_091,
									    0.28_723_598,
									    0.27_696_294,
									]

									assert image.shape == (1, 512, 512, 3)

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


				def  __lowercase				(					self       ):




									"""simple docstring"""

									__UpperCamelCase :   Any									='cuda'
									__UpperCamelCase :   List[str]									=StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'       )
									__UpperCamelCase :   List[Any]									=pipe.to(lowerCamelCase__       )
									pipe.set_progress_bar_config(disable=lowerCamelCase__       )

									__UpperCamelCase :   int									='a castle next to a river'
									__UpperCamelCase :   Dict									={
									    'editing_prompt': ['boat on a river, boat', 'monet, impression, sunrise'],
									    'reverse_editing_direction': False,
									    'edit_warmup_steps': [15, 18],
									    'edit_guidance_scale': 6,
									    'edit_threshold': [0.9, 0.8],
									    'edit_momentum_scale': 0.5,
									    'edit_mom_beta': 0.6,
									}

									__UpperCamelCase :   Dict									=48
									__UpperCamelCase :   List[Any]									=7

									# no sega enabled
									__UpperCamelCase :   Optional[int]									=torch.Generator(lowerCamelCase__       )
									generator.manual_seed(lowerCamelCase__       )
									__UpperCamelCase :   List[Any]									=pipe(
									    [prompt]				,    generator=lowerCamelCase__				,    guidance_scale=lowerCamelCase__				,    num_inference_steps=50				,    output_type='np'				,    width=512				,    height=512				,    )

									__UpperCamelCase :   Tuple									=output.images
									__UpperCamelCase :   List[Any]									=image[0, -3:, -3:, -1]
									__UpperCamelCase :   List[str]									=[
									    0.75_163_555,
									    0.76_037_145,
									    0.61_785,
									    0.9_189_673,
									    0.8_627_701,
									    0.85_189_694,
									    0.8_512_813,
									    0.87_012_076,
									    0.8_312_857,
									]

									assert image.shape == (1, 512, 512, 3)

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

									# with sega enabled
									# generator = torch.manual_seed(seed)
									generator.manual_seed(lowerCamelCase__       )
									__UpperCamelCase :   List[str]									=pipe(
									    [prompt]				,    generator=lowerCamelCase__				,    guidance_scale=lowerCamelCase__				,    num_inference_steps=50				,    output_type='np'				,    width=512				,    height=512				,    **lowerCamelCase__				,    )

									__UpperCamelCase :   Tuple									=output.images
									__UpperCamelCase :   List[Any]									=image[0, -3:, -3:, -1]
									__UpperCamelCase :   Tuple									=[
									    0.73_553_365,
									    0.7_537_271,
									    0.74_341_905,
									    0.66_480_356,
									    0.6_472_925,
									    0.63_039_416,
									    0.64_812_905,
									    0.6_749_717,
									    0.6_517_102,
									]

									assert image.shape == (1, 512, 512, 3)

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







				def  __lowercase				(					self       ):




									"""simple docstring"""

									__UpperCamelCase :   List[Any]									='cuda'
									__UpperCamelCase :   Union[str, Any]									=StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'				,    torch_dtype=torch.floataa       )
									__UpperCamelCase :   List[str]									=pipe.to(lowerCamelCase__       )
									pipe.set_progress_bar_config(disable=lowerCamelCase__       )

									__UpperCamelCase :   Optional[Any]									='a photo of a cat'
									__UpperCamelCase :   Optional[int]									={
									    'editing_prompt': ['sunglasses'],
									    'reverse_editing_direction': [False],
									    'edit_warmup_steps': 10,
									    'edit_guidance_scale': 6,
									    'edit_threshold': 0.95,
									    'edit_momentum_scale': 0.5,
									    'edit_mom_beta': 0.6,
									}

									__UpperCamelCase :   Optional[int]									=3
									__UpperCamelCase :   int									=7

									# no sega enabled
									__UpperCamelCase :   List[Any]									=torch.Generator(lowerCamelCase__       )
									generator.manual_seed(lowerCamelCase__       )
									__UpperCamelCase :   Dict									=pipe(
									    [prompt]				,    generator=lowerCamelCase__				,    guidance_scale=lowerCamelCase__				,    num_inference_steps=50				,    output_type='np'				,    width=512				,    height=512				,    )

									__UpperCamelCase :   Optional[Any]									=output.images
									__UpperCamelCase :   int									=image[0, -3:, -3:, -1]
									__UpperCamelCase :   Tuple									=[
									    0.34_887_695,
									    0.3_876_953,
									    0.375,
									    0.34_423_828,
									    0.3_581_543,
									    0.35_717_773,
									    0.3_383_789,
									    0.34_570_312,
									    0.359_375,
									]

									assert image.shape == (1, 512, 512, 3)

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

									# with sega enabled
									# generator = torch.manual_seed(seed)
									generator.manual_seed(lowerCamelCase__       )
									__UpperCamelCase :   Any									=pipe(
									    [prompt]				,    generator=lowerCamelCase__				,    guidance_scale=lowerCamelCase__				,    num_inference_steps=50				,    output_type='np'				,    width=512				,    height=512				,    **lowerCamelCase__				,    )

									__UpperCamelCase :   Optional[int]									=output.images
									__UpperCamelCase :   Tuple									=image[0, -3:, -3:, -1]
									__UpperCamelCase :   str									=[
									    0.42_285_156,
									    0.36_914_062,
									    0.29_077_148,
									    0.42_041_016,
									    0.41_918_945,
									    0.35_498_047,
									    0.3_618_164,
									    0.4_423_828,
									    0.43_115_234,
									]

									assert image.shape == (1, 512, 512, 3)

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









from __future__ import annotations




class 							__A	:





				"""simple docstring"""







				def __init__(					self				,    lowerCamelCase__ = 0       ):




									"""simple docstring"""

									__UpperCamelCase :   str									=value
									__UpperCamelCase :   Node | None									=None
									__UpperCamelCase :   Node | None									=None






def 				A	(			a_				,a_   )	->		Node | None:
					if treea is None:
										return treea
					if treea is None:
										return treea

					__UpperCamelCase :   Dict									=treea.value + treea.value
					__UpperCamelCase :   Any									=merge_two_binary_trees(treea.left				,treea.left   )
					__UpperCamelCase :   Union[str, Any]									=merge_two_binary_trees(treea.right				,treea.right   )
					return treea






def 				A	(			a_   )	->		None:
					if root:
										print(root.value   )
										print_preorder(root.left   )
										print_preorder(root.right   )


if __name__ == "__main__":
							A_			:List[str]	    =		Node(1)
							A_			:Dict	    =		Node(2)
							A_			:str	    =		Node(3)
							A_			:Union[str, Any]	    =		Node(4)

							A_			:Any	    =		Node(2)
							A_			:Tuple	    =		Node(4)
							A_			:Optional[Any]	    =		Node(6)
							A_			:Optional[Any]	    =		Node(9)
							A_			:str	    =		Node(5)

							print('''Tree1 is: ''')
							print_preorder(treea)
							print('''Tree2 is: ''')
							print_preorder(treea)
							A_			:Optional[Any]	    =		merge_two_binary_trees(treea, treea)
							print('''Merged Tree is: ''')
							print_preorder(merged_tree)

