


'''simple docstring'''
# using dfs for finding eulerian path traversal


def 			_lowercase       (				UpperCamelCase__       :					Union[str, Any],				UpperCamelCase__       :					Optional[Any],				UpperCamelCase__       :					Optional[Any],				UpperCamelCase__       :					Union[str, Any]=None			):
 __A  :		List[str]       =			(path or []) + [u]
 for v in graph[u]:
  if visited_edge[u][v] is False:
   __A     ,__A  :		Dict       =			True, True
   __A  :		Dict       =			dfs(UpperCamelCase__,				UpperCamelCase__,				UpperCamelCase__,				UpperCamelCase__			)
 return path


def 			_lowercase       (				UpperCamelCase__       :					Optional[int],				UpperCamelCase__       :					List[str]			):
 __A  :		List[Any]       =			0
 __A  :		str       =			-1
 for i in range(UpperCamelCase__			):
  if i not in graph.keys():
   continue
  if len(graph[i]			) % 2 == 1:
   odd_degree_nodes += 1
   __A  :		Union[str, Any]       =			i
 if odd_degree_nodes == 0:
  return 1, odd_node
 if odd_degree_nodes == 2:
  return 2, odd_node
 return 3, odd_node


def 			_lowercase       (				UpperCamelCase__       :					List[str],				UpperCamelCase__       :					Dict			):
 __A  :		Dict       =			[[False for _ in range(max_node + 1			)] for _ in range(max_node + 1			)]
 __A     ,__A  :		int       =			check_circuit_or_path(UpperCamelCase__,				UpperCamelCase__			)
 if check == 3:
  print('graph is not Eulerian'			)
  print('no path'			)
  return
 __A  :		str       =			1
 if check == 2:
  __A  :		Dict       =			odd_node
  print('graph has a Euler path'			)
 if check == 1:
  print('graph has a Euler cycle'			)
 __A  :		Any       =			dfs(UpperCamelCase__,				UpperCamelCase__,				UpperCamelCase__			)
 print(UpperCamelCase__			)


def 			_lowercase       (				):
 __A  :		Union[str, Any]       =			{1: [2, 3, 4], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [4]}
 __A  :		Tuple       =			{1: [2, 3, 4, 5], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [1, 4]}
 __A  :		List[str]       =			{1: [2, 3, 4], 2: [1, 3, 4], 3: [1, 2], 4: [1, 2, 5], 5: [4]}
 __A  :		Optional[int]       =			{1: [2, 3], 2: [1, 3], 3: [1, 2]}
 __A  :		Any       =			{
     1: [],
     2: []
     # all degree is zero
 }
 __A  :		Optional[int]       =			10
 check_euler(UpperCamelCase__,				UpperCamelCase__			)
 check_euler(UpperCamelCase__,				UpperCamelCase__			)
 check_euler(UpperCamelCase__,				UpperCamelCase__			)
 check_euler(UpperCamelCase__,				UpperCamelCase__			)
 check_euler(UpperCamelCase__,				UpperCamelCase__			)


if __name__ == "__main__":
 main()










'''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() = }''')






