'''simple docstring'''







import gc
import unittest

import torch
from parameterized import parameterized

from diffusers import AutoencoderKL
from diffusers.utils import floats_tensor, load_hf_numpy, require_torch_gpu, slow, torch_all_close, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()




class _SCREAMING_SNAKE_CASE(							_SCREAMING_SNAKE_CASE						,						_SCREAMING_SNAKE_CASE						,						unittest.TestCase					):
						A_			:							List[str]     		= AutoencoderKL
						A_			:							Optional[int]     		= 'sample'
						A_			:							str     		= 1e-2




						@property
						def      __lowerCamelCase       (    self :       Tuple      )     ->				List[str]:
													SCREAMING_SNAKE_CASE__     :Dict						    = 4
													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = 3
													SCREAMING_SNAKE_CASE__     :str						    = (32, 32)

													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = floats_tensor((batch_size, num_channels) + sizes      ).to(UpperCamelCase_      )

													return {"sample": image}




						@property
						def      __lowerCamelCase       (    self :       Tuple      )     ->				Tuple:
													return (3, 32, 32)




						@property
						def      __lowerCamelCase       (    self :       Optional[Any]      )     ->				Tuple:
													return (3, 32, 32)




						def      __lowerCamelCase       (    self :       List[Any]      )     ->				int:
													SCREAMING_SNAKE_CASE__     :Optional[int]						    = {
													    'block_out_channels': [32, 64],
													    'in_channels': 3,
													    'out_channels': 3,
													    'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
													    'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'],
													    'latent_channels': 4,
													}
													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = self.dummy_input
													return init_dict, inputs_dict




						def      __lowerCamelCase       (    self :       List[Any]      )     ->				Optional[int]:
													pass




						def      __lowerCamelCase       (    self :       Tuple      )     ->				List[Any]:
													pass




						@unittest.skipIf(torch_device == 'mps'							,							'Gradient checkpointing skipped on MPS'      )
						def      __lowerCamelCase       (    self :       Any      )     ->				Optional[int]:
													# enable deterministic behavior for gradient checkpointing
													SCREAMING_SNAKE_CASE__    ,      SCREAMING_SNAKE_CASE__     :str						    = self.prepare_init_args_and_inputs_for_common()
													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = self.model_class(**UpperCamelCase_      )
													model.to(UpperCamelCase_      )

													assert not model.is_gradient_checkpointing and model.training

													SCREAMING_SNAKE_CASE__     :Tuple						    = model(**UpperCamelCase_      ).sample
													# run the backwards pass on the model. For backwards pass, for simplicity purpose,
													# we won't calculate the loss and rather backprop on out.sum()
													model.zero_grad()

													SCREAMING_SNAKE_CASE__     :Dict						    = torch.randn_like(UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :List[Any]						    = (out - labels).mean()
													loss.backward()

													# re-instantiate the model now enabling gradient checkpointing
													SCREAMING_SNAKE_CASE__     :Any						    = self.model_class(**UpperCamelCase_      )
													# clone model
													model_a.load_state_dict(model.state_dict()      )
													model_a.to(UpperCamelCase_      )
													model_a.enable_gradient_checkpointing()

													assert model_a.is_gradient_checkpointing and model_a.training

													SCREAMING_SNAKE_CASE__     :List[str]						    = model_a(**UpperCamelCase_      ).sample
													# run the backwards pass on the model. For backwards pass, for simplicity purpose,
													# we won't calculate the loss and rather backprop on out.sum()
													model_a.zero_grad()
													SCREAMING_SNAKE_CASE__     :Any						    = (out_a - labels).mean()
													loss_a.backward()

													# compare the output and parameters gradients
													self.assertTrue((loss - loss_a).abs() < 1e-5      )
													SCREAMING_SNAKE_CASE__     :Any						    = dict(model.named_parameters()      )
													SCREAMING_SNAKE_CASE__     :List[str]						    = dict(model_a.named_parameters()      )
													for name, param in named_params.items():
																				self.assertTrue(torch_all_close(param.grad.data							,							named_params_a[name].grad.data							,							atol=5e-5      )      )




						def      __lowerCamelCase       (    self :       Tuple      )     ->				Optional[Any]:
													SCREAMING_SNAKE_CASE__    ,      SCREAMING_SNAKE_CASE__     :List[Any]						    = AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'							,							output_loading_info=UpperCamelCase_      )
													self.assertIsNotNone(UpperCamelCase_      )
													self.assertEqual(len(loading_info['missing_keys']      )							,							0      )

													model.to(UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :Dict						    = model(**self.dummy_input      )

													assert image is not None, "Make sure output is not None"




						def      __lowerCamelCase       (    self :       Dict      )     ->				Dict:
													SCREAMING_SNAKE_CASE__     :str						    = AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'      )
													SCREAMING_SNAKE_CASE__     :List[str]						    = model.to(UpperCamelCase_      )
													model.eval()

													if torch_device == "mps":
																				SCREAMING_SNAKE_CASE__     :List[Any]						    = torch.manual_seed(0      )
													else:
																				SCREAMING_SNAKE_CASE__     :Optional[Any]						    = torch.Generator(device=UpperCamelCase_      ).manual_seed(0      )

													SCREAMING_SNAKE_CASE__     :Dict						    = torch.randn(
													    1							,							model.config.in_channels							,							model.config.sample_size							,							model.config.sample_size							,							generator=torch.manual_seed(0      )							,							)
													SCREAMING_SNAKE_CASE__     :List[str]						    = image.to(UpperCamelCase_      )
													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :Any						    = model(UpperCamelCase_							,							sample_posterior=UpperCamelCase_							,							generator=UpperCamelCase_      ).sample

													SCREAMING_SNAKE_CASE__     :int						    = output[0, -1, -3:, -3:].flatten().cpu()

													# Since the VAE Gaussian prior's generator is seeded on the appropriate device,
													# the expected output slices are not the same for CPU and GPU.
													if torch_device == "mps":
																				SCREAMING_SNAKE_CASE__     :int						    = torch.tensor(
																				    [
																				        -4.0_078e-01,
																				        -3.8_323e-04,
																				        -1.2_681e-01,
																				        -1.1_462e-01,
																				        2.0_095e-01,
																				        1.0_893e-01,
																				        -8.8_247e-02,
																				        -3.0_361e-01,
																				        -9.8_644e-03,
																				    ]      )
													elif torch_device == "cpu":
																				SCREAMING_SNAKE_CASE__     :Optional[int]						    = torch.tensor(
																				    [-0.1352, 0.0878, 0.0419, -0.0818, -0.1069, 0.0688, -0.1458, -0.4446, -0.0026]      )
													else:
																				SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = torch.tensor(
																				    [-0.2421, 0.4642, 0.2507, -0.0438, 0.0682, 0.3160, -0.2018, -0.0727, 0.2485]      )

													self.assertTrue(torch_all_close(UpperCamelCase_							,							UpperCamelCase_							,							rtol=1e-2      )      )




@slow
class _SCREAMING_SNAKE_CASE(							unittest.TestCase					):




						def      __lowerCamelCase       (    self :       List[str]							,							UpperCamelCase_ :       List[Any]							,							UpperCamelCase_ :       Tuple      )     ->				str:
													return f'''gaussian_noise_s={seed}_shape={"_".join([str(UpperCamelCase_      ) for s in shape]      )}.npy'''




						def      __lowerCamelCase       (    self :       Optional[Any]      )     ->				str:
													# clean up the VRAM after each test
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()




						def      __lowerCamelCase       (    self :       List[Any]							,							UpperCamelCase_ :       Optional[Any]=0							,							UpperCamelCase_ :       Union[str, Any]=(4, 3, 5_12, 5_12)							,							UpperCamelCase_ :       int=False      )     ->				List[str]:
													SCREAMING_SNAKE_CASE__     :List[str]						    = torch.floataa if fpaa else torch.floataa
													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = torch.from_numpy(load_hf_numpy(self.get_file_format(UpperCamelCase_							,							UpperCamelCase_      )      )      ).to(UpperCamelCase_      ).to(UpperCamelCase_      )
													return image




						def      __lowerCamelCase       (    self :       Tuple							,							UpperCamelCase_ :       Union[str, Any]="CompVis/stable-diffusion-v1-4"							,							UpperCamelCase_ :       Union[str, Any]=False      )     ->				List[str]:
													SCREAMING_SNAKE_CASE__     :List[str]						    = 'fp16' if fpaa else None
													SCREAMING_SNAKE_CASE__     :List[str]						    = torch.floataa if fpaa else torch.floataa

													SCREAMING_SNAKE_CASE__     :List[Any]						    = AutoencoderKL.from_pretrained(
													    UpperCamelCase_							,							subfolder='vae'							,							torch_dtype=UpperCamelCase_							,							revision=UpperCamelCase_							,							)
													model.to(UpperCamelCase_      ).eval()

													return model




						def      __lowerCamelCase       (    self :       Tuple							,							UpperCamelCase_ :       List[Any]=0      )     ->				Optional[int]:
													if torch_device == "mps":
																				return torch.manual_seed(UpperCamelCase_      )
													return torch.Generator(device=UpperCamelCase_      ).manual_seed(UpperCamelCase_      )




						@parameterized.expand(
						    [
						        # fmt: off
						        [33, [-0.1603, 0.9878, -0.0495, -0.0790, -0.2709, 0.8375, -0.2060, -0.0824], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
						        [47, [-0.2376, 0.1168, 0.1332, -0.4840, -0.2508, -0.0791, -0.0493, -0.4089], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
						        # fmt: on
						    ]      )
						def      __lowerCamelCase       (    self :       str							,							UpperCamelCase_ :       Optional[int]							,							UpperCamelCase_ :       List[str]							,							UpperCamelCase_ :       Union[str, Any]      )     ->				Dict:
													SCREAMING_SNAKE_CASE__     :Dict						    = self.get_sd_vae_model()
													SCREAMING_SNAKE_CASE__     :List[Any]						    = self.get_sd_image(UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :List[str]						    = self.get_generator(UpperCamelCase_      )

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :Optional[int]						    = model(UpperCamelCase_							,							generator=UpperCamelCase_							,							sample_posterior=UpperCamelCase_      ).sample

													assert sample.shape == image.shape

													SCREAMING_SNAKE_CASE__     :List[Any]						    = sample[-1, -2:, -2:, :2].flatten().float().cpu()
													SCREAMING_SNAKE_CASE__     :Dict						    = torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice      )

													assert torch_all_close(UpperCamelCase_							,							UpperCamelCase_							,							atol=3e-3      )




						@parameterized.expand(
						    [
						        # fmt: off
						        [33, [-0.0513, 0.0289, 1.3799, 0.2166, -0.2573, -0.0871, 0.5103, -0.0999]],
						        [47, [-0.4128, -0.1320, -0.3704, 0.1965, -0.4116, -0.2332, -0.3340, 0.2247]],
						        # fmt: on
						    ]      )
						@require_torch_gpu
						def      __lowerCamelCase       (    self :       List[Any]							,							UpperCamelCase_ :       Any							,							UpperCamelCase_ :       Tuple      )     ->				List[Any]:
													SCREAMING_SNAKE_CASE__     :Dict						    = self.get_sd_vae_model(fpaa=UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :Optional[int]						    = self.get_sd_image(UpperCamelCase_							,							fpaa=UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :str						    = self.get_generator(UpperCamelCase_      )

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :Tuple						    = model(UpperCamelCase_							,							generator=UpperCamelCase_							,							sample_posterior=UpperCamelCase_      ).sample

													assert sample.shape == image.shape

													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = sample[-1, -2:, :2, -2:].flatten().float().cpu()
													SCREAMING_SNAKE_CASE__     :Tuple						    = torch.tensor(UpperCamelCase_      )

													assert torch_all_close(UpperCamelCase_							,							UpperCamelCase_							,							atol=1e-2      )




						@parameterized.expand(
						    [
						        # fmt: off
						        [33, [-0.1609, 0.9866, -0.0487, -0.0777, -0.2716, 0.8368, -0.2055, -0.0814], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
						        [47, [-0.2377, 0.1147, 0.1333, -0.4841, -0.2506, -0.0805, -0.0491, -0.4085], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
						        # fmt: on
						    ]      )
						def      __lowerCamelCase       (    self :       Tuple							,							UpperCamelCase_ :       Tuple							,							UpperCamelCase_ :       Dict							,							UpperCamelCase_ :       Optional[int]      )     ->				Optional[Any]:
													SCREAMING_SNAKE_CASE__     :Any						    = self.get_sd_vae_model()
													SCREAMING_SNAKE_CASE__     :Dict						    = self.get_sd_image(UpperCamelCase_      )

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :Optional[int]						    = model(UpperCamelCase_      ).sample

													assert sample.shape == image.shape

													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = sample[-1, -2:, -2:, :2].flatten().float().cpu()
													SCREAMING_SNAKE_CASE__     :Dict						    = torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice      )

													assert torch_all_close(UpperCamelCase_							,							UpperCamelCase_							,							atol=3e-3      )




						@parameterized.expand(
						    [
						        # fmt: off
						        [13, [-0.2051, -0.1803, -0.2311, -0.2114, -0.3292, -0.3574, -0.2953, -0.3323]],
						        [37, [-0.2632, -0.2625, -0.2199, -0.2741, -0.4539, -0.4990, -0.3720, -0.4925]],
						        # fmt: on
						    ]      )
						@require_torch_gpu
						def      __lowerCamelCase       (    self :       Tuple							,							UpperCamelCase_ :       Any							,							UpperCamelCase_ :       int      )     ->				Optional[int]:
													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = self.get_sd_vae_model()
													SCREAMING_SNAKE_CASE__     :Tuple						    = self.get_sd_image(UpperCamelCase_							,							shape=(3, 4, 64, 64)      )

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :Tuple						    = model.decode(UpperCamelCase_      ).sample

													assert list(sample.shape      ) == [3, 3, 5_12, 5_12]

													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = sample[-1, -2:, :2, -2:].flatten().cpu()
													SCREAMING_SNAKE_CASE__     :Dict						    = torch.tensor(UpperCamelCase_      )

													assert torch_all_close(UpperCamelCase_							,							UpperCamelCase_							,							atol=1e-3      )




						@parameterized.expand(
						    [
						        # fmt: off
						        [27, [-0.0369, 0.0207, -0.0776, -0.0682, -0.1747, -0.1930, -0.1465, -0.2039]],
						        [16, [-0.1628, -0.2134, -0.2747, -0.2642, -0.3774, -0.4404, -0.3687, -0.4277]],
						        # fmt: on
						    ]      )
						@require_torch_gpu
						def      __lowerCamelCase       (    self :       int							,							UpperCamelCase_ :       Dict							,							UpperCamelCase_ :       Any      )     ->				str:
													SCREAMING_SNAKE_CASE__     :Any						    = self.get_sd_vae_model(fpaa=UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :int						    = self.get_sd_image(UpperCamelCase_							,							shape=(3, 4, 64, 64)							,							fpaa=UpperCamelCase_      )

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :List[Any]						    = model.decode(UpperCamelCase_      ).sample

													assert list(sample.shape      ) == [3, 3, 5_12, 5_12]

													SCREAMING_SNAKE_CASE__     :Any						    = sample[-1, -2:, :2, -2:].flatten().float().cpu()
													SCREAMING_SNAKE_CASE__     :List[str]						    = torch.tensor(UpperCamelCase_      )

													assert torch_all_close(UpperCamelCase_							,							UpperCamelCase_							,							atol=5e-3      )




						@parameterized.expand([(13,), (16,), (27,)]      )
						@require_torch_gpu
						@unittest.skipIf(not is_xformers_available()							,							reason='xformers is not required when using PyTorch 2.0.'      )
						def      __lowerCamelCase       (    self :       Any							,							UpperCamelCase_ :       Any      )     ->				Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :Any						    = self.get_sd_vae_model(fpaa=UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = self.get_sd_image(UpperCamelCase_							,							shape=(3, 4, 64, 64)							,							fpaa=UpperCamelCase_      )

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :Dict						    = model.decode(UpperCamelCase_      ).sample

													model.enable_xformers_memory_efficient_attention()
													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :str						    = model.decode(UpperCamelCase_      ).sample

													assert list(sample.shape      ) == [3, 3, 5_12, 5_12]

													assert torch_all_close(UpperCamelCase_							,							UpperCamelCase_							,							atol=1e-1      )




						@parameterized.expand([(13,), (16,), (37,)]      )
						@require_torch_gpu
						@unittest.skipIf(not is_xformers_available()							,							reason='xformers is not required when using PyTorch 2.0.'      )
						def      __lowerCamelCase       (    self :       List[Any]							,							UpperCamelCase_ :       Tuple      )     ->				Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :str						    = self.get_sd_vae_model()
													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = self.get_sd_image(UpperCamelCase_							,							shape=(3, 4, 64, 64)      )

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = model.decode(UpperCamelCase_      ).sample

													model.enable_xformers_memory_efficient_attention()
													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = model.decode(UpperCamelCase_      ).sample

													assert list(sample.shape      ) == [3, 3, 5_12, 5_12]

													assert torch_all_close(UpperCamelCase_							,							UpperCamelCase_							,							atol=1e-2      )




						@parameterized.expand(
						    [
						        # fmt: off
						        [33, [-0.3001, 0.0918, -2.6984, -3.9720, -3.2099, -5.0353, 1.7338, -0.2065, 3.4267]],
						        [47, [-1.5030, -4.3871, -6.0355, -9.1157, -1.6661, -2.7853, 2.1607, -5.0823, 2.5633]],
						        # fmt: on
						    ]      )
						def      __lowerCamelCase       (    self :       str							,							UpperCamelCase_ :       Union[str, Any]							,							UpperCamelCase_ :       List[str]      )     ->				Optional[Any]:
													SCREAMING_SNAKE_CASE__     :Any						    = self.get_sd_vae_model()
													SCREAMING_SNAKE_CASE__     :Tuple						    = self.get_sd_image(UpperCamelCase_      )
													SCREAMING_SNAKE_CASE__     :List[Any]						    = self.get_generator(UpperCamelCase_      )

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE__     :List[str]						    = model.encode(UpperCamelCase_      ).latent_dist
																				SCREAMING_SNAKE_CASE__     :str						    = dist.sample(generator=UpperCamelCase_      )

													assert list(sample.shape      ) == [image.shape[0], 4] + [i // 8 for i in image.shape[2:]]

													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = sample[0, -1, -3:, -3:].flatten().cpu()
													SCREAMING_SNAKE_CASE__     :Dict						    = torch.tensor(UpperCamelCase_      )

													SCREAMING_SNAKE_CASE__     :Any						    = 3e-3 if torch_device != 'mps' else 1e-2
													assert torch_all_close(UpperCamelCase_							,							UpperCamelCase_							,							atol=UpperCamelCase_      )







'''simple docstring'''







import numpy as np
import qiskit


def    lowerCamelCase       (			UpperCAmelCase__				:  int = 8				,						UpperCAmelCase__				:  int | None = None		)			->	str:


							'''simple docstring'''






							SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = np.random.default_rng(seed=UpperCAmelCase__		)

							# Roughly 25% of the qubits will contribute to the key.
							# So we take more than we need.
							SCREAMING_SNAKE_CASE__     :Optional[int]						    = 6 * key_len
							# Measurement basis for Alice's qubits.
							SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = rng.integers(2				,						size=UpperCAmelCase__		)
							# The set of states Alice will prepare.
							SCREAMING_SNAKE_CASE__     :List[Any]						    = rng.integers(2				,						size=UpperCAmelCase__		)
							# Measurement basis for Bob's qubits.
							SCREAMING_SNAKE_CASE__     :str						    = rng.integers(2				,						size=UpperCAmelCase__		)

							# Quantum Circuit to simulate BB84
							SCREAMING_SNAKE_CASE__     :int						    = qiskit.QuantumCircuit(UpperCAmelCase__				,						name='BB84'		)

							# Alice prepares her qubits according to rules above.
							for index, _ in enumerate(UpperCAmelCase__		):
														if alice_state[index] == 1:
																					bbaa_circ.x(UpperCAmelCase__		)
														if alice_basis[index] == 1:
																					bbaa_circ.h(UpperCAmelCase__		)
							bbaa_circ.barrier()

							# Bob measures the received qubits according to rules above.
							for index, _ in enumerate(UpperCAmelCase__		):
														if bob_basis[index] == 1:
																					bbaa_circ.h(UpperCAmelCase__		)

							bbaa_circ.barrier()
							bbaa_circ.measure_all()

							# Simulate the quantum circuit.
							SCREAMING_SNAKE_CASE__     :str						    = qiskit.Aer.get_backend('aer_simulator'		)
							# We only need to run one shot because the key is unique.
							# Multiple shots will produce the same key.
							SCREAMING_SNAKE_CASE__     :int						    = qiskit.execute(UpperCAmelCase__				,						UpperCAmelCase__				,						shots=1				,						seed_simulator=UpperCAmelCase__		)
							# Returns the result of measurement.
							SCREAMING_SNAKE_CASE__     :List[Any]						    = job.result().get_counts(UpperCAmelCase__		).most_frequent()

							# Extracting the generated key from the simulation results.
							# Only keep measurement results where Alice and Bob chose the same basis.
							SCREAMING_SNAKE_CASE__     :Any						    = ''.join(
							    [
							        result_bit
							        for alice_basis_bit, bob_basis_bit, result_bit in zip(
							            UpperCAmelCase__				,						UpperCAmelCase__				,						UpperCAmelCase__		)
							        if alice_basis_bit == bob_basis_bit
							    ]		)

							# Get final key. Pad with 0 if too short, otherwise truncate.
							SCREAMING_SNAKE_CASE__     :Optional[Any]						    = gen_key[:key_len] if len(UpperCAmelCase__		) >= key_len else gen_key.ljust(UpperCAmelCase__				,						'0'		)
							return key


if __name__ == "__main__":
		print(f"The generated key is : {bbaa(8, seed=0)}")
		from doctest import testmod

		testmod()






