
import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch
   from torch import nn

   from transformers import MaskFormerSwinBackbone
   from transformers.models.maskformer import MaskFormerSwinModel






class   UpperCAmelCase		:



   def __init__(self		:					Dict    ,						snake_case__		:					Dict    ,						snake_case__		:					Any=13    ,						snake_case__		:					Any=32    ,						snake_case__		:					Optional[Any]=2    ,						snake_case__		:					Union[str, Any]=3    ,						snake_case__		:					List[Any]=16    ,						snake_case__		:					int=[1, 2, 1]    ,						snake_case__		:					Dict=[2, 2, 4]    ,						snake_case__		:					Dict=2    ,						snake_case__		:					Tuple=2.0    ,						snake_case__		:					Optional[int]=True    ,						snake_case__		:					Union[str, Any]=0.0    ,						snake_case__		:					Any=0.0    ,						snake_case__		:					Union[str, Any]=0.1    ,						snake_case__		:					int="gelu"    ,						snake_case__		:					Optional[int]=False    ,						snake_case__		:					List[Any]=True    ,						snake_case__		:					List[str]=0.02    ,						snake_case__		:					int=1e-5    ,						snake_case__		:					List[str]=True    ,						snake_case__		:					Union[str, Any]=None    ,						snake_case__		:					List[Any]=True    ,						snake_case__		:					Optional[Any]=10    ,						snake_case__		:					Optional[Any]=8    ,						snake_case__		:					Any=["stage1", "stage2", "stage3"]    ,						snake_case__		:					Tuple=[1, 2, 3]    ,						)		->	Union[str, Any]:


          '''simple docstring'''


          snake_case       :   Any							=      parent
          snake_case       :   Optional[int]							=      batch_size
          snake_case       :   Union[str, Any]							=      image_size
          snake_case       :   Dict							=      patch_size
          snake_case       :   Optional[Any]							=      num_channels
          snake_case       :   Union[str, Any]							=      embed_dim
          snake_case       :   int							=      depths
          snake_case       :   List[str]							=      num_heads
          snake_case       :   Union[str, Any]							=      window_size
          snake_case       :   Union[str, Any]							=      mlp_ratio
          snake_case       :   List[Any]							=      qkv_bias
          snake_case       :   List[Any]							=      hidden_dropout_prob
          snake_case       :   Union[str, Any]							=      attention_probs_dropout_prob
          snake_case       :   Union[str, Any]							=      drop_path_rate
          snake_case       :   int							=      hidden_act
          snake_case       :   Optional[int]							=      use_absolute_embeddings
          snake_case       :   int							=      patch_norm
          snake_case       :   Union[str, Any]							=      layer_norm_eps
          snake_case       :   Any							=      initializer_range
          snake_case       :   Optional[Any]							=      is_training
          snake_case       :   Tuple							=      scope
          snake_case       :   Optional[int]							=      use_labels
          snake_case       :   Optional[Any]							=      type_sequence_label_size
          snake_case       :   Union[str, Any]							=      encoder_stride
          snake_case       :   Any							=      out_features
          snake_case       :   Tuple							=      out_indices



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	Dict:


          '''simple docstring'''


          snake_case       :   Optional[Any]							=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

          snake_case       :   int							=      None
          if self.use_labels:
                 snake_case       :   Tuple							=      ids_tensor([self.batch_size]    ,						self.type_sequence_label_size )

          snake_case       :   Dict							=      self.get_config()

          return config, pixel_values, labels



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str] )		->	int:


          '''simple docstring'''


          return MaskFormerSwinConfig(
              image_size=self.image_size    ,						patch_size=self.patch_size    ,						num_channels=self.num_channels    ,						embed_dim=self.embed_dim    ,						depths=self.depths    ,						num_heads=self.num_heads    ,						window_size=self.window_size    ,						mlp_ratio=self.mlp_ratio    ,						qkv_bias=self.qkv_bias    ,						hidden_dropout_prob=self.hidden_dropout_prob    ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,						drop_path_rate=self.drop_path_rate    ,						hidden_act=self.hidden_act    ,						use_absolute_embeddings=self.use_absolute_embeddings    ,						path_norm=self.patch_norm    ,						layer_norm_eps=self.layer_norm_eps    ,						initializer_range=self.initializer_range    ,						encoder_stride=self.encoder_stride    ,						out_features=self.out_features    ,						out_indices=self.out_indices    ,						)



   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple    ,						snake_case__		:					List[Any]    ,						snake_case__		:					List[str]    ,						snake_case__		:					Tuple )		->	Optional[Any]:


          '''simple docstring'''


          snake_case       :   Union[str, Any]							=      MaskFormerSwinModel(config=snake_case__ )
          model.to(snake_case__ )
          model.eval()
          snake_case       :   List[Any]							=      model(snake_case__ )

          snake_case       :   Dict							=      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
          snake_case       :   int							=      int(config.embed_dim * 2 ** (len(config.depths ) - 1) )

          self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, expected_seq_len, expected_dim) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str]    ,						snake_case__		:					Union[str, Any]    ,						snake_case__		:					List[Any]    ,						snake_case__		:					Union[str, Any] )		->	str:


          '''simple docstring'''


          snake_case       :   Optional[int]							=      MaskFormerSwinBackbone(config=snake_case__ )
          model.to(snake_case__ )
          model.eval()
          snake_case       :   List[Any]							=      model(snake_case__ )

          # verify feature maps
          self.parent.assertEqual(len(result.feature_maps )    ,						len(config.out_features ) )
          self.parent.assertListEqual(list(result.feature_maps[0].shape )    ,						[13, 16, 16, 16] )

          # verify channels
          self.parent.assertEqual(len(model.channels )    ,						len(config.out_features ) )
          self.parent.assertListEqual(model.channels    ,						[16, 32, 64] )

          # verify ValueError
          with self.parent.assertRaises(snake_case__ ):
                 snake_case       :   Tuple							=      ["stem"]
                 snake_case       :   List[Any]							=      MaskFormerSwinBackbone(config=snake_case__ )



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


          '''simple docstring'''


          snake_case       :   Union[str, Any]							=      self.prepare_config_and_inputs()
          snake_case				,					snake_case				,					snake_case       :   List[Any]							=      config_and_inputs
          snake_case       :   int							=      {"pixel_values": pixel_values}
          return config, inputs_dict






@require_torch
class   UpperCAmelCase		(						A_       ,A_       ,unittest.TestCase ):
   A__					:		List[str]						     =     (
       (
           MaskFormerSwinModel,
           MaskFormerSwinBackbone,
       )
       if is_torch_available()
       else ()
   )
   A__					:		str						     =     {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
   A__					:		Optional[Any]						     =     False
   A__					:		List[Any]						     =     False
   A__					:		List[str]						     =     False
   A__					:		List[str]						     =     False
   A__					:		Union[str, Any]						     =     False



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	List[str]:


          '''simple docstring'''


          snake_case       :   str							=      MaskFormerSwinModelTester(self )
          snake_case       :   Optional[int]							=      ConfigTester(self    ,						config_class=snake_case__    ,						embed_dim=37 )



   @require_torch_multi_gpu
   @unittest.skip(
       reason=(
           "`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with"
           " `nn.DataParallel`"
       ) )
   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	Optional[Any]:


          '''simple docstring'''


          pass



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


          '''simple docstring'''


          self.create_and_test_config_common_properties()
          self.config_tester.create_and_test_config_to_json_string()
          self.config_tester.create_and_test_config_to_json_file()
          self.config_tester.create_and_test_config_from_and_save_pretrained()
          self.config_tester.create_and_test_config_with_num_labels()
          self.config_tester.check_config_can_be_init_without_params()
          self.config_tester.check_config_arguments_init()



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


          '''simple docstring'''


          return



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	str:


          '''simple docstring'''


          snake_case       :   str							=      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Dict:


          '''simple docstring'''


          snake_case       :   Any							=      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_backbone(*snake_case__ )



   @unittest.skip("Swin does not use inputs_embeds" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Any:


          '''simple docstring'''


          pass



   @unittest.skip("Swin does not support feedforward chunking" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str] )		->	Dict:


          '''simple docstring'''


          pass



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	List[str]:


          '''simple docstring'''


          snake_case				,					snake_case       :   Any							=      self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                 snake_case       :   int							=      model_class(snake_case__ )
                 self.assertIsInstance(model.get_input_embeddings()    ,						(nn.Module) )
                 snake_case       :   List[Any]							=      model.get_output_embeddings()
                 self.assertTrue(x is None or isinstance(snake_case__    ,						nn.Linear ) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	Dict:


          '''simple docstring'''


          snake_case				,					snake_case       :   str							=      self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                 snake_case       :   str							=      model_class(snake_case__ )
                 snake_case       :   Optional[int]							=      inspect.signature(model.forward )
                 # signature.parameters is an OrderedDict => so arg_names order is deterministic
                 snake_case       :   Optional[Any]							=      [*signature.parameters.keys()]

                 snake_case       :   Tuple							=      ["pixel_values"]
                 self.assertListEqual(arg_names[:1]    ,						snake_case__ )



   @unittest.skip(reason="MaskFormerSwin is only used as backbone and doesn't support output_attentions" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					List[Any] )		->	str:


          '''simple docstring'''


          pass



   @unittest.skip(reason="MaskFormerSwin is only used as an internal backbone" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	Any:


          '''simple docstring'''


          pass



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any]    ,						snake_case__		:					List[Any]    ,						snake_case__		:					str    ,						snake_case__		:					List[Any]    ,						snake_case__		:					Tuple )		->	Optional[int]:


          '''simple docstring'''


          snake_case       :   Tuple							=      model_class(snake_case__ )
          model.to(snake_case__ )
          model.eval()

          with torch.no_grad():
                 snake_case       :   Any							=      model(**self._prepare_for_class(snake_case__    ,						snake_case__ ) )

          snake_case       :   int							=      outputs.hidden_states

          snake_case       :   Union[str, Any]							=      getattr(
              self.model_tester    ,						"expected_num_hidden_layers"    ,						len(self.model_tester.depths ) + 1 )
          self.assertEqual(len(snake_case__ )    ,						snake_case__ )

          # Swin has a different seq_length
          snake_case       :   Any							=      (
              config.patch_size
              if isinstance(config.patch_size    ,						collections.abc.Iterable )
              else (config.patch_size, config.patch_size)
          )

          snake_case       :   Tuple							=      (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

          self.assertListEqual(
              list(hidden_states[0].shape[-2:] )    ,						[num_patches, self.model_tester.embed_dim]    ,						)



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	Union[str, Any]:


          '''simple docstring'''


          snake_case				,					snake_case       :   List[Any]							=      self.model_tester.prepare_config_and_inputs_for_common()

          snake_case       :   int							=      (
              self.model_tester.image_size
              if isinstance(self.model_tester.image_size    ,						collections.abc.Iterable )
              else (self.model_tester.image_size, self.model_tester.image_size)
          )

          for model_class in self.all_model_classes:
                 snake_case       :   int							=      True
                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__ )

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 snake_case       :   Dict							=      True

                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Any:


          '''simple docstring'''


          snake_case				,					snake_case       :   Union[str, Any]							=      self.model_tester.prepare_config_and_inputs_for_common()
          snake_case       :   Any							=      3

          snake_case       :   List[str]							=      (
              self.model_tester.image_size
              if isinstance(self.model_tester.image_size    ,						collections.abc.Iterable )
              else (self.model_tester.image_size, self.model_tester.image_size)
          )
          snake_case       :   Tuple							=      (
              config.patch_size
              if isinstance(config.patch_size    ,						collections.abc.Iterable )
              else (config.patch_size, config.patch_size)
          )

          snake_case       :   str							=      image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
          snake_case       :   str							=      image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

          for model_class in self.all_model_classes:
                 snake_case       :   str							=      True
                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						(padded_height, padded_width) )

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 snake_case       :   Optional[Any]							=      True
                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						(padded_height, padded_width) )



   @unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	str:


          '''simple docstring'''


          pass



   @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	int:


          '''simple docstring'''


          pass



   @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	str:


          '''simple docstring'''


          pass



   def 				_SCREAMING_SNAKE_CASE   (self		:					Any )		->	Any:


          '''simple docstring'''


          snake_case				,					snake_case       :   List[Any]							=      self.model_tester.prepare_config_and_inputs_for_common()

          def set_nan_tensor_to_zero(snake_case__		:					Union[str, Any] ):
                 snake_case       :   Any							=      0
                 return t

          def check_equivalence(snake_case__		:					Union[str, Any]    ,						snake_case__		:					int    ,						snake_case__		:					List[str]    ,						snake_case__		:					Optional[int]={} ):
                 with torch.no_grad():
                        snake_case       :   Optional[Any]							=      model(**snake_case__    ,						return_dict=snake_case__    ,						**snake_case__ )
                        snake_case       :   Tuple							=      model(**snake_case__    ,						return_dict=snake_case__    ,						**snake_case__ ).to_tuple()

                        def recursive_check(snake_case__		:					List[str]    ,						snake_case__		:					Optional[Any] ):
                               if isinstance(snake_case__    ,						(List, Tuple) ):
                                      for tuple_iterable_value, dict_iterable_value in zip(snake_case__    ,						snake_case__ ):
                                             recursive_check(snake_case__    ,						snake_case__ )
                               elif isinstance(snake_case__    ,						snake_case__ ):
                                      for tuple_iterable_value, dict_iterable_value in zip(
                                          tuple_object.values()    ,						dict_object.values() ):
                                             recursive_check(snake_case__    ,						snake_case__ )
                               elif tuple_object is None:
                                      return
                               else:
                                      self.assertTrue(
                                          torch.allclose(
                                              set_nan_tensor_to_zero(snake_case__ )    ,						set_nan_tensor_to_zero(snake_case__ )    ,						atol=1e-5 )    ,						msg=(
                                              "Tuple and dict output are not equal. Difference:"
                                              f""" {torch.max(torch.abs(tuple_object - dict_object ) )}. Tuple has `nan`:"""
                                              f""" {torch.isnan(snake_case__ ).any()} and `inf`: {torch.isinf(snake_case__ )}. Dict has"""
                                              f""" `nan`: {torch.isnan(snake_case__ ).any()} and `inf`: {torch.isinf(snake_case__ )}."""
                                          )    ,						)

                        recursive_check(snake_case__    ,						snake_case__ )

          for model_class in self.all_model_classes:
                 snake_case       :   Optional[int]							=      model_class(snake_case__ )
                 model.to(snake_case__ )
                 model.eval()

                 snake_case       :   Union[str, Any]							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 snake_case       :   Tuple							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__ )

                 snake_case       :   Tuple							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 snake_case       :   Optional[Any]							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__ )

                 snake_case       :   Dict							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 snake_case       :   List[Any]							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__    ,						{"output_hidden_states": True} )

                 snake_case       :   Any							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 snake_case       :   List[str]							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__    ,						{"output_hidden_states": True} )






@require_torch
class   UpperCAmelCase		(						unittest.TestCase       ,A_ ):
   A__					:		int						     =     (MaskFormerSwinBackbone,) if is_torch_available() else ()
   A__					:		int						     =     MaskFormerSwinConfig



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


          '''simple docstring'''


          snake_case       :   Union[str, Any]							=      MaskFormerSwinModelTester(self )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Optional[Any]:


          '''simple docstring'''


          snake_case				,					snake_case       :   Dict							=      self.model_tester.prepare_config_and_inputs_for_common()
          snake_case       :   Optional[int]							=      inputs_dict["pixel_values"].shape[0]

          for backbone_class in self.all_model_classes:
                 snake_case       :   Optional[int]							=      backbone_class(snake_case__ )
                 backbone.to(snake_case__ )
                 backbone.eval()

                 snake_case       :   Union[str, Any]							=      backbone(**snake_case__ )

                 # Test default outputs and verify feature maps
                 self.assertIsInstance(outputs.feature_maps    ,						snake_case__ )
                 self.assertTrue(len(outputs.feature_maps ) == len(backbone.channels ) )
                 for feature_map, n_channels in zip(outputs.feature_maps    ,						backbone.channels ):
                        self.assertTrue(feature_map.shape[:2]    ,						(batch_size, n_channels) )
                 self.assertIsNone(outputs.hidden_states )
                 self.assertIsNone(outputs.attentions )

                 # Test output_hidden_states=True
                 snake_case       :   Optional[int]							=      backbone(**snake_case__    ,						output_hidden_states=snake_case__ )
                 self.assertIsNotNone(outputs.hidden_states )
                 self.assertTrue(len(outputs.hidden_states )    ,						len(backbone.stage_names ) )
                 # We skip the stem layer
                 for hidden_states, n_channels in zip(outputs.hidden_states[1:]    ,						backbone.channels ):
                        for hidden_state in hidden_states:
                               # Hidden states are in the format (batch_size, (height * width), n_channels)
                               snake_case				,					snake_case				,					snake_case       :   Dict							=      hidden_state.shape
                               self.assertTrue((h_batch_size, h_n_channels)    ,						(batch_size, n_channels) )

            # Test output_attentions=True
                 if self.has_attentions:
                        snake_case       :   Optional[Any]							=      backbone(**snake_case__    ,						output_attentions=snake_case__ )
                        self.assertIsNotNone(outputs.attentions )












# This code is adapted from OpenAI's release
# https://github.com/openai/human-eval/blob/master/human_eval/execution.py

import contextlib
import faulthandler
import io
import multiprocessing
import os
import platform
import signal
import tempfile







def    __lowerCamelCase					(							__a   :List[str]    ,     __a   :List[Any]    ,     __a   :Union[str, Any]    ,     __a   :List[Any]    )		->				Dict:






		"""simple docstring"""

		A__        =   multiprocessing.Manager()
		A__        =   manager.list()

		A__        =   multiprocessing.Process(target=__a    ,     args=(check_program, result, timeout)    )
		p.start()
		p.join(timeout=timeout + 1    )
		if p.is_alive():
				p.kill()

		if not result:
				result.append("""timed out"""    )

		return {
		    "task_id": task_id,
		    "passed": result[0] == "passed",
		    "result": result[0],
		    "completion_id": completion_id,
		}







def    __lowerCamelCase					(							__a   :Optional[Any]    ,     __a   :Any    ,     __a   :List[Any]    )		->				Union[str, Any]:






		"""simple docstring"""

		with create_tempdir():
				# These system calls are needed when cleaning up tempdir.
				import os
				import shutil

				A__        =   shutil.rmtree
				A__        =   os.rmdir
				A__        =   os.chdir

				# Disable functionalities that can make destructive changes to the test.
				reliability_guard()

				# Run program.
				try:
						A__        =   {}
						with swallow_io():
								with time_limit(__a    ):
										exec(__a    ,     __a    )
						result.append("""passed"""    )
				except TimeoutException:
						result.append("""timed out"""    )
				except BaseException as e:
						result.append(F'failed: {e}'    )

				# Needed for cleaning up.
				A__        =   rmtree
				A__        =   rmdir
				A__        =   chdir







@contextlib.contextmanager
def    __lowerCamelCase					(							__a   :List[str]    )		->				Dict:






		"""simple docstring"""

		def signal_handler(__a   :List[Any]    ,     __a   :Optional[Any]    ):
				raise TimeoutException("""Timed out!"""    )

		signal.setitimer(signal.ITIMER_REAL    ,     __a    )
		signal.signal(signal.SIGALRM    ,     __a    )
		try:
				yield
		finally:
				signal.setitimer(signal.ITIMER_REAL    ,     0    )







@contextlib.contextmanager
def    __lowerCamelCase					(							)		->				Union[str, Any]:






		"""simple docstring"""

		A__        =   WriteOnlyStringIO()
		with contextlib.redirect_stdout(__a    ):
				with contextlib.redirect_stderr(__a    ):
						with redirect_stdin(__a    ):
								yield







@contextlib.contextmanager
def    __lowerCamelCase					(							)		->				Dict:






		"""simple docstring"""

		with tempfile.TemporaryDirectory() as dirname:
				with chdir(__a    ):
						yield dirname


class   A			(SCREAMING_SNAKE_CASE    ):
			'''simple docstring'''




			pass


class   A			(io.StringIO    ):
			'''simple docstring'''




			def    a_       (			self   :    Any							,	*__lowerCAmelCase   :    List[str]							,	**__lowerCAmelCase   :    str   )	->	Dict:







					"""simple docstring"""






					raise OSError






			def    a_       (			self   :    Optional[Any]							,	*__lowerCAmelCase   :    Any							,	**__lowerCAmelCase   :    Optional[int]   )	->	str:







					"""simple docstring"""






					raise OSError






			def    a_       (			self   :    Optional[Any]							,	*__lowerCAmelCase   :    Any							,	**__lowerCAmelCase   :    Any   )	->	int:







					"""simple docstring"""






					raise OSError







			def    a_       (			self   :    str							,	*__lowerCAmelCase   :    Any							,	**__lowerCAmelCase   :    Union[str, Any]   )	->	int:







					"""simple docstring"""






					return False


class   A			(contextlib._RedirectStream    ):  # type: ignore
			'''simple docstring'''




			__lowerCamelCase	:       Union[str, Any]							=    '''stdin'''







@contextlib.contextmanager
def    __lowerCamelCase					(							__a   :Union[str, Any]    )		->				List[str]:






		"""simple docstring"""

		if root == ".":
				yield
				return
		A__        =   os.getcwd()
		os.chdir(__a    )
		try:
				yield
		except BaseException as exc:
				raise exc
		finally:
				os.chdir(__a    )







def    __lowerCamelCase					(							__a   :Union[str, Any]=None    )		->				Dict:






		"""simple docstring"""

		if maximum_memory_bytes is not None:
				import resource

				resource.setrlimit(resource.RLIMIT_AS    ,     (maximum_memory_bytes, maximum_memory_bytes)    )
				resource.setrlimit(resource.RLIMIT_DATA    ,     (maximum_memory_bytes, maximum_memory_bytes)    )
				if not platform.uname().system == "Darwin":
						resource.setrlimit(resource.RLIMIT_STACK    ,     (maximum_memory_bytes, maximum_memory_bytes)    )

		faulthandler.disable()

		import builtins

		A__        =   None
		A__        =   None

		import os

		A__        =   """1"""

		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None

		import shutil

		A__        =   None
		A__        =   None
		A__        =   None

		import subprocess

		A__        =   None  # type: ignore

		A__        =   None

		import sys

		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None



