


'''simple docstring'''
import importlib.metadata
import operator
import re
import sys
from typing import Optional

from packaging import version


UpperCAmelCase_ :     str								=      {
    "<": operator.lt,
    "<=": operator.le,
    "==": operator.eq,
    "!=": operator.ne,
    ">=": operator.ge,
    ">": operator.gt,
}


def 			_lowercase       (				UpperCamelCase__       :					Tuple,				UpperCamelCase__       :					Dict,				UpperCamelCase__       :					Tuple,				UpperCamelCase__       :					Optional[Any],				UpperCamelCase__       :					int,				UpperCamelCase__       :					Optional[Any]			):



 if got_ver is None or want_ver is None:
  raise ValueError(
      f"""Unable to compare versions for {requirement}: need={want_ver} found={got_ver}. This is unusual. Consider"""
      f""" reinstalling {pkg}."""			)
 if not ops[op](version.parse(_SCREAMING_SNAKE_CASE			),				version.parse(_SCREAMING_SNAKE_CASE			)			):
  raise ImportError(
      f"""{requirement} is required for a normal functioning of this module, but found {pkg}=={got_ver}.{hint}"""			)


def 			_lowercase       (				UpperCamelCase__       :					str,				UpperCamelCase__       :					Optional[str] = None			):
 __A  :		List[Any]       =			f"""\n{hint}""" if hint is not None else ''

 # non-versioned check
 if re.match(r'^[\w_\-\d]+$',				_SCREAMING_SNAKE_CASE			):
  __A     ,__A     ,__A  :		str       =			requirement, None, None
 else:
  __A  :		List[str]       =			re.findall(r'^([^!=<>\s]+)([\s!=<>]{1,2}.+)',				_SCREAMING_SNAKE_CASE			)
  if not match:
   raise ValueError(
       'requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23, but'
       f""" got {requirement}"""			)
  __A     ,__A  :		Optional[int]       =			match[0]
  __A  :		Union[str, Any]       =			want_full.split(','			)  # there could be multiple requirements
  __A  :		Optional[Any]       =			{}
  for w in want_range:
   __A  :		Optional[int]       =			re.findall(r'^([\s!=<>]{1,2})(.+)',				_SCREAMING_SNAKE_CASE			)
   if not match:
    raise ValueError(
        'requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23,'
        f""" but got {requirement}"""			)
   __A     ,__A  :		Optional[Any]       =			match[0]
   __A  :		Tuple       =			want_ver
   if op not in ops:
    raise ValueError(f"""{requirement}: need one of {list(ops.keys()			)}, but got {op}"""			)

    # special case
 if pkg == "python":
  __A  :		Dict       =			'.'.join([str(_SCREAMING_SNAKE_CASE			) for x in sys.version_info[:3]]			)
  for op, want_ver in wanted.items():
   _compare_versions(_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE			)
  return

 # check if any version is installed
 try:
  __A  :		str       =			importlib.metadata.version(_SCREAMING_SNAKE_CASE			)
 except importlib.metadata.PackageNotFoundError:
  raise importlib.metadata.PackageNotFoundError(
      f"""The \'{requirement}\' distribution was not found and is required by this application. {hint}"""			)

 # check that the right version is installed if version number or a range was provided
 if want_ver is not None:
  for op, want_ver in wanted.items():
   _compare_versions(_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE			)


def 			_lowercase       (				UpperCamelCase__       :					Optional[int]			):
 __A  :		Union[str, Any]       =			'Try: pip install transformers -U or pip install -e \'.[dev]\' if you\'re working with git main'
 return require_version(_SCREAMING_SNAKE_CASE,				_SCREAMING_SNAKE_CASE			)










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


def 			_lowercase       (				UpperCamelCase__       :					int = 1000000,				UpperCamelCase__       :					int = 10			):
 __A  :		defaultdict       =			defaultdict(UpperCamelCase__			)

 for outer_width in range(3,				(t_limit // 4) + 2			):
  if outer_width * outer_width > t_limit:
   __A  :		Optional[int]       =			max(
       ceil(sqrt(outer_width * outer_width - t_limit			)			),				1			)
  else:
   __A  :		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() = }''')






