
def        A__					(						lowerCamelCase = 1_00_00_00						)  ->	int:
				UpperCamelCase_:							Union[str, Any]	=						limit + 1
				UpperCamelCase_:							int	=						[0] * limit
				for first_term in range(1     ,    __snake_case						):
								for n in range(__snake_case     ,    __snake_case     ,    __snake_case						):
												UpperCamelCase_:							str	=						first_term + n / first_term
												if common_difference % 4:  # d must be divisble by 4
																continue
												else:
																common_difference /= 4
																if (
																    first_term > common_difference
																    and first_term < 4 * common_difference
																):  # since x,y,z are positive integers
																				frequency[n] += 1  # so z>0 and a>d ,also 4d<a

				UpperCamelCase_:							Optional[Any]	=						sum(1 for x in frequency[1:limit] if x == 10						)

				return count


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








class        _UpperCamelCase				:






			'''simple docstring'''

			def __init__(       self :       List[str]						,	snake_case_ :       int						,	snake_case_ :       Optional[Any]=None						,	snake_case_ :       List[str]=None      ):
							UpperCamelCase_:							List[Any]	=						data
							UpperCamelCase_:							List[Any]	=						previous
							UpperCamelCase_:							Tuple	=						next_node

			def __str__(       self :       Dict      ):
							return f'''{self.data}'''

			def       lowerCAmelCase__	(       self :       List[str]      ):
							return self.data

			def       lowerCAmelCase__	(       self :       Any      ):
							return self.next




			def       lowerCAmelCase__	(       self :       List[str]      ):
							return self.previous




class        _UpperCamelCase				:






			'''simple docstring'''

			def __init__(       self :       Optional[Any]						,	snake_case_ :       int      ):
							UpperCamelCase_:							Union[str, Any]	=						head

			def __iter__(       self :       Union[str, Any]      ):
							return self




			def       lowerCAmelCase__	(       self :       Union[str, Any]      ):
							if not self.current:
											raise StopIteration
							else:
											UpperCamelCase_:							Dict	=						self.current.get_data()
											UpperCamelCase_:							Tuple	=						self.current.get_next()
											return value




class        _UpperCamelCase				:






			'''simple docstring'''

			def __init__(       self :       int      ):
							UpperCamelCase_:							Optional[int]	=						None  # First node in list
							UpperCamelCase_:							Dict	=						None  # Last node in list

			def __str__(       self :       Tuple      ):
							UpperCamelCase_:							int	=						self.head
							UpperCamelCase_:							Tuple	=						[]
							while current is not None:
											nodes.append(current.get_data()      )
											UpperCamelCase_:							List[str]	=						current.get_next()
							return " ".join(str(snake_case_      ) for node in nodes      )

			def __contains__(       self :       int						,	snake_case_ :       int      ):
							UpperCamelCase_:							Optional[Any]	=						self.head
							while current:
											if current.get_data() == value:
															return True
											UpperCamelCase_:							Any	=						current.get_next()
							return False

			def __iter__(       self :       Any      ):
							return LinkedListIterator(self.head      )

			def       lowerCAmelCase__	(       self :       Tuple      ):
							if self.head:
											return self.head.get_data()
							return None

			def       lowerCAmelCase__	(       self :       Optional[Any]      ):
							if self.tail:
											return self.tail.get_data()
							return None

			def       lowerCAmelCase__	(       self :       Optional[int]						,	snake_case_ :       Node      ):
							if self.head is None:
											UpperCamelCase_:							Tuple	=						node
											UpperCamelCase_:							Optional[int]	=						node
							else:
											self.insert_before_node(self.head						,	snake_case_      )

			def       lowerCAmelCase__	(       self :       Optional[Any]						,	snake_case_ :       Node      ):
							if self.head is None:
											self.set_head(snake_case_      )
							else:
											self.insert_after_node(self.tail						,	snake_case_      )

			def       lowerCAmelCase__	(       self :       List[Any]						,	snake_case_ :       int      ):
							UpperCamelCase_:							Any	=						Node(snake_case_      )
							if self.head is None:
											self.set_head(snake_case_      )
							else:
											self.set_tail(snake_case_      )

			def       lowerCAmelCase__	(       self :       Optional[Any]						,	snake_case_ :       Node						,	snake_case_ :       Node      ):
							UpperCamelCase_:							str	=						node
							UpperCamelCase_:							int	=						node.previous

							if node.get_previous() is None:
											UpperCamelCase_:							int	=						node_to_insert
							else:
											UpperCamelCase_:							Dict	=						node_to_insert

							UpperCamelCase_:							int	=						node_to_insert

			def       lowerCAmelCase__	(       self :       Dict						,	snake_case_ :       Node						,	snake_case_ :       Node      ):
							UpperCamelCase_:							Tuple	=						node
							UpperCamelCase_:							Dict	=						node.next

							if node.get_next() is None:
											UpperCamelCase_:							Union[str, Any]	=						node_to_insert
							else:
											UpperCamelCase_:							str	=						node_to_insert

							UpperCamelCase_:							int	=						node_to_insert

			def       lowerCAmelCase__	(       self :       Tuple						,	snake_case_ :       int						,	snake_case_ :       int      ):
							UpperCamelCase_:							Union[str, Any]	=						1
							UpperCamelCase_:							List[str]	=						Node(snake_case_      )
							UpperCamelCase_:							Optional[Any]	=						self.head
							while node:
											if current_position == position:
															self.insert_before_node(snake_case_						,	snake_case_      )
															return
											current_position += 1
											UpperCamelCase_:							Dict	=						node.next
							self.insert_after_node(self.tail						,	snake_case_      )

			def       lowerCAmelCase__	(       self :       int						,	snake_case_ :       int      ):
							UpperCamelCase_:							Union[str, Any]	=						self.head
							while node:
											if node.get_data() == item:
															return node
											UpperCamelCase_:							List[Any]	=						node.get_next()
							raise Exception("""Node not found"""      )

			def       lowerCAmelCase__	(       self :       List[Any]						,	snake_case_ :       List[str]      ):
							if (node := self.get_node(snake_case_      )) is not None:
											if node == self.head:
															UpperCamelCase_:							Optional[int]	=						self.head.get_next()

											if node == self.tail:
															UpperCamelCase_:							Union[str, Any]	=						self.tail.get_previous()

											self.remove_node_pointers(snake_case_      )

			@staticmethod
			def       lowerCAmelCase__	(       snake_case_ :       Node      ):
							if node.get_next():
											UpperCamelCase_:							str	=						node.previous

							if node.get_previous():
											UpperCamelCase_:							int	=						node.next

							UpperCamelCase_:							List[str]	=						None
							UpperCamelCase_:							int	=						None




			def       lowerCAmelCase__	(       self :       str      ):
							return self.head is None







def        A__					(						)  ->	None:
				pass


if __name__ == "__main__":
							import doctest

							doctest.testmod()






