

"""simple docstring"""




import os
import string
import sys


__UpperCAmelCase =				1 << 8

__UpperCAmelCase =				{
    '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,
}

__UpperCAmelCase =				KEYMAP['up']
__UpperCAmelCase =				KEYMAP['left']

if sys.platform == "win32":
      __UpperCAmelCase =				[]
      __UpperCAmelCase =				{
          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):
      __UpperCAmelCase =				ord(str(i))
def   lowerCAmelCase						(					):
 '''simple docstring'''





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

  UpperCAmelCase__					:  List[str]					   =					"mbcs"
  # Flush the keyboard buffer
  while msvcrt.kbhit():
   msvcrt.getch()
  if len(_lowerCAmelCase      ) == 0:
   # Read the keystroke
   UpperCAmelCase__					:  Any					   =					msvcrt.getch()

   # If it is a prefix char, get second part
   if ch in (b"\x00", b"\xe0"):
    UpperCAmelCase__					:  Tuple					   =					ch + msvcrt.getch()
    # Translate actual Win chars to bullet char types
    try:
     UpperCAmelCase__					:  Optional[int]					   =					chr(WIN_KEYMAP[cha]      )
     WIN_CH_BUFFER.append(chr(KEYMAP["""mod_int"""]      )      )
     WIN_CH_BUFFER.append(_lowerCAmelCase      )
     if ord(_lowerCAmelCase      ) 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      )      )
     UpperCAmelCase__					:  str					   =					chr(KEYMAP["""esc"""]      )
    except KeyError:
     UpperCAmelCase__					:  Any					   =					cha[1]
   else:
    UpperCAmelCase__					:  Dict					   =					ch.decode(_lowerCAmelCase      )
  else:
   UpperCAmelCase__					:  Union[str, Any]					   =					WIN_CH_BUFFER.pop(0      )
 elif os.name == "posix":
  import termios
  import tty

  UpperCAmelCase__					:  Optional[Any]					   =					sys.stdin.fileno()
  UpperCAmelCase__					:  Dict					   =					termios.tcgetattr(_lowerCAmelCase      )
  try:
   tty.setraw(_lowerCAmelCase      )
   UpperCAmelCase__					:  List[str]					   =					sys.stdin.read(1      )
  finally:
   termios.tcsetattr(_lowerCAmelCase							,    termios.TCSADRAIN							,    _lowerCAmelCase      )
 return ch




def   lowerCAmelCase						(					):
 '''simple docstring'''





 UpperCAmelCase__					:  Optional[int]					   =					get_raw_chars()
 if ord(_lowerCAmelCase      ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
  return char

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

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








"""simple docstring"""




def   lowerCAmelCase						(					__UpperCamelCase      ):
 '''simple docstring'''





 UpperCAmelCase__					:  str					   =					[]
 if len(__UpperCamelCase      ) == 1:
  return [nums.copy()]
 for _ in range(len(__UpperCamelCase      )      ):
  UpperCAmelCase__					:  Tuple					   =					nums.pop(0      )
  UpperCAmelCase__					:  List[str]					   =					permute(__UpperCamelCase      )
  for perm in permutations:
   perm.append(__UpperCamelCase      )
  result.extend(__UpperCamelCase      )
  nums.append(__UpperCamelCase      )
 return result
def   lowerCAmelCase						(					__UpperCamelCase      ):
 '''simple docstring'''





 def backtrack(__UpperCamelCase      ):
  if start == len(__UpperCamelCase      ) - 1:
   output.append(nums[:]      )
  else:
   for i in range(__UpperCamelCase							,    len(__UpperCamelCase      )      ):
    UpperCAmelCase__   ,      UpperCAmelCase__					:  Union[str, Any]					   =					nums[i], nums[start]
    backtrack(start + 1      )
    UpperCAmelCase__   ,      UpperCAmelCase__					:  Union[str, Any]					   =					nums[i], nums[start]  # backtrack

 UpperCAmelCase__					:  List[str]					   =					[]
 backtrack(0      )
 return output


if __name__ == "__main__":
      import doctest

      # use res to print the data in permute2 function
      __UpperCAmelCase =				permutea([1, 2, 3])
      print(res)
      doctest.testmod()





