
"""simple docstring"""






from __future__ import annotations

from typing import Generic, TypeVar

_lowercase							 =							TypeVar('''T''')

class 				__a    (   Generic[T]					):



							'''simple docstring'''







							def __init__(    self     ,						_lowerCamelCase					) ->       List[Any]:




										'''simple docstring'''
										__lowercase						      =					data  # Assign data
										__lowercase						      =					None  # Initialize next as null
										__lowercase						      =					None  # Initialize prev as null





class 				__a    (   Generic[T]					):



							'''simple docstring'''







							def __init__(    self					) ->       None:




										'''simple docstring'''
										__lowercase						      =					None
							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase					) ->       None:




										'''simple docstring'''
										if self.head is None:
													__lowercase						      =					Node(_lowerCamelCase					)
										else:
													__lowercase						      =					Node(_lowerCamelCase					)
													__lowercase						      =					new_node
													__lowercase						      =					self.head
													__lowercase						      =					None
													__lowercase						      =					new_node
							def      SCREAMING_SNAKE_CASE	(    self					) ->       T | None:




										'''simple docstring'''
										if self.head is None:
													return None
										else:
													assert self.head is not None
													__lowercase						      =					self.head.data
													__lowercase						      =					self.head.next
													if self.head is not None:
																__lowercase						      =					None
													return temp
							def      SCREAMING_SNAKE_CASE	(    self					) ->       T | None:




										'''simple docstring'''
										return self.head.data if self.head is not None else None
							def __len__(    self					) ->       int:




										'''simple docstring'''
										__lowercase						      =					self.head
										__lowercase						      =					0
										while temp is not None:
													count += 1
													__lowercase						      =					temp.next
										return count
							def      SCREAMING_SNAKE_CASE	(    self					) ->       bool:




										'''simple docstring'''
										return self.head is None





							def      SCREAMING_SNAKE_CASE	(    self					) ->       None:




										'''simple docstring'''
										print("stack elements are:"					)
										__lowercase						      =					self.head
										while temp is not None:
													print(temp.data     ,						end="->"					)
													__lowercase						      =					temp.next


# Code execution starts here
if __name__ == "__main__":
					# Start with the empty stack
					_lowercase							 =							Stack()

					# Insert 4 at the beginning. So stack becomes 4->None
					print('''Stack operations using Doubly LinkedList''')
					stack.push(4)

					# Insert 5 at the beginning. So stack becomes 4->5->None
					stack.push(5)

					# Insert 6 at the beginning. So stack becomes 4->5->6->None
					stack.push(6)

					# Insert 7 at the beginning. So stack becomes 4->5->6->7->None
					stack.push(7)

					# Print the stack
					stack.print_stack()

					# Print the top element
					print('''\nTop element is ''', stack.top())

					# Print the stack size
					print('''Size of the stack is ''', len(stack))

					# pop the top element
					stack.pop()

					# pop the top element
					stack.pop()

					# two elements have now been popped off
					stack.print_stack()

					# Print True if the stack is empty else False
					print('''\nstack is empty:''', stack.is_empty())







"""simple docstring"""






import os



def     lowerCAmelCase__ (		)	->Tuple:
			__lowercase						      =					0
			__lowercase						      =					0
			with open(os.path.dirname(__magic_name__			) + "/p022_names.txt"			) as file:
						__lowercase						      =					str(file.readlines()[0]			)
						__lowercase						      =					name.replace("\"" ,      ""			).split(","			)

			name.sort()
			for i in range(len(__magic_name__			)			):
						for j in name[i]:
									temp_sum += ord(__magic_name__			) - ord("A"			) + 1
						total_sum += (i + 1) * temp_sum
						__lowercase						      =					0
			return total_sum


if __name__ == "__main__":
					print(solution())





