



"""simple docstring"""
from collections import Counter
def        A_  (      _lowercase     ):







						'''simple docstring'''


						return sum(socks_by_color // 2 for socks_by_color in Counter(_lowercase     ).values()     )


if __name__ == "__main__":
						import doctest

						doctest.testmod()

						__a     =    [int(x) for x in input("Enter socks by color :").rstrip().split()]
						print(F"""sock_merchant({colors}) = {sock_merchant(colors)}""")





"""simple docstring"""
import gc
import unittest

import numpy as np
import torch

from diffusers import RePaintPipeline, RePaintScheduler, UNetaDModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_image,
    load_numpy,
    nightly,
    require_torch_gpu,
    skip_mps,
    torch_device,
)

from ..pipeline_params import IMAGE_INPAINTING_BATCH_PARAMS, IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
class     lowerCamelCase  (      _lowerCAmelCase   ,						unittest.TestCase    ):






					'''simple docstring'''





					_A		:      Tuple						=					RePaintPipeline
					_A		:      List[Any]						=					IMAGE_INPAINTING_PARAMS - {"""width""", """height""", """guidance_scale"""}
					_A		:      Union[str, Any]						=					PipelineTesterMixin.required_optional_params - {
					    """latents""",
					    """num_images_per_prompt""",
					    """callback""",
					    """callback_steps""",
					}
					_A		:      Tuple						=					IMAGE_INPAINTING_BATCH_PARAMS
					_A		:      Any						=					False






					def        lowerCAmelCase_    (	self:							Any						)       ->     List[str]:
											torch.manual_seed(0						)
											torch.manual_seed(0						)
											snake_case_			:Union[str, Any]						=      UNetaDModel(
											    block_out_channels=(32, 64)						,					layers_per_block=2						,					sample_size=32						,					in_channels=3						,					out_channels=3						,					down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")						,					up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")						,					)
											snake_case_			:str						=      RePaintScheduler()
											snake_case_			:Any						=      {"""unet""": unet, """scheduler""": scheduler}
											return components






					def        lowerCAmelCase_    (	self:							Dict						,					snake_case:							Dict						,					snake_case:							List[Any]=0						)       ->     Tuple:
											if str(snake_case						).startswith("""mps"""						):
																	snake_case_			:int						=      torch.manual_seed(snake_case						)
											else:
																	snake_case_			:Optional[Any]						=      torch.Generator(device=snake_case						).manual_seed(snake_case						)
											snake_case_			:Dict						=      np.random.RandomState(snake_case						).standard_normal((1, 3, 32, 32)						)
											snake_case_			:int						=      torch.from_numpy(snake_case						).to(device=snake_case						,					dtype=torch.floataa						)
											snake_case_			:Dict						=      (image > 0).to(device=snake_case						,					dtype=torch.floataa						)
											snake_case_			:Union[str, Any]						=      {
											    """image""": image,
											    """mask_image""": mask,
											    """generator""": generator,
											    """num_inference_steps""": 5,
											    """eta""": 0.0,
											    """jump_length""": 2,
											    """jump_n_sample""": 2,
											    """output_type""": """numpy""",
											}
											return inputs






					def        lowerCAmelCase_    (	self:							List[Any]						)       ->     List[Any]:
											snake_case_			:int						=      """cpu"""  # ensure determinism for the device-dependent torch.Generator
											snake_case_			:List[str]						=      self.get_dummy_components()
											snake_case_			:Union[str, Any]						=      RePaintPipeline(**snake_case						)
											snake_case_			:Tuple						=      sd_pipe.to(snake_case						)
											sd_pipe.set_progress_bar_config(disable=snake_case						)

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

											assert image.shape == (1, 32, 32, 3)
											snake_case_			:Optional[int]						=      np.array([1.0_0_0_0, 0.5_4_2_6, 0.5_4_9_7, 0.2_2_0_0, 1.0_0_0_0, 1.0_0_0_0, 0.5_6_2_3, 1.0_0_0_0, 0.6_2_7_4]						)

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






					@skip_mps
					def        lowerCAmelCase_    (	self:							Dict						)       ->     int:
											return super().test_save_load_local()






					@unittest.skip("""non-deterministic pipeline"""						)
					def        lowerCAmelCase_    (	self:							Union[str, Any]						)       ->     List[Any]:
											return super().test_inference_batch_single_identical()






					@skip_mps
					def        lowerCAmelCase_    (	self:							int						)       ->     Optional[Any]:
											return super().test_dict_tuple_outputs_equivalent()






					@skip_mps
					def        lowerCAmelCase_    (	self:							Optional[Any]						)       ->     Optional[Any]:
											return super().test_save_load_optional_components()






					@skip_mps
					def        lowerCAmelCase_    (	self:							str						)       ->     Optional[Any]:
											return super().test_attention_slicing_forward_pass()

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






					'''simple docstring'''





					def        lowerCAmelCase_    (	self:							Optional[int]						)       ->     str:
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()






					def        lowerCAmelCase_    (	self:							List[Any]						)       ->     Tuple:
											snake_case_			:Any						=      load_image(
											    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/"""
											    """repaint/celeba_hq_256.png"""						)
											snake_case_			:Union[str, Any]						=      load_image(
											    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png"""						)
											snake_case_			:str						=      load_numpy(
											    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/"""
											    """repaint/celeba_hq_256_result.npy"""						)

											snake_case_			:List[str]						=      """google/ddpm-ema-celebahq-256"""
											snake_case_			:Optional[int]						=      UNetaDModel.from_pretrained(snake_case						)
											snake_case_			:List[Any]						=      RePaintScheduler.from_pretrained(snake_case						)

											snake_case_			:str						=      RePaintPipeline(unet=snake_case						,					scheduler=snake_case						).to(snake_case						)
											repaint.set_progress_bar_config(disable=snake_case						)
											repaint.enable_attention_slicing()

											snake_case_			:int						=      torch.manual_seed(0						)
											snake_case_			:str						=      repaint(
											    snake_case						,					snake_case						,					num_inference_steps=250						,					eta=0.0						,					jump_length=10						,					jump_n_sample=10						,					generator=snake_case						,					output_type="""np"""						,					)
											snake_case_			:List[str]						=      output.images[0]

											assert image.shape == (256, 256, 3)
											assert np.abs(expected_image - image						).mean() < 1E-2
