"""simple docstring"""





import os
import string
import sys


_UpperCamelCase     :		str											=					1 << 8

_UpperCamelCase     :		List[Any]											=					{
    "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     :		Union[str, Any]											=					KEYMAP["up"]
_UpperCamelCase     :		List[str]											=					KEYMAP["left"]

if sys.platform == "win32":
       _UpperCamelCase     :		List[Any]											=					[]
       _UpperCamelCase     :		Optional[Any]											=					{
           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     :		Tuple											=					ord(str(i))





def        a_  (   ):





       '''simple docstring'''

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

              lowercase__    :	Optional[Any]     					=			'mbcs'
              # Flush the keyboard buffer
              while msvcrt.kbhit():
                     msvcrt.getch()
              if len(_lowerCAmelCase  ) == 0:
                     # Read the keystroke
                     lowercase__    :	Optional[int]     					=			msvcrt.getch()

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

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






def        a_  (   ):





       '''simple docstring'''

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

       elif ord(_lowerCAmelCase  ) == KEYMAP["esc"]:
              lowercase__    :	Any     					=			get_raw_chars()
              if ord(_lowerCAmelCase  ) == KEYMAP["mod_int"]:
                     lowercase__    :	Tuple     					=			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"""





import math





def        a_  (   _lowerCAmelCase						:				int = 100  ):





       '''simple docstring'''

       lowercase__    :	Union[str, Any]     					=			sum(i * i for i in range(1     ,				n + 1  )  )
       lowercase__    :	str     					=			int(math.pow(sum(range(1     ,				n + 1  )  )     ,				2  )  )
       return square_of_sum - sum_of_squares


if __name__ == "__main__":
       print(f'''{solution() = }''')

