





from __future__ import annotations



def     _lowerCAmelCase		(  _lowerCAmelCase  ,_lowerCAmelCase = None  ,_lowerCAmelCase = None  ,_lowerCAmelCase = False  ,):
   '''simple docstring'''


   A_     :				str			      =	cipher_alphabet or [chr(_lowerCAmelCase     ) for i in range(9_7  ,1_2_3     )]

   # If the argument is None or the user provided an empty dictionary
   if not frequencies_dict:
      # Frequencies of letters in the english language (how much they show up)
      A_     :				Dict			      =	{
          """a""": 0.0_8497,
          """b""": 0.0_1492,
          """c""": 0.0_2202,
          """d""": 0.0_4253,
          """e""": 0.1_1162,
          """f""": 0.0_2228,
          """g""": 0.0_2015,
          """h""": 0.0_6094,
          """i""": 0.0_7546,
          """j""": 0.0_0153,
          """k""": 0.0_1292,
          """l""": 0.0_4025,
          """m""": 0.0_2406,
          """n""": 0.0_6749,
          """o""": 0.0_7507,
          """p""": 0.0_1929,
          """q""": 0.0_0095,
          """r""": 0.0_7587,
          """s""": 0.0_6327,
          """t""": 0.0_9356,
          """u""": 0.0_2758,
          """v""": 0.0_0978,
          """w""": 0.0_2560,
          """x""": 0.0_0150,
          """y""": 0.0_1994,
          """z""": 0.0_0077,
      }
   else:
      # Custom frequencies dictionary
      A_     :				Optional[int]			      =	frequencies_dict

   if not case_sensitive:
      A_     :				str			      =	ciphertext.lower()

   # Chi squared statistic values
   A_     :				dict[int, tuple[float, str]]			      =	{}

   # cycle through all of the shifts
   for shift in range(len(_lowerCAmelCase     )     ):
      A_     :				List[Any]			      =	""""""

      # decrypt the message with the shift
      for letter in ciphertext:
         try:
            # Try to index the letter in the alphabet
            A_     :				List[str]			      =	(alphabet_letters.index(letter.lower()     ) - shift) % len(
                _lowerCAmelCase     )
            decrypted_with_shift += (
                alphabet_letters[new_key].upper()
                if case_sensitive and letter.isupper()
                else alphabet_letters[new_key]
            )
         except ValueError:
            # Append the character if it isn't in the alphabet
            decrypted_with_shift += letter

      A_     :				Dict			      =	0.0

      # Loop through each letter in the decoded message with the shift
      for letter in decrypted_with_shift:
         if case_sensitive:
            A_     :				Union[str, Any]			      =	letter.lower()
            if letter in frequencies:
               # Get the amount of times the letter occurs in the message
               A_     :				Union[str, Any]			      =	decrypted_with_shift.lower().count(_lowerCAmelCase     )

               # Get the excepcted amount of times the letter should appear based
               # on letter frequencies
               A_     :				List[Any]			      =	frequencies[letter] * occurrences

               # Complete the chi squared statistic formula
               A_     :				Tuple			      =	((occurrences - expected) ** 2) / expected

               # Add the margin of error to the total chi squared statistic
               chi_squared_statistic += chi_letter_value
         else:
            if letter.lower() in frequencies:
               # Get the amount of times the letter occurs in the message
               A_     :				Optional[Any]			      =	decrypted_with_shift.count(_lowerCAmelCase     )

               # Get the excepcted amount of times the letter should appear based
               # on letter frequencies
               A_     :				Any			      =	frequencies[letter] * occurrences

               # Complete the chi squared statistic formula
               A_     :				Optional[Any]			      =	((occurrences - expected) ** 2) / expected

               # Add the margin of error to the total chi squared statistic
               chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
      A_     :				Union[str, Any]			      =	(
          chi_squared_statistic,
          decrypted_with_shift,
      )

   # Get the most likely cipher by finding the cipher with the smallest chi squared
   # statistic
   def chi_squared_statistic_values_sorting_key(_lowerCAmelCase     ) -> tuple[float, str]:
      return chi_squared_statistic_values[key]

   A_     :				int			      =	min(
       _lowerCAmelCase  ,key=_lowerCAmelCase  ,)

   # Get all the data from the most likely cipher (key, decoded message)
   (
       (
       A_
   )      ,				(
       A_
   )      ,				
   )     :				Union[str, Any]			      =	chi_squared_statistic_values[most_likely_cipher]

   # Return the data on the most likely shift
   return (
       most_likely_cipher,
       most_likely_cipher_chi_squared_value,
       decoded_most_likely_cipher,
   )













import re



def     _lowerCAmelCase		(  _lowerCAmelCase     ):
   '''simple docstring'''


   A_     :				Any			      =	re.compile(r"""^(\+91[\-\s]?)?[0]?(91)?[789]\d{9}$"""     )
   if match := re.search(_lowerCAmelCase  ,_lowerCAmelCase     ):
      return match.string == phone
   return False


if __name__ == "__main__":
      print(indian_phone_validator("""+918827897895"""))






