





'''simple docstring'''


import itertools
import string
from collections.abc import Generator, Iterable







def  _lowerCamelCase	(__lowerCamelCase	:  Iterable[str]       ,	__lowerCamelCase	:  int  ) ->     Union[str, Any]:
			a__	 =			iter(_UpperCamelCase  )
			while True:
						a__	 =			tuple(itertools.islice(_UpperCamelCase       ,	_UpperCamelCase  )  )
						if not chunk:
									return
						yield chunk







def  _lowerCamelCase	(__lowerCamelCase	:  str  ) ->     Dict:
			a__	 =			"".join([c.upper() for c in dirty if c in string.ascii_letters]  )
			a__	 =			""

			if len(_UpperCamelCase  ) < 2:
						return dirty

			for i in range(len(_UpperCamelCase  ) - 1  ):
						clean += dirty[i]

						if dirty[i] == dirty[i + 1]:
									clean += "X"

			clean += dirty[-1]

			if len(_UpperCamelCase  ) & 1:
						clean += "X"

			return clean







def  _lowerCamelCase	(__lowerCamelCase	:  str  ) ->     Optional[int]:
			# I and J are used interchangeably to allow
			# us to use a 5x5 table (25 letters)
			a__	 =			"ABCDEFGHIKLMNOPQRSTUVWXYZ"
			# we're using a list instead of a '2d' array because it makes the math
			# for setting up the table and doing the actual encoding/decoding simpler
			a__	 =			[]

			# copy key chars into the table if they are in `alphabet` ignoring duplicates
			for char in key.upper():
						if char not in table and char in alphabet:
									table.append(_UpperCamelCase  )

    # fill the rest of the table in with the remaining alphabet chars
			for char in alphabet:
						if char not in table:
									table.append(_UpperCamelCase  )

			return table







def  _lowerCamelCase	(__lowerCamelCase	:  str       ,	__lowerCamelCase	:  str  ) ->     int:
			a__	 =			generate_table(_UpperCamelCase  )
			a__	 =			prepare_input(_UpperCamelCase  )
			a__	 =			""

			# https://en.wikipedia.org/wiki/Playfair_cipher#Description
			for chara, chara in chunker(_UpperCamelCase       ,	2  ):
						a__ ,					a__	 =			divmod(table.index(_UpperCamelCase  )       ,	5  )
						a__ ,					a__	 =			divmod(table.index(_UpperCamelCase  )       ,	5  )

						if rowa == rowa:
									ciphertext += table[rowa * 5 + (cola + 1) % 5]
									ciphertext += table[rowa * 5 + (cola + 1) % 5]
						elif cola == cola:
									ciphertext += table[((rowa + 1) % 5) * 5 + cola]
									ciphertext += table[((rowa + 1) % 5) * 5 + cola]
						else:  # rectangle
									ciphertext += table[rowa * 5 + cola]
									ciphertext += table[rowa * 5 + cola]

			return ciphertext







def  _lowerCamelCase	(__lowerCamelCase	:  str       ,	__lowerCamelCase	:  str  ) ->     Optional[Any]:
			a__	 =			generate_table(_UpperCamelCase  )
			a__	 =			""

			# https://en.wikipedia.org/wiki/Playfair_cipher#Description
			for chara, chara in chunker(_UpperCamelCase       ,	2  ):
						a__ ,					a__	 =			divmod(table.index(_UpperCamelCase  )       ,	5  )
						a__ ,					a__	 =			divmod(table.index(_UpperCamelCase  )       ,	5  )

						if rowa == rowa:
									plaintext += table[rowa * 5 + (cola - 1) % 5]
									plaintext += table[rowa * 5 + (cola - 1) % 5]
						elif cola == cola:
									plaintext += table[((rowa - 1) % 5) * 5 + cola]
									plaintext += table[((rowa - 1) % 5) * 5 + cola]
						else:  # rectangle
									plaintext += table[rowa * 5 + cola]
									plaintext += table[rowa * 5 + cola]

			return plaintext








from __future__ import annotations





def 		a__      (		_UpperCamelCase      :			list[float]				):
   if len(_UpperCamelCase				) < 2:
      raise ValueError('''Monogons and Digons are not polygons in the Euclidean space'''				)
   if any(i <= 0 for i in nums				):
      raise ValueError('''All values must be greater than 0'''				)
   __lowerCamelCase    				=     nums.copy()
   copy_nums.sort()
   return copy_nums[-1] < sum(copy_nums[:-1]				)


if __name__ == "__main__":
  import doctest

  doctest.testmod()






