


import argparse
import os
import re


UpperCAmelCase   :    List[Any]     =		"src/diffusers"

# Pattern that looks at the indentation in a line.
UpperCAmelCase   :    List[Any]     =		re.compile(r"^(\s*)\S")
# Pattern that matches `"key":" and puts `key` in group 0.
UpperCAmelCase   :    Any     =		re.compile(r"^\s*\"([^\"]+)\":")
# Pattern that matches `_import_structure["key"]` and puts `key` in group 0.
UpperCAmelCase   :    Tuple     =		re.compile(r"^\s*_import_structure\[\"([^\"]+)\"\]")
# Pattern that matches `"key",` and puts `key` in group 0.
UpperCAmelCase   :    Optional[int]     =		re.compile(r"^\s*\"([^\"]+)\",\s*$")
# Pattern that matches any `[stuff]` and puts `stuff` in group 0.
UpperCAmelCase   :    Optional[Any]     =		re.compile(r"\[([^\]]+)\]")






def 	__lowerCamelCase						(							lowerCamelCase__		:						Optional[Any]      ):





			'''simple docstring'''




			lowerCamelCase    		=  _re_indent.search(lowerCamelCase__      )
			return "" if search is None else search.groups()[0]






def 	__lowerCamelCase						(							lowerCamelCase__		:						List[str]  ,							lowerCamelCase__		:						Dict=""  ,							lowerCamelCase__		:						Optional[int]=None  ,							lowerCamelCase__		:						List[Any]=None      ):





			'''simple docstring'''




			lowerCamelCase    		=  0
			lowerCamelCase    		=  code.split("""\n"""      )
			if start_prompt is not None:
						while not lines[index].startswith(lowerCamelCase__      ):
									index += 1
						lowerCamelCase    		=  ["""\n""".join(lines[:index]      )]
			else:
						lowerCamelCase    		=  []

			# We split into blocks until we get to the `end_prompt` (or the end of the block).
			lowerCamelCase    		=  [lines[index]]
			index += 1
			while index < len(lowerCamelCase__      ) and (end_prompt is None or not lines[index].startswith(lowerCamelCase__      )):
						if len(lines[index]      ) > 0 and get_indent(lines[index]      ) == indent_level:
									if len(lowerCamelCase__      ) > 0 and get_indent(current_block[-1]      ).startswith(indent_level + """ """      ):
												current_block.append(lines[index]      )
												blocks.append("""\n""".join(lowerCamelCase__      )      )
												if index < len(lowerCamelCase__      ) - 1:
															lowerCamelCase    		=  [lines[index + 1]]
															index += 1
												else:
															lowerCamelCase    		=  []
									else:
												blocks.append("""\n""".join(lowerCamelCase__      )      )
												lowerCamelCase    		=  [lines[index]]
						else:
									current_block.append(lines[index]      )
						index += 1

			# Adds current block if it's nonempty.
			if len(lowerCamelCase__      ) > 0:
						blocks.append("""\n""".join(lowerCamelCase__      )      )

			# Add final block after end_prompt if provided.
			if end_prompt is not None and index < len(lowerCamelCase__      ):
						blocks.append("""\n""".join(lines[index:]      )      )

			return blocks






def 	__lowerCamelCase						(							lowerCamelCase__		:						str      ):





			'''simple docstring'''




			def _inner(lowerCamelCase__		:						List[str]      ):
						return key(lowerCamelCase__      ).lower().replace("""_"""  ,							""""""      )

			return _inner






def 	__lowerCamelCase						(							lowerCamelCase__		:						int  ,							lowerCamelCase__		:						Union[str, Any]=None      ):





			'''simple docstring'''




			def noop(lowerCamelCase__		:						Dict      ):
						return x

			if key is None:
						lowerCamelCase    		=  noop
			# Constants are all uppercase, they go first.
			lowerCamelCase    		=  [obj for obj in objects if key(lowerCamelCase__      ).isupper()]
			# Classes are not all uppercase but start with a capital, they go second.
			lowerCamelCase    		=  [obj for obj in objects if key(lowerCamelCase__      )[0].isupper() and not key(lowerCamelCase__      ).isupper()]
			# Functions begin with a lowercase, they go last.
			lowerCamelCase    		=  [obj for obj in objects if not key(lowerCamelCase__      )[0].isupper()]

			lowerCamelCase    		=  ignore_underscore(lowerCamelCase__      )
			return sorted(lowerCamelCase__  ,							key=lowerCamelCase__      ) + sorted(lowerCamelCase__  ,							key=lowerCamelCase__      ) + sorted(lowerCamelCase__  ,							key=lowerCamelCase__      )






def 	__lowerCamelCase						(							lowerCamelCase__		:						List[Any]      ):





			'''simple docstring'''




			def _replace(lowerCamelCase__		:						Optional[Any]      ):
						lowerCamelCase    		=  match.groups()[0]
						if "," not in imports:
									return f'[{imports}]'
						lowerCamelCase    		=  [part.strip().replace("""\""""  ,							""""""      ) for part in imports.split(""","""      )]
						# We will have a final empty element if the line finished with a comma.
						if len(keys[-1]      ) == 0:
									lowerCamelCase    		=  keys[:-1]
						return "[" + ", ".join([f'"{k}"' for k in sort_objects(lowerCamelCase__      )]      ) + "]"

			lowerCamelCase    		=  import_statement.split("""\n"""      )
			if len(lowerCamelCase__      ) > 3:
						# Here we have to sort internal imports that are on several lines (one per name):
						# key: [
						#     "object1",
						#     "object2",
						#     ...
						# ]

						# We may have to ignore one or two lines on each side.
						lowerCamelCase    		=  2 if lines[1].strip() == """[""" else 1
						lowerCamelCase    		=  [(i, _re_strip_line.search(lowerCamelCase__      ).groups()[0]) for i, line in enumerate(lines[idx:-idx]      )]
						lowerCamelCase    		=  sort_objects(lowerCamelCase__  ,							key=lambda lowerCamelCase__      : x[1]      )
						lowerCamelCase    		=  [lines[x[0] + idx] for x in sorted_indices]
						return "\n".join(lines[:idx] + sorted_lines + lines[-idx:]      )
			elif len(lowerCamelCase__      ) == 3:
						# Here we have to sort internal imports that are on one separate line:
						# key: [
						#     "object1", "object2", ...
						# ]
						if _re_bracket_content.search(lines[1]      ) is not None:
									lowerCamelCase    		=  _re_bracket_content.sub(_replace  ,							lines[1]      )
						else:
									lowerCamelCase    		=  [part.strip().replace("""\""""  ,							""""""      ) for part in lines[1].split(""","""      )]
									# We will have a final empty element if the line finished with a comma.
									if len(keys[-1]      ) == 0:
												lowerCamelCase    		=  keys[:-1]
									lowerCamelCase    		=  get_indent(lines[1]      ) + """, """.join([f'"{k}"' for k in sort_objects(lowerCamelCase__      )]      )
						return "\n".join(lowerCamelCase__      )
			else:
						# Finally we have to deal with imports fitting on one line
						lowerCamelCase    		=  _re_bracket_content.sub(_replace  ,							lowerCamelCase__      )
						return import_statement






def 	__lowerCamelCase						(							lowerCamelCase__		:						List[str]  ,							lowerCamelCase__		:						Dict=True      ):





			'''simple docstring'''




			with open(lowerCamelCase__  ,							"""r"""      ) as f:
						lowerCamelCase    		=  f.read()

			if "_import_structure" not in code:
						return

			# Blocks of indent level 0
			lowerCamelCase    		=  split_code_in_indented_blocks(
			    lowerCamelCase__  ,							start_prompt="""_import_structure = {"""  ,							end_prompt="""if TYPE_CHECKING:"""      )

			# We ignore block 0 (everything until start_prompt) and the last block (everything after end_prompt).
			for block_idx in range(1  ,							len(lowerCamelCase__      ) - 1      ):
						# Check if the block contains some `_import_structure`s thingy to sort.
						lowerCamelCase    		=  main_blocks[block_idx]
						lowerCamelCase    		=  block.split("""\n"""      )

						# Get to the start of the imports.
						lowerCamelCase    		=  0
						while line_idx < len(lowerCamelCase__      ) and "_import_structure" not in block_lines[line_idx]:
									# Skip dummy import blocks
									if "import dummy" in block_lines[line_idx]:
												lowerCamelCase    		=  len(lowerCamelCase__      )
									else:
												line_idx += 1
						if line_idx >= len(lowerCamelCase__      ):
									continue

						# Ignore beginning and last line: they don't contain anything.
						lowerCamelCase    		=  """\n""".join(block_lines[line_idx:-1]      )
						lowerCamelCase    		=  get_indent(block_lines[1]      )
						# Slit the internal block into blocks of indent level 1.
						lowerCamelCase    		=  split_code_in_indented_blocks(lowerCamelCase__  ,							indent_level=lowerCamelCase__      )
						# We have two categories of import key: list or _import_structure[key].append/extend
						lowerCamelCase    		=  _re_direct_key if """_import_structure""" in block_lines[0] else _re_indirect_key
						# Grab the keys, but there is a trap: some lines are empty or just comments.
						lowerCamelCase    		=  [(pattern.search(lowerCamelCase__      ).groups()[0] if pattern.search(lowerCamelCase__      ) is not None else None) for b in internal_blocks]
						# We only sort the lines with a key.
						lowerCamelCase    		=  [(i, key) for i, key in enumerate(lowerCamelCase__      ) if key is not None]
						lowerCamelCase    		=  [x[0] for x in sorted(lowerCamelCase__  ,							key=lambda lowerCamelCase__      : x[1]      )]

						# We reorder the blocks by leaving empty lines/comments as they were and reorder the rest.
						lowerCamelCase    		=  0
						lowerCamelCase    		=  []
						for i in range(len(lowerCamelCase__      )      ):
									if keys[i] is None:
												reordered_blocks.append(internal_blocks[i]      )
									else:
												lowerCamelCase    		=  sort_objects_in_import(internal_blocks[sorted_indices[count]]      )
												reordered_blocks.append(lowerCamelCase__      )
												count += 1

        # And we put our main block back together with its first and last line.
						lowerCamelCase    		=  """\n""".join(block_lines[:line_idx] + reordered_blocks + [block_lines[-1]]      )

			if code != "\n".join(lowerCamelCase__      ):
						if check_only:
									return True
						else:
									print(f'Overwriting {file}.'      )
									with open(lowerCamelCase__  ,							"""w"""      ) as f:
												f.write("""\n""".join(lowerCamelCase__      )      )






def 	__lowerCamelCase						(							lowerCamelCase__		:						Tuple=True      ):





			'''simple docstring'''




			lowerCamelCase    		=  []
			for root, _, files in os.walk(lowerCamelCase__      ):
						if "__init__.py" in files:
									lowerCamelCase    		=  sort_imports(os.path.join(lowerCamelCase__  ,							"""__init__.py"""      )  ,							check_only=lowerCamelCase__      )
									if result:
												lowerCamelCase    		=  [os.path.join(lowerCamelCase__  ,							"""__init__.py"""      )]
			if len(lowerCamelCase__      ) > 0:
						raise ValueError(f'Would overwrite {len(lowerCamelCase__      )} files, run `make style`.'      )


if __name__ == "__main__":
		UpperCAmelCase   :    Tuple     =		argparse.ArgumentParser()
		parser.add_argument("--check_only", action="store_true", help="Whether to only check or fix style.")
		UpperCAmelCase   :    List[Any]     =		parser.parse_args()

		sort_imports_in_all_inits(check_only=args.check_only)





import gc
import unittest

import numpy as np
import torch
from torch.backends.cuda import sdp_kernel

from diffusers import (
    CMStochasticIterativeScheduler,
    ConsistencyModelPipeline,
    UNetaDModel,
)
from diffusers.utils import randn_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu

from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()







class        __lowercase       (							a_			,							unittest.TestCase  ):



		"""simple docstring"""

		UpperCamelCase     :					List[str]			       =		ConsistencyModelPipeline
		UpperCamelCase     :					int			       =		UNCONDITIONAL_IMAGE_GENERATION_PARAMS
		UpperCamelCase     :					Any			       =		UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS

		# Override required_optional_params to remove num_images_per_prompt
		UpperCamelCase     :					Optional[int]			       =		frozenset(
		    [
		        "num_inference_steps",
		        "generator",
		        "latents",
		        "output_type",
		        "return_dict",
		        "callback",
		        "callback_steps",
		    ]  )







		@property
		def 					__A   ( self	)  -> Optional[int]:







					'''simple docstring'''







					lowerCamelCase    		=  UNetaDModel.from_pretrained(
					    """diffusers/consistency-models-test"""		,      subfolder="""test_unet"""		,      )
					return unet







		@property
		def 					__A   ( self	)  -> str:







					'''simple docstring'''







					lowerCamelCase    		=  UNetaDModel.from_pretrained(
					    """diffusers/consistency-models-test"""		,      subfolder="""test_unet_class_cond"""		,      )
					return unet







		def 					__A   ( self		,      A=False	)  -> Tuple:







					'''simple docstring'''







					if class_cond:
								lowerCamelCase    		=  self.dummy_cond_unet
					else:
								lowerCamelCase    		=  self.dummy_uncond_unet

					# Default to CM multistep sampler
					lowerCamelCase    		=  CMStochasticIterativeScheduler(
					    num_train_timesteps=40		,      sigma_min=0.002		,      sigma_max=80.0		,      )

					lowerCamelCase    		=  {
					    """unet""": unet,
					    """scheduler""": scheduler,
					}

					return components







		def 					__A   ( self		,      A		,      A=0	)  -> List[str]:







					'''simple docstring'''







					if str(A	).startswith("""mps"""	):
								lowerCamelCase    		=  torch.manual_seed(A	)
					else:
								lowerCamelCase    		=  torch.Generator(device=A	).manual_seed(A	)

					lowerCamelCase    		=  {
					    """batch_size""": 1,
					    """num_inference_steps""": None,
					    """timesteps""": [22, 0],
					    """generator""": generator,
					    """output_type""": """np""",
					}

					return inputs







		def 					__A   ( self	)  -> Optional[Any]:







					'''simple docstring'''







					lowerCamelCase    		=  """cpu"""  # ensure determinism for the device-dependent torch.Generator
					lowerCamelCase    		=  self.get_dummy_components()
					lowerCamelCase    		=  ConsistencyModelPipeline(**A	)
					lowerCamelCase    		=  pipe.to(A	)
					pipe.set_progress_bar_config(disable=A	)

					lowerCamelCase    		=  self.get_dummy_inputs(A	)
					lowerCamelCase    		=  pipe(**A	).images
					assert image.shape == (1, 32, 32, 3)

					lowerCamelCase    		=  image[0, -3:, -3:, -1]
					lowerCamelCase    		=  np.array([0.3572, 0.6273, 0.4031, 0.3961, 0.4321, 0.5730, 0.5266, 0.4780, 0.5004]	)

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







		def 					__A   ( self	)  -> Dict:







					'''simple docstring'''







					lowerCamelCase    		=  """cpu"""  # ensure determinism for the device-dependent torch.Generator
					lowerCamelCase    		=  self.get_dummy_components(class_cond=A	)
					lowerCamelCase    		=  ConsistencyModelPipeline(**A	)
					lowerCamelCase    		=  pipe.to(A	)
					pipe.set_progress_bar_config(disable=A	)

					lowerCamelCase    		=  self.get_dummy_inputs(A	)
					lowerCamelCase    		=  0
					lowerCamelCase    		=  pipe(**A	).images
					assert image.shape == (1, 32, 32, 3)

					lowerCamelCase    		=  image[0, -3:, -3:, -1]
					lowerCamelCase    		=  np.array([0.3572, 0.6273, 0.4031, 0.3961, 0.4321, 0.5730, 0.5266, 0.4780, 0.5004]	)

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







		def 					__A   ( self	)  -> List[Any]:







					'''simple docstring'''







					lowerCamelCase    		=  """cpu"""  # ensure determinism for the device-dependent torch.Generator
					lowerCamelCase    		=  self.get_dummy_components()
					lowerCamelCase    		=  ConsistencyModelPipeline(**A	)
					lowerCamelCase    		=  pipe.to(A	)
					pipe.set_progress_bar_config(disable=A	)

					lowerCamelCase    		=  self.get_dummy_inputs(A	)
					lowerCamelCase    		=  1
					lowerCamelCase    		=  None
					lowerCamelCase    		=  pipe(**A	).images
					assert image.shape == (1, 32, 32, 3)

					lowerCamelCase    		=  image[0, -3:, -3:, -1]
					lowerCamelCase    		=  np.array([0.5004, 0.5004, 0.4994, 0.5008, 0.4976, 0.5018, 0.4990, 0.4982, 0.4987]	)

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







		def 					__A   ( self	)  -> List[str]:







					'''simple docstring'''







					lowerCamelCase    		=  """cpu"""  # ensure determinism for the device-dependent torch.Generator
					lowerCamelCase    		=  self.get_dummy_components(class_cond=A	)
					lowerCamelCase    		=  ConsistencyModelPipeline(**A	)
					lowerCamelCase    		=  pipe.to(A	)
					pipe.set_progress_bar_config(disable=A	)

					lowerCamelCase    		=  self.get_dummy_inputs(A	)
					lowerCamelCase    		=  1
					lowerCamelCase    		=  None
					lowerCamelCase    		=  0
					lowerCamelCase    		=  pipe(**A	).images
					assert image.shape == (1, 32, 32, 3)

					lowerCamelCase    		=  image[0, -3:, -3:, -1]
					lowerCamelCase    		=  np.array([0.5004, 0.5004, 0.4994, 0.5008, 0.4976, 0.5018, 0.4990, 0.4982, 0.4987]	)

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







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



		"""simple docstring"""

		def 					__A   ( self	)  -> Optional[Any]:







					'''simple docstring'''







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







		def 					__A   ( self		,      A=0		,      A=False		,      A="cpu"		,      A=torch.floataa		,      A=(1, 3, 64, 64)	)  -> Optional[int]:







					'''simple docstring'''







					lowerCamelCase    		=  torch.manual_seed(A	)

					lowerCamelCase    		=  {
					    """num_inference_steps""": None,
					    """timesteps""": [22, 0],
					    """class_labels""": 0,
					    """generator""": generator,
					    """output_type""": """np""",
					}

					if get_fixed_latents:
								lowerCamelCase    		=  self.get_fixed_latents(seed=A		,      device=A		,      dtype=A		,      shape=A	)
								lowerCamelCase    		=  latents

					return inputs







		def 					__A   ( self		,      A=0		,      A="cpu"		,      A=torch.floataa		,      A=(1, 3, 64, 64)	)  -> Union[str, Any]:







					'''simple docstring'''







					if type(A	) == str:
								lowerCamelCase    		=  torch.device(A	)
					lowerCamelCase    		=  torch.Generator(device=A	).manual_seed(A	)
					lowerCamelCase    		=  randn_tensor(A		,      generator=A		,      device=A		,      dtype=A	)
					return latents







		def 					__A   ( self	)  -> str:







					'''simple docstring'''







					lowerCamelCase    		=  UNetaDModel.from_pretrained("""diffusers/consistency_models"""		,      subfolder="""diffusers_cd_imagenet64_l2"""	)
					lowerCamelCase    		=  CMStochasticIterativeScheduler(
					    num_train_timesteps=40		,      sigma_min=0.002		,      sigma_max=80.0		,      )
					lowerCamelCase    		=  ConsistencyModelPipeline(unet=A		,      scheduler=A	)
					pipe.to(torch_device=A	)
					pipe.set_progress_bar_config(disable=A	)

					lowerCamelCase    		=  self.get_inputs()
					lowerCamelCase    		=  pipe(**A	).images
					assert image.shape == (1, 64, 64, 3)

					lowerCamelCase    		=  image[0, -3:, -3:, -1]

					lowerCamelCase    		=  np.array([0.0888, 0.0881, 0.0666, 0.0479, 0.0292, 0.0195, 0.0201, 0.0163, 0.0254]	)

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







		def 					__A   ( self	)  -> Optional[Any]:







					'''simple docstring'''







					lowerCamelCase    		=  UNetaDModel.from_pretrained("""diffusers/consistency_models"""		,      subfolder="""diffusers_cd_imagenet64_l2"""	)
					lowerCamelCase    		=  CMStochasticIterativeScheduler(
					    num_train_timesteps=40		,      sigma_min=0.002		,      sigma_max=80.0		,      )
					lowerCamelCase    		=  ConsistencyModelPipeline(unet=A		,      scheduler=A	)
					pipe.to(torch_device=A	)
					pipe.set_progress_bar_config(disable=A	)

					lowerCamelCase    		=  self.get_inputs()
					lowerCamelCase    		=  1
					lowerCamelCase    		=  None
					lowerCamelCase    		=  pipe(**A	).images
					assert image.shape == (1, 64, 64, 3)

					lowerCamelCase    		=  image[0, -3:, -3:, -1]

					lowerCamelCase    		=  np.array([0.0340, 0.0152, 0.0063, 0.0267, 0.0221, 0.0107, 0.0416, 0.0186, 0.0217]	)

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







		@require_torch_a
		def 					__A   ( self	)  -> Any:







					'''simple docstring'''







					lowerCamelCase    		=  UNetaDModel.from_pretrained("""diffusers/consistency_models"""		,      subfolder="""diffusers_cd_imagenet64_l2"""	)
					lowerCamelCase    		=  CMStochasticIterativeScheduler(
					    num_train_timesteps=40		,      sigma_min=0.002		,      sigma_max=80.0		,      )
					lowerCamelCase    		=  ConsistencyModelPipeline(unet=A		,      scheduler=A	)
					pipe.to(torch_device=A		,      torch_dtype=torch.floataa	)
					pipe.set_progress_bar_config(disable=A	)

					lowerCamelCase    		=  self.get_inputs(get_fixed_latents=A		,      device=A	)
					# Ensure usage of flash attention in torch 2.0
					with sdp_kernel(enable_flash=A		,      enable_math=A		,      enable_mem_efficient=A	):
								lowerCamelCase    		=  pipe(**A	).images
					assert image.shape == (1, 64, 64, 3)

					lowerCamelCase    		=  image[0, -3:, -3:, -1]

					lowerCamelCase    		=  np.array([0.1875, 0.1428, 0.1289, 0.2151, 0.2092, 0.1477, 0.1877, 0.1641, 0.1353]	)

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







		@require_torch_a
		def 					__A   ( self	)  -> List[Any]:







					'''simple docstring'''







					lowerCamelCase    		=  UNetaDModel.from_pretrained("""diffusers/consistency_models"""		,      subfolder="""diffusers_cd_imagenet64_l2"""	)
					lowerCamelCase    		=  CMStochasticIterativeScheduler(
					    num_train_timesteps=40		,      sigma_min=0.002		,      sigma_max=80.0		,      )
					lowerCamelCase    		=  ConsistencyModelPipeline(unet=A		,      scheduler=A	)
					pipe.to(torch_device=A		,      torch_dtype=torch.floataa	)
					pipe.set_progress_bar_config(disable=A	)

					lowerCamelCase    		=  self.get_inputs(get_fixed_latents=A		,      device=A	)
					lowerCamelCase    		=  1
					lowerCamelCase    		=  None
					# Ensure usage of flash attention in torch 2.0
					with sdp_kernel(enable_flash=A		,      enable_math=A		,      enable_mem_efficient=A	):
								lowerCamelCase    		=  pipe(**A	).images
					assert image.shape == (1, 64, 64, 3)

					lowerCamelCase    		=  image[0, -3:, -3:, -1]

					lowerCamelCase    		=  np.array([0.1663, 0.1948, 0.2275, 0.1680, 0.1204, 0.1245, 0.1858, 0.1338, 0.2095]	)

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

