






'''simple docstring'''







import os
import string
import sys


_A	:			Optional[Any]         =1 << 8

_A	:			Union[str, 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,
}

_A	:			Optional[Any]         =KEYMAP['''up''']
_A	:			Optional[Any]         =KEYMAP['''left''']

if sys.platform == "win32":
			_A	:			List[str]         =[]
			_A	:			Union[str, 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):
			_A	:			List[str]         =ord(str(i))





def  SCREAMING_SNAKE_CASE_       ()      ->       int:
							if os.name == "nt":
														import msvcrt

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

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

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





def  SCREAMING_SNAKE_CASE_       ()      ->       Optional[int]:
							lowerCamelCase__					:	Dict         =       get_raw_chars()
							if ord(UpperCamelCase      ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
														return char

							elif ord(UpperCamelCase      ) == KEYMAP["esc"]:
														lowerCamelCase__					:	List[str]         =       get_raw_chars()
														if ord(UpperCamelCase      ) == KEYMAP["mod_int"]:
																					lowerCamelCase__					:	str         =       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"]






"""simple docstring"""
from collections import defaultdict
from math import ceil, sqrt

def       _snake_case						(						UpperCamelCase						:		int = 1000000			,		UpperCamelCase						:		int = 10						):
 UpperCAmelCase	:					defaultdict	=	defaultdict(UpperCamelCase						)

 for outer_width in range(3			,		(t_limit // 4) + 2						):
  if outer_width * outer_width > t_limit:
   UpperCAmelCase	:					str	=	max(
       ceil(sqrt(outer_width * outer_width - t_limit						)						)			,		1						)
  else:
   UpperCAmelCase	:					Optional[Any]	=	1

  hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

  for hole_width in range(UpperCamelCase			,		outer_width - 1			,		2						):
   count[outer_width * outer_width - hole_width * hole_width] += 1

 return sum(1 for n in count.values() if 1 <= n <= 10						)


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