





# Author: OMKAR PATHAK, Nwachukwu Chidiebere

# Use a Python dictionary to construct the graph.
from __future__ import annotations

from pprint import pformat
from typing import Generic, TypeVar

UpperCAmelCase						:   Optional[int]			  =     TypeVar('''T''')





class 						_A(					Generic[T]   ):


				"""simple docstring"""


				def __init__(			self     ,					_A = True     ):
									__A	:						dict[T, list[T]]       =				{}  # dictionary of lists
									__A	:						str       =				directed



				def 					UpperCAmelCase_		(			self     ,					_A     ,					_A     ):

									if not self.directed:  # For undirected graphs
														# if both source vertex and destination vertex are both present in the
														# adjacency list, add destination vertex to source vertex list of adjacent
														# vertices and add source vertex to destination vertex list of adjacent
														# vertices.
														if source_vertex in self.adj_list and destination_vertex in self.adj_list:
																			self.adj_list[source_vertex].append(_A     )
																			self.adj_list[destination_vertex].append(_A     )
														# if only source vertex is present in adjacency list, add destination vertex
														# to source vertex list of adjacent vertices, then create a new vertex with
														# destination vertex as key and assign a list containing the source vertex
														# as it's first adjacent vertex.
														elif source_vertex in self.adj_list:
																			self.adj_list[source_vertex].append(_A     )
																			__A	:						Union[str, Any]       =				[source_vertex]
														# if only destination vertex is present in adjacency list, add source vertex
														# to destination vertex list of adjacent vertices, then create a new vertex
														# with source vertex as key and assign a list containing the source vertex
														# as it's first adjacent vertex.
														elif destination_vertex in self.adj_list:
																			self.adj_list[destination_vertex].append(_A     )
																			__A	:						Union[str, Any]       =				[destination_vertex]
														# if both source vertex and destination vertex are not present in adjacency
														# list, create a new vertex with source vertex as key and assign a list
														# containing the destination vertex as it's first adjacent vertex also
														# create a new vertex with destination vertex as key and assign a list
														# containing the source vertex as it's first adjacent vertex.
														else:
																			__A	:						Optional[Any]       =				[destination_vertex]
																			__A	:						str       =				[source_vertex]
									else:  # For directed graphs
														# if both source vertex and destination vertex are present in adjacency
														# list, add destination vertex to source vertex list of adjacent vertices.
														if source_vertex in self.adj_list and destination_vertex in self.adj_list:
																			self.adj_list[source_vertex].append(_A     )
														# if only source vertex is present in adjacency list, add destination
														# vertex to source vertex list of adjacent vertices and create a new vertex
														# with destination vertex as key, which has no adjacent vertex
														elif source_vertex in self.adj_list:
																			self.adj_list[source_vertex].append(_A     )
																			__A	:						List[str]       =				[]
														# if only destination vertex is present in adjacency list, create a new
														# vertex with source vertex as key and assign a list containing destination
														# vertex as first adjacent vertex
														elif destination_vertex in self.adj_list:
																			__A	:						str       =				[destination_vertex]
														# if both source vertex and destination vertex are not present in adjacency
														# list, create a new vertex with source vertex as key and a list containing
														# destination vertex as it's first adjacent vertex. Then create a new vertex
														# with destination vertex as key, which has no adjacent vertex
														else:
																			__A	:						Tuple       =				[destination_vertex]
																			__A	:						str       =				[]

									return self





				def __repr__(			self     ):
									return pformat(self.adj_list     )











def  _SCREAMING_SNAKE_CASE				(   a  )      ->      bool:
					return str(a  ) == str(a  )[::-1]







def  _SCREAMING_SNAKE_CASE				(   a  )      ->      int:
					return int(a  ) + int(str(a  )[::-1]  )







def  _SCREAMING_SNAKE_CASE				(   a = 1_00_00  )      ->      int:
					__A	:						int       =				[]
					for num in range(1					,						a  ):
										__A	:						List[str]       =				0
										__A	:						List[Any]       =				num
										while iterations < 50:
															__A	:						str       =				sum_reverse(a  )
															iterations += 1
															if is_palindrome(a  ):
																				break
										else:
															lychrel_nums.append(a  )
					return len(a  )


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




