





"""simple docstring"""






from __future__ import annotations

from collections.abc import Iterable, Iterator
from dataclasses import dataclass

A 			=  (3, 9, -11, 0, 7, 5, 1, -1)
A 			=  (4, 6, 2, 0, 8, 10, 3, -2)




@dataclass
class 				__lowercase			:







					'''simple docstring'''




					__lowerCAmelCase  =  42
					__lowerCAmelCase  =  42






class 				__lowercase			:







					'''simple docstring'''




					def __init__(						self	,			_UpperCAmelCase     ):
									__a :						Node | None			       =  None
									for i in sorted(_UpperCAmelCase	,			reverse=_UpperCAmelCase     ):
													__a :						Union[str, Any]			       =  Node(_UpperCAmelCase	,			self.head     )







					def __iter__(						self     ):
									__a :						Union[str, Any]			       =  self.head
									while node:
													yield node.data
													__a :						List[Any]			       =  node.next_node







					def __len__(						self     ):
									return sum(1 for _ in self     )







					def __str__(						self     ):
									return " -> ".join([str(_UpperCAmelCase     ) for node in self]     )






def     __A      (			a_						:SortedLinkedList   ,       a_						:SortedLinkedList)		->		SortedLinkedList:
				return SortedLinkedList(list(a_) + list(a_))


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		A 			=  SortedLinkedList
		print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))






"""simple docstring"""






from __future__ import annotations

import typing
from collections import Counter

def     __A      (			a_						:int)		->		typing.Counter[int]:
				__a :						typing.Counter[int]			       =  Counter()
				for base in range(1   ,       max_perimeter + 1):
								for perpendicular in range(a_   ,       max_perimeter + 1):
												__a :						Any			       =  (base * base + perpendicular * perpendicular) ** 0.5
												if hypotenuse == int(a_):
																__a :						List[Any]			       =  int(base + perpendicular + hypotenuse)
																if perimeter > max_perimeter:
																				continue
																triplets[perimeter] += 1
				return triplets

def     __A      (			a_						:int = 10_00)		->		int:
				__a :						Dict			       =  pythagorean_triple(a_)
				return triplets.most_common(1)[0][0]


if __name__ == "__main__":
		print(F'Perimeter {solution()} has maximum solutions')