




from __future__ import annotations

import typing
from collections import Counter





def 		snake_case_							(_a			:							int  ):
    UpperCAmelCase     =	Counter()
    for base in range(1					,     max_perimeter + 1  ):
        for perpendicular in range(_a					,     max_perimeter + 1  ):
            UpperCAmelCase     =	(base * base + perpendicular * perpendicular) ** 0.5
            if hypotenuse == int(_a  ):
                UpperCAmelCase     =	int(base + perpendicular + hypotenuse  )
                if perimeter > max_perimeter:
                    continue
                triplets[perimeter] += 1
    return triplets





def 		snake_case_							(_a			:							int = 1_0_0_0  ):
    UpperCAmelCase     =	pythagorean_triple(_a  )
    return triplets.most_common(1  )[0][0]


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










'''simple docstring'''







def 		snake_case_							(_a			:							list[list[int]]					,     _a			:							int					,     _a			:							int					,     _a			:							list[int]  ):

    # 1. Validate that path exists between current and next vertices
    if graph[path[curr_ind - 1]][next_ver] == 0:
        return False

    # 2. Validate that next vertex is not already in path
    return not any(vertex == next_ver for vertex in path  )





def 		snake_case_							(_a			:							list[list[int]]					,     _a			:							list[int]					,     _a			:							int  ):

    # Base Case
    if curr_ind == len(_a  ):
        # return whether path exists between current and starting vertices
        return graph[path[curr_ind - 1]][path[0]] == 1

    # Recursive Step
    for next_ver in range(0					,     len(_a  )  ):
        if valid_connection(_a					,     _a					,     _a					,     _a  ):
            # Insert current vertex  into path as next transition
            UpperCAmelCase     =	next_ver
            # Validate created path
            if util_hamilton_cycle(_a					,     _a					,     curr_ind + 1  ):
                return True
            # Backtrack
            UpperCAmelCase     =	-1
    return False







def 		snake_case_							(_a			:							list[list[int]]					,     _a			:							int = 0  ):
    UpperCAmelCase     =	[-1] * (len(_a  ) + 1)
    # initialize start and end of path with starting index
    UpperCAmelCase     =	UpperCAmelCase     =	start_index
    # evaluate and if we find answer return path either return empty array
    return path if util_hamilton_cycle(_a					,     _a					,     1  ) else []




