

'''simple docstring'''






from __future__ import annotations


def 		_A     (    A__     ,				A__ = None     ,				A__ = None     ,				A__ = False     ,				):






 """simple docstring"""



 __lowercase							  = cipher_alphabet or [chr(A__      ) for i in range(97     ,				123      )]

 # 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)
  __lowercase							  = {
      '''a''': 0.0_8_4_9_7,
      '''b''': 0.0_1_4_9_2,
      '''c''': 0.0_2_2_0_2,
      '''d''': 0.0_4_2_5_3,
      '''e''': 0.1_1_1_6_2,
      '''f''': 0.0_2_2_2_8,
      '''g''': 0.0_2_0_1_5,
      '''h''': 0.0_6_0_9_4,
      '''i''': 0.0_7_5_4_6,
      '''j''': 0.0_0_1_5_3,
      '''k''': 0.0_1_2_9_2,
      '''l''': 0.0_4_0_2_5,
      '''m''': 0.0_2_4_0_6,
      '''n''': 0.0_6_7_4_9,
      '''o''': 0.0_7_5_0_7,
      '''p''': 0.0_1_9_2_9,
      '''q''': 0.0_0_0_9_5,
      '''r''': 0.0_7_5_8_7,
      '''s''': 0.0_6_3_2_7,
      '''t''': 0.0_9_3_5_6,
      '''u''': 0.0_2_7_5_8,
      '''v''': 0.0_0_9_7_8,
      '''w''': 0.0_2_5_6_0,
      '''x''': 0.0_0_1_5_0,
      '''y''': 0.0_1_9_9_4,
      '''z''': 0.0_0_0_7_7,
  }
 else:
  # Custom frequencies dictionary
  __lowercase							  = frequencies_dict

 if not case_sensitive:
  __lowercase							  = ciphertext.lower()

 # Chi squared statistic values
 __lowercase							  = {}

 # cycle through all of the shifts
 for shift in range(len(A__      )      ):
  __lowercase							  = ''''''

  # decrypt the message with the shift
  for letter in ciphertext:
   try:
    # Try to index the letter in the alphabet
    __lowercase							  = (alphabet_letters.index(letter.lower()      ) - shift) % len(
        A__      )
    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

  __lowercase							  = 0.0

  # Loop through each letter in the decoded message with the shift
  for letter in decrypted_with_shift:
   if case_sensitive:
    __lowercase							  = letter.lower()
    if letter in frequencies:
     # Get the amount of times the letter occurs in the message
     __lowercase							  = decrypted_with_shift.lower().count(A__      )

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

     # Complete the chi squared statistic formula
     __lowercase							  = ((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
     __lowercase							  = decrypted_with_shift.count(A__      )

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

     # Complete the chi squared statistic formula
     __lowercase							  = ((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
  __lowercase							  = (
      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(A__      ) -> tuple[float, str]:
  return chi_squared_statistic_values[key]

 __lowercase							  = min(
     A__     ,				key=A__     ,				)

 # Get all the data from the most likely cipher (key, decoded message)
 (
     (
     __lowercase
 )  ,	(
     __lowercase
 )  ,	
 )							  = 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,
 )




'''simple docstring'''






from __future__ import annotations


def 		_A     (    A__      ):






 """simple docstring"""



 __lowercase							  = len(A__      )
 # We need to create solution object to save path.
 __lowercase							  = [[0 for _ in range(A__      )] for _ in range(A__      )]
 __lowercase							  = run_maze(A__     ,				0     ,				0     ,				A__      )
 if solved:
  print('''\n'''.join(str(A__      ) for row in solutions      )      )
 else:
  print('''No solution exists!'''      )
 return solved


def 		_A     (    A__     ,				A__     ,				A__     ,				A__      ):






 """simple docstring"""



 __lowercase							  = len(A__      )
 # Final check point.
 if i == j == (size - 1):
  __lowercase							  = 1
  return True

 __lowercase							  = (not i < 0) and (not j < 0)  # Check lower bounds
 __lowercase							  = (i < size) and (j < size)  # Check upper bounds

 if lower_flag and upper_flag:
  # check for already visited and block points.
  __lowercase							  = (not solutions[i][j]) and (not maze[i][j])
  if block_flag:
   # check visited
   __lowercase							  = 1

   # check for directions
   if (
       run_maze(A__     ,				i + 1     ,				A__     ,				A__      )
       or run_maze(A__     ,				A__     ,				j + 1     ,				A__      )
       or run_maze(A__     ,				i - 1     ,				A__     ,				A__      )
       or run_maze(A__     ,				A__     ,				j - 1     ,				A__      )
   ):
    return True

   __lowercase							  = 0
   return False
 return False


if __name__ == "__main__":
 import doctest

 doctest.testmod()

