





'''simple docstring'''

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 __a :





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

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       parent
      __SCREAMING_SNAKE_CASE      							=       batch_size
      __SCREAMING_SNAKE_CASE      							=       image_size
      __SCREAMING_SNAKE_CASE      							=       patch_size
      __SCREAMING_SNAKE_CASE      							=       num_channels
      __SCREAMING_SNAKE_CASE      							=       embed_dim
      __SCREAMING_SNAKE_CASE      							=       depths
      __SCREAMING_SNAKE_CASE      							=       num_heads
      __SCREAMING_SNAKE_CASE      							=       window_size
      __SCREAMING_SNAKE_CASE      							=       mlp_ratio
      __SCREAMING_SNAKE_CASE      							=       qkv_bias
      __SCREAMING_SNAKE_CASE      							=       hidden_dropout_prob
      __SCREAMING_SNAKE_CASE      							=       attention_probs_dropout_prob
      __SCREAMING_SNAKE_CASE      							=       drop_path_rate
      __SCREAMING_SNAKE_CASE      							=       hidden_act
      __SCREAMING_SNAKE_CASE      							=       use_absolute_embeddings
      __SCREAMING_SNAKE_CASE      							=       patch_norm
      __SCREAMING_SNAKE_CASE      							=       layer_norm_eps
      __SCREAMING_SNAKE_CASE      							=       initializer_range
      __SCREAMING_SNAKE_CASE      							=       is_training
      __SCREAMING_SNAKE_CASE      							=       scope
      __SCREAMING_SNAKE_CASE      							=       use_labels
      __SCREAMING_SNAKE_CASE      							=       type_sequence_label_size
      __SCREAMING_SNAKE_CASE      							=       encoder_stride
      __SCREAMING_SNAKE_CASE      							=       out_features
      __SCREAMING_SNAKE_CASE      							=       out_indices





   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

      __SCREAMING_SNAKE_CASE      							=       None
      if self.use_labels:
         __SCREAMING_SNAKE_CASE      							=       ids_tensor([self.batch_size]				,self.type_sequence_label_size    )

      __SCREAMING_SNAKE_CASE      							=       self.get_config()

      return config, pixel_values, labels





   def      UpperCAmelCase__     (					self				:			str    ):

      '''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      UpperCAmelCase__     (					self				:			int				,lowerCamelCase				:			List[str]				,lowerCamelCase				:			Optional[Any]				,lowerCamelCase				:			Tuple    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       MaskFormerSwinModel(config=lowerCamelCase    )
      model.to(lowerCamelCase    )
      model.eval()
      __SCREAMING_SNAKE_CASE      							=       model(lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
      __SCREAMING_SNAKE_CASE      							=       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      UpperCAmelCase__     (					self				:			Tuple				,lowerCamelCase				:			int				,lowerCamelCase				:			Optional[Any]				,lowerCamelCase				:			Tuple    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       MaskFormerSwinBackbone(config=lowerCamelCase    )
      model.to(lowerCamelCase    )
      model.eval()
      __SCREAMING_SNAKE_CASE      							=       model(lowerCamelCase    )

      # 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(lowerCamelCase    ):
         __SCREAMING_SNAKE_CASE      							=       ["""stem"""]
         __SCREAMING_SNAKE_CASE      							=       MaskFormerSwinBackbone(config=lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.prepare_config_and_inputs()
      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       config_and_inputs
      __SCREAMING_SNAKE_CASE      							=       {"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_torch
class __a (   _snake_case,   _snake_case,   unittest.TestCase			):
   __UpperCamelCase   : Dict	      =	(
       (
           MaskFormerSwinModel,
           MaskFormerSwinBackbone,
       )
       if is_torch_available()
       else ()
   )
   __UpperCamelCase   : Optional[int]	      =	{'feature-extraction': MaskFormerSwinModel} if is_torch_available() else {}
   __UpperCamelCase   : Dict	      =	False
   __UpperCamelCase   : str	      =	False
   __UpperCamelCase   : Optional[Any]	      =	False
   __UpperCamelCase   : Optional[Any]	      =	False
   __UpperCamelCase   : Tuple	      =	False





   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       MaskFormerSwinModelTester(self    )
      __SCREAMING_SNAKE_CASE      							=       ConfigTester(self				,config_class=lowerCamelCase				,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      UpperCAmelCase__     (					self				:			Optional[Any]    ):

      '''simple docstring'''

      pass





   def      UpperCAmelCase__     (					self				:			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      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      return





   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*lowerCamelCase    )





   @unittest.skip("""Swin does not use inputs_embeds"""    )
   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      pass





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

      '''simple docstring'''

      pass





   def      UpperCAmelCase__     (					self				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE      							=       model_class(lowerCamelCase    )
         self.assertIsInstance(model.get_input_embeddings()				,(nn.Module)    )
         __SCREAMING_SNAKE_CASE      							=       model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(lowerCamelCase				,nn.Linear    )    )





   def      UpperCAmelCase__     (					self				:			str    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE      							=       model_class(lowerCamelCase    )
         __SCREAMING_SNAKE_CASE      							=       inspect.signature(model.forward    )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         __SCREAMING_SNAKE_CASE      							=       [*signature.parameters.keys()]

         __SCREAMING_SNAKE_CASE      							=       ["""pixel_values"""]
         self.assertListEqual(arg_names[:1]				,lowerCamelCase    )





   @unittest.skip(reason="""MaskFormerSwin is only used as backbone and doesn't support output_attentions"""    )
   def      UpperCAmelCase__     (					self				:			str    ):

      '''simple docstring'''

      pass





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

      '''simple docstring'''

      pass





   def      UpperCAmelCase__     (					self				:			Dict				,lowerCamelCase				:			int				,lowerCamelCase				:			Optional[int]				,lowerCamelCase				:			List[Any]				,lowerCamelCase				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       model_class(lowerCamelCase    )
      model.to(lowerCamelCase    )
      model.eval()

      with torch.no_grad():
         __SCREAMING_SNAKE_CASE      							=       model(**self._prepare_for_class(lowerCamelCase				,lowerCamelCase    )    )

      __SCREAMING_SNAKE_CASE      							=       outputs.hidden_states

      __SCREAMING_SNAKE_CASE      							=       getattr(
          self.model_tester				,"""expected_num_hidden_layers"""				,len(self.model_tester.depths    ) + 1    )
      self.assertEqual(len(lowerCamelCase    )				,lowerCamelCase    )

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

      __SCREAMING_SNAKE_CASE      							=       (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      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs_for_common()

      __SCREAMING_SNAKE_CASE      							=       (
          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:
         __SCREAMING_SNAKE_CASE      							=       True
         self.check_hidden_states_output(lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,lowerCamelCase    )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         __SCREAMING_SNAKE_CASE      							=       True

         self.check_hidden_states_output(lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs_for_common()
      __SCREAMING_SNAKE_CASE      							=       3

      __SCREAMING_SNAKE_CASE      							=       (
          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)
      )
      __SCREAMING_SNAKE_CASE      							=       (
          config.patch_size
          if isinstance(config.patch_size				,collections.abc.Iterable    )
          else (config.patch_size, config.patch_size)
      )

      __SCREAMING_SNAKE_CASE      							=       image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
      __SCREAMING_SNAKE_CASE      							=       image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE      							=       True
         self.check_hidden_states_output(lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,(padded_height, padded_width)    )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         __SCREAMING_SNAKE_CASE      							=       True
         self.check_hidden_states_output(lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,(padded_height, padded_width)    )





   @unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""    )
   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      pass





   @unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""    )
   def      UpperCAmelCase__     (					self				:			Optional[int]    ):

      '''simple docstring'''

      pass





   @unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""    )
   def      UpperCAmelCase__     (					self				:			Dict    ):

      '''simple docstring'''

      pass





   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs_for_common()

      def set_nan_tensor_to_zero(lowerCamelCase				:			Union[str, Any]    ):
         __SCREAMING_SNAKE_CASE      							=       0
         return t

      def check_equivalence(lowerCamelCase				:			Any				,lowerCamelCase				:			int				,lowerCamelCase				:			int				,lowerCamelCase				:			str={}    ):
         with torch.no_grad():
            __SCREAMING_SNAKE_CASE      							=       model(**lowerCamelCase				,return_dict=lowerCamelCase				,**lowerCamelCase    )
            __SCREAMING_SNAKE_CASE      							=       model(**lowerCamelCase				,return_dict=lowerCamelCase				,**lowerCamelCase    ).to_tuple()

            def recursive_check(lowerCamelCase				:			Tuple				,lowerCamelCase				:			Union[str, Any]    ):
               if isinstance(lowerCamelCase				,(List, Tuple)    ):
                  for tuple_iterable_value, dict_iterable_value in zip(lowerCamelCase				,lowerCamelCase    ):
                     recursive_check(lowerCamelCase				,lowerCamelCase    )
               elif isinstance(lowerCamelCase				,lowerCamelCase    ):
                  for tuple_iterable_value, dict_iterable_value in zip(
                      tuple_object.values()				,dict_object.values()    ):
                     recursive_check(lowerCamelCase				,lowerCamelCase    )
               elif tuple_object is None:
                  return
               else:
                  self.assertTrue(
                      torch.allclose(
                          set_nan_tensor_to_zero(lowerCamelCase    )				,set_nan_tensor_to_zero(lowerCamelCase    )				,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(lowerCamelCase    ).any()} and `inf`: {torch.isinf(lowerCamelCase    )}. Dict has"""
                          f""" `nan`: {torch.isnan(lowerCamelCase    ).any()} and `inf`: {torch.isinf(lowerCamelCase    )}."""
                      )				,)

            recursive_check(lowerCamelCase				,lowerCamelCase    )

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE      							=       model_class(lowerCamelCase    )
         model.to(lowerCamelCase    )
         model.eval()

         __SCREAMING_SNAKE_CASE      							=       self._prepare_for_class(lowerCamelCase				,lowerCamelCase    )
         __SCREAMING_SNAKE_CASE      							=       self._prepare_for_class(lowerCamelCase				,lowerCamelCase    )
         check_equivalence(lowerCamelCase				,lowerCamelCase				,lowerCamelCase    )

         __SCREAMING_SNAKE_CASE      							=       self._prepare_for_class(lowerCamelCase				,lowerCamelCase				,return_labels=lowerCamelCase    )
         __SCREAMING_SNAKE_CASE      							=       self._prepare_for_class(lowerCamelCase				,lowerCamelCase				,return_labels=lowerCamelCase    )
         check_equivalence(lowerCamelCase				,lowerCamelCase				,lowerCamelCase    )

         __SCREAMING_SNAKE_CASE      							=       self._prepare_for_class(lowerCamelCase				,lowerCamelCase    )
         __SCREAMING_SNAKE_CASE      							=       self._prepare_for_class(lowerCamelCase				,lowerCamelCase    )
         check_equivalence(lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,{"""output_hidden_states""": True}    )

         __SCREAMING_SNAKE_CASE      							=       self._prepare_for_class(lowerCamelCase				,lowerCamelCase				,return_labels=lowerCamelCase    )
         __SCREAMING_SNAKE_CASE      							=       self._prepare_for_class(lowerCamelCase				,lowerCamelCase				,return_labels=lowerCamelCase    )
         check_equivalence(lowerCamelCase				,lowerCamelCase				,lowerCamelCase				,{"""output_hidden_states""": True}    )







@require_torch
class __a (   unittest.TestCase,   _snake_case			):
   __UpperCamelCase   : Optional[Any]	      =	(MaskFormerSwinBackbone,) if is_torch_available() else ()
   __UpperCamelCase   : Any	      =	MaskFormerSwinConfig





   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       MaskFormerSwinModelTester(self    )





   def      UpperCAmelCase__     (					self				:			Optional[int]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs_for_common()
      __SCREAMING_SNAKE_CASE      							=       inputs_dict["""pixel_values"""].shape[0]

      for backbone_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE      							=       backbone_class(lowerCamelCase    )
         backbone.to(lowerCamelCase    )
         backbone.eval()

         __SCREAMING_SNAKE_CASE      							=       backbone(**lowerCamelCase    )

         # Test default outputs and verify feature maps
         self.assertIsInstance(outputs.feature_maps				,lowerCamelCase    )
         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
         __SCREAMING_SNAKE_CASE      							=       backbone(**lowerCamelCase				,output_hidden_states=lowerCamelCase    )
         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)
               __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       hidden_state.shape
               self.assertTrue((h_batch_size, h_n_channels)				,(batch_size, n_channels)    )

            # Test output_attentions=True
         if self.has_attentions:
            __SCREAMING_SNAKE_CASE      							=       backbone(**lowerCamelCase				,output_attentions=lowerCamelCase    )
            self.assertIsNotNone(outputs.attentions    )












'''simple docstring'''

import os
import string
import sys


a        =						1 << 8

a        =						{
    "tab": ord("\t"),
    "newline": ord("\r"),
    "esc": 27,
    "up": 65 + ARROW_KEY_FLAG,
    "down": 66 + ARROW_KEY_FLAG,
    "right": 67 + ARROW_KEY_FLAG,
    "left": 68 + ARROW_KEY_FLAG,
    "mod_int": 91,
    "undefined": sys.maxsize,
    "interrupt": 3,
    "insert": 50,
    "delete": 51,
    "pg_up": 53,
    "pg_down": 54,
}

a        =						KEYMAP["up"]
a        =						KEYMAP["left"]

if sys.platform == "win32":
    a        =						[]
    a        =						{
        b"\xe0H": KEYMAP["up"] - ARROW_KEY_FLAG,
        b"\x00H": KEYMAP["up"] - ARROW_KEY_FLAG,
        b"\xe0P": KEYMAP["down"] - ARROW_KEY_FLAG,
        b"\x00P": KEYMAP["down"] - ARROW_KEY_FLAG,
        b"\xe0M": KEYMAP["right"] - ARROW_KEY_FLAG,
        b"\x00M": KEYMAP["right"] - ARROW_KEY_FLAG,
        b"\xe0K": KEYMAP["left"] - ARROW_KEY_FLAG,
        b"\x00K": KEYMAP["left"] - ARROW_KEY_FLAG,
    }

for i in range(10):
    a        =						ord(str(i))

def 						__magic_name__       (							)						->					Union[str, Any]:

   '''simple docstring'''







   if os.name == "nt":
      import msvcrt

      __SCREAMING_SNAKE_CASE      							=       """mbcs"""
      # Flush the keyboard buffer
      while msvcrt.kbhit():
         msvcrt.getch()
      if len(__UpperCAmelCase      ) == 0:
         # Read the keystroke
         __SCREAMING_SNAKE_CASE      							=       msvcrt.getch()

         # If it is a prefix char, get second part
         if ch in (b"\x00", b"\xe0"):
            __SCREAMING_SNAKE_CASE      							=       ch + msvcrt.getch()
            # Translate actual Win chars to bullet char types
            try:
               __SCREAMING_SNAKE_CASE      							=       chr(WIN_KEYMAP[cha]      )
               WIN_CH_BUFFER.append(chr(KEYMAP["""mod_int"""]      )      )
               WIN_CH_BUFFER.append(__UpperCAmelCase      )
               if ord(__UpperCAmelCase      ) in (
                   KEYMAP["insert"] - 1 << 9,
                   KEYMAP["delete"] - 1 << 9,
                   KEYMAP["pg_up"] - 1 << 9,
                   KEYMAP["pg_down"] - 1 << 9,
               ):
                  WIN_CH_BUFFER.append(chr(126      )      )
               __SCREAMING_SNAKE_CASE      							=       chr(KEYMAP["""esc"""]      )
            except KeyError:
               __SCREAMING_SNAKE_CASE      							=       cha[1]
         else:
            __SCREAMING_SNAKE_CASE      							=       ch.decode(__UpperCAmelCase      )
      else:
         __SCREAMING_SNAKE_CASE      							=       WIN_CH_BUFFER.pop(0      )
   elif os.name == "posix":
      import termios
      import tty

      __SCREAMING_SNAKE_CASE      							=       sys.stdin.fileno()
      __SCREAMING_SNAKE_CASE      							=       termios.tcgetattr(__UpperCAmelCase      )
      try:
         tty.setraw(__UpperCAmelCase      )
         __SCREAMING_SNAKE_CASE      							=       sys.stdin.read(1      )
      finally:
         termios.tcsetattr(__UpperCAmelCase							,	termios.TCSADRAIN							,	__UpperCAmelCase      )
   return ch







def 						__magic_name__       (							)						->					List[str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       get_raw_chars()
   if ord(__UpperCAmelCase      ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
      return char

   elif ord(__UpperCAmelCase      ) == KEYMAP["esc"]:
      __SCREAMING_SNAKE_CASE      							=       get_raw_chars()
      if ord(__UpperCAmelCase      ) == KEYMAP["mod_int"]:
         __SCREAMING_SNAKE_CASE      							=       get_raw_chars()
         if ord(__UpperCAmelCase      ) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(__UpperCAmelCase      ) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
            return chr(ord(__UpperCAmelCase      ) + ARROW_KEY_FLAG      )
         else:
            return KEYMAP["undefined"]
      else:
         return get_raw_chars()

   else:
      if char in string.printable:
         return char
      else:
         return KEYMAP["undefined"]





