






from __future__ import annotations

import unittest

from transformers import FunnelConfig, is_tf_available
from transformers.testing_utils import require_tf

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import (
        TFFunnelBaseModel,
        TFFunnelForMaskedLM,
        TFFunnelForMultipleChoice,
        TFFunnelForPreTraining,
        TFFunnelForQuestionAnswering,
        TFFunnelForSequenceClassification,
        TFFunnelForTokenClassification,
        TFFunnelModel,
    )







class     _lowercase				:


       """simple docstring"""




       def __init__(     self							:    Union[str, Any]      ,   __lowerCamelCase							:    Union[str, Any]      ,   __lowerCamelCase							:    List[Any]=13      ,   __lowerCamelCase							:    Any=7      ,   __lowerCamelCase							:    Tuple=True      ,   __lowerCamelCase							:    Tuple=True      ,   __lowerCamelCase							:    List[Any]=True      ,   __lowerCamelCase							:    List[str]=True      ,   __lowerCamelCase							:    int=99      ,   __lowerCamelCase							:    Any=[1, 1, 2]      ,   __lowerCamelCase							:    Union[str, Any]=1      ,   __lowerCamelCase							:    Optional[Any]=32      ,   __lowerCamelCase							:    Optional[int]=4      ,   __lowerCamelCase							:    List[Any]=8      ,   __lowerCamelCase							:    List[str]=37      ,   __lowerCamelCase							:    Optional[int]="gelu_new"      ,   __lowerCamelCase							:    Any=0.1      ,   __lowerCamelCase							:    Optional[Any]=0.1      ,   __lowerCamelCase							:    List[Any]=0.0      ,   __lowerCamelCase							:    List[str]=512      ,   __lowerCamelCase							:    List[Any]=3      ,   __lowerCamelCase							:    Any=0.0_2      ,   __lowerCamelCase							:    List[Any]=3      ,   __lowerCamelCase							:    Optional[Any]=4      ,   __lowerCamelCase							:    List[str]=None      ,   __lowerCamelCase							:    List[Any]=False      ,   ):


             '''simple docstring'''



             lowerCamelCase__	:       Any					=						parent
             lowerCamelCase__	:       List[Any]					=						batch_size
             lowerCamelCase__	:       Union[str, Any]					=						seq_length
             lowerCamelCase__	:       List[Any]					=						is_training
             lowerCamelCase__	:       List[Any]					=						use_input_mask
             lowerCamelCase__	:       Tuple					=						use_token_type_ids
             lowerCamelCase__	:       Any					=						use_labels
             lowerCamelCase__	:       str					=						vocab_size
             lowerCamelCase__	:       int					=						block_sizes
             lowerCamelCase__	:       Dict					=						num_decoder_layers
             lowerCamelCase__	:       Dict					=						d_model
             lowerCamelCase__	:       Tuple					=						n_head
             lowerCamelCase__	:       Tuple					=						d_head
             lowerCamelCase__	:       str					=						d_inner
             lowerCamelCase__	:       Dict					=						hidden_act
             lowerCamelCase__	:       List[Any]					=						hidden_dropout
             lowerCamelCase__	:       Union[str, Any]					=						attention_dropout
             lowerCamelCase__	:       int					=						activation_dropout
             lowerCamelCase__	:       Any					=						max_position_embeddings
             lowerCamelCase__	:       Any					=						type_vocab_size
             lowerCamelCase__	:       Optional[Any]					=						2
             lowerCamelCase__	:       Dict					=						num_labels
             lowerCamelCase__	:       str					=						num_choices
             lowerCamelCase__	:       int					=						scope
             lowerCamelCase__	:       List[Any]					=						initializer_std

             # Used in the tests to check the size of the first attention layer
             lowerCamelCase__	:       Optional[int]					=						n_head
             # Used in the tests to check the size of the first hidden state
             lowerCamelCase__	:       List[str]					=						self.d_model
             # Used in the tests to check the number of output hidden states/attentions
             lowerCamelCase__	:       List[Any]					=						sum(self.block_sizes ) + (0 if base else self.num_decoder_layers)
             # FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
             # the last hidden state of the first block (which is the first hidden state of the decoder).
             if not base:
                   lowerCamelCase__	:       int					=						self.num_hidden_layers + 2





       def 		lowerCAmelCase  (     self							:    Any ):


             '''simple docstring'''



             lowerCamelCase__	:       List[str]					=						ids_tensor([self.batch_size, self.seq_length]      ,   self.vocab_size )

             lowerCamelCase__	:       int					=						None
             if self.use_input_mask:
                   lowerCamelCase__	:       Union[str, Any]					=						random_attention_mask([self.batch_size, self.seq_length] )

             lowerCamelCase__	:       Any					=						None
             if self.use_token_type_ids:
                   lowerCamelCase__	:       Optional[int]					=						ids_tensor([self.batch_size, self.seq_length]      ,   self.type_vocab_size )

             lowerCamelCase__	:       Optional[Any]					=						None
             lowerCamelCase__	:       Union[str, Any]					=						None
             lowerCamelCase__	:       Optional[int]					=						None
             if self.use_labels:
                   lowerCamelCase__	:       Union[str, Any]					=						ids_tensor([self.batch_size]      ,   self.type_sequence_label_size )
                   lowerCamelCase__	:       Dict					=						ids_tensor([self.batch_size, self.seq_length]      ,   self.num_labels )
                   lowerCamelCase__	:       int					=						ids_tensor([self.batch_size]      ,   self.num_choices )

             lowerCamelCase__	:       List[Any]					=						FunnelConfig(
                 vocab_size=self.vocab_size      ,   block_sizes=self.block_sizes      ,   num_decoder_layers=self.num_decoder_layers      ,   d_model=self.d_model      ,   n_head=self.n_head      ,   d_head=self.d_head      ,   d_inner=self.d_inner      ,   hidden_act=self.hidden_act      ,   hidden_dropout=self.hidden_dropout      ,   attention_dropout=self.attention_dropout      ,   activation_dropout=self.activation_dropout      ,   max_position_embeddings=self.max_position_embeddings      ,   type_vocab_size=self.type_vocab_size      ,   initializer_std=self.initializer_std      ,   )

             return (
                 config,
                 input_ids,
                 token_type_ids,
                 input_mask,
                 sequence_labels,
                 token_labels,
                 choice_labels,
             )





       def 		lowerCAmelCase  (     self							:    Dict      ,   __lowerCamelCase							:    Optional[int]      ,   __lowerCamelCase							:    List[Any]      ,   __lowerCamelCase							:    int      ,   __lowerCamelCase							:    Optional[int]      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    List[Any]      ,   ):


             '''simple docstring'''



             lowerCamelCase__	:       Tuple					=						TFFunnelModel(config=_a )
             lowerCamelCase__	:       Tuple					=						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             lowerCamelCase__	:       int					=						model(_a )

             lowerCamelCase__	:       Tuple					=						[input_ids, input_mask]
             lowerCamelCase__	:       Dict					=						model(_a )

             lowerCamelCase__	:       Optional[int]					=						model(_a )
             self.parent.assertEqual(result.last_hidden_state.shape      ,   (self.batch_size, self.seq_length, self.d_model) )

             lowerCamelCase__	:       Optional[Any]					=						False
             lowerCamelCase__	:       Tuple					=						TFFunnelModel(config=_a )
             lowerCamelCase__	:       Union[str, Any]					=						model(_a )
             self.parent.assertEqual(result.last_hidden_state.shape      ,   (self.batch_size, self.seq_length, self.d_model) )

             lowerCamelCase__	:       int					=						False
             lowerCamelCase__	:       List[Any]					=						TFFunnelModel(config=_a )
             lowerCamelCase__	:       Optional[int]					=						model(_a )
             self.parent.assertEqual(result.last_hidden_state.shape      ,   (self.batch_size, self.seq_length, self.d_model) )





       def 		lowerCAmelCase  (     self							:    int      ,   __lowerCamelCase							:    Any      ,   __lowerCamelCase							:    Any      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    Tuple      ,   __lowerCamelCase							:    Optional[Any]      ,   __lowerCamelCase							:    Optional[Any]      ,   __lowerCamelCase							:    Optional[Any]      ,   ):


             '''simple docstring'''



             lowerCamelCase__	:       Dict					=						TFFunnelBaseModel(config=_a )
             lowerCamelCase__	:       Optional[int]					=						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             lowerCamelCase__	:       List[Any]					=						model(_a )

             lowerCamelCase__	:       int					=						[input_ids, input_mask]
             lowerCamelCase__	:       Any					=						model(_a )

             lowerCamelCase__	:       List[str]					=						model(_a )
             self.parent.assertEqual(result.last_hidden_state.shape      ,   (self.batch_size, 2, self.d_model) )

             lowerCamelCase__	:       Dict					=						False
             lowerCamelCase__	:       Union[str, Any]					=						TFFunnelBaseModel(config=_a )
             lowerCamelCase__	:       Optional[Any]					=						model(_a )
             self.parent.assertEqual(result.last_hidden_state.shape      ,   (self.batch_size, 3, self.d_model) )

             lowerCamelCase__	:       List[Any]					=						False
             lowerCamelCase__	:       Any					=						TFFunnelBaseModel(config=_a )
             lowerCamelCase__	:       Union[str, Any]					=						model(_a )
             self.parent.assertEqual(result.last_hidden_state.shape      ,   (self.batch_size, 2, self.d_model) )





       def 		lowerCAmelCase  (     self							:    Tuple      ,   __lowerCamelCase							:    Optional[Any]      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    Optional[Any]      ,   __lowerCamelCase							:    List[Any]      ,   __lowerCamelCase							:    Optional[int]      ,   __lowerCamelCase							:    List[str]      ,   ):


             '''simple docstring'''



             lowerCamelCase__	:       int					=						TFFunnelForPreTraining(config=_a )
             lowerCamelCase__	:       List[Any]					=						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             lowerCamelCase__	:       Optional[int]					=						model(_a )
             self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length) )





       def 		lowerCAmelCase  (     self							:    str      ,   __lowerCamelCase							:    int      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    Optional[int]      ,   __lowerCamelCase							:    Optional[Any]      ,   __lowerCamelCase							:    Union[str, Any]      ,   ):


             '''simple docstring'''



             lowerCamelCase__	:       Optional[Any]					=						TFFunnelForMaskedLM(config=_a )
             lowerCamelCase__	:       Optional[int]					=						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             lowerCamelCase__	:       int					=						model(_a )
             self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.vocab_size) )





       def 		lowerCAmelCase  (     self							:    List[Any]      ,   __lowerCamelCase							:    Tuple      ,   __lowerCamelCase							:    str      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    Optional[Any]      ,   __lowerCamelCase							:    int      ,   __lowerCamelCase							:    Optional[int]      ,   __lowerCamelCase							:    Tuple      ,   ):


             '''simple docstring'''



             lowerCamelCase__	:       Union[str, Any]					=						self.num_labels
             lowerCamelCase__	:       Any					=						TFFunnelForSequenceClassification(config=_a )
             lowerCamelCase__	:       List[str]					=						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             lowerCamelCase__	:       List[str]					=						model(_a )
             self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.num_labels) )





       def 		lowerCAmelCase  (     self							:    Tuple      ,   __lowerCamelCase							:    Optional[Any]      ,   __lowerCamelCase							:    Optional[Any]      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    Tuple      ,   __lowerCamelCase							:    Tuple      ,   __lowerCamelCase							:    List[str]      ,   __lowerCamelCase							:    Any      ,   ):


             '''simple docstring'''



             lowerCamelCase__	:       Union[str, Any]					=						self.num_choices
             lowerCamelCase__	:       Union[str, Any]					=						TFFunnelForMultipleChoice(config=_a )
             lowerCamelCase__	:       Union[str, Any]					=						tf.tile(tf.expand_dims(_a      ,   1 )      ,   (1, self.num_choices, 1) )
             lowerCamelCase__	:       int					=						tf.tile(tf.expand_dims(_a      ,   1 )      ,   (1, self.num_choices, 1) )
             lowerCamelCase__	:       List[Any]					=						tf.tile(tf.expand_dims(_a      ,   1 )      ,   (1, self.num_choices, 1) )
             lowerCamelCase__	:       Tuple					=						{
                 """input_ids""": multiple_choice_inputs_ids,
                 """attention_mask""": multiple_choice_input_mask,
                 """token_type_ids""": multiple_choice_token_type_ids,
             }
             lowerCamelCase__	:       Tuple					=						model(_a )
             self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.num_choices) )





       def 		lowerCAmelCase  (     self							:    Tuple      ,   __lowerCamelCase							:    Dict      ,   __lowerCamelCase							:    Optional[int]      ,   __lowerCamelCase							:    str      ,   __lowerCamelCase							:    List[Any]      ,   __lowerCamelCase							:    Optional[int]      ,   __lowerCamelCase							:    Tuple      ,   __lowerCamelCase							:    Tuple      ,   ):


             '''simple docstring'''



             lowerCamelCase__	:       Tuple					=						self.num_labels
             lowerCamelCase__	:       Union[str, Any]					=						TFFunnelForTokenClassification(config=_a )
             lowerCamelCase__	:       str					=						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             lowerCamelCase__	:       int					=						model(_a )
             self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.num_labels) )





       def 		lowerCAmelCase  (     self							:    Any      ,   __lowerCamelCase							:    Optional[Any]      ,   __lowerCamelCase							:    int      ,   __lowerCamelCase							:    Union[str, Any]      ,   __lowerCamelCase							:    Dict      ,   __lowerCamelCase							:    Tuple      ,   __lowerCamelCase							:    Union[str, Any]      ,   __lowerCamelCase							:    Tuple      ,   ):


             '''simple docstring'''



             lowerCamelCase__	:       Optional[Any]					=						TFFunnelForQuestionAnswering(config=_a )
             lowerCamelCase__	:       Optional[int]					=						{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             lowerCamelCase__	:       List[Any]					=						model(_a )
             self.parent.assertEqual(result.start_logits.shape      ,   (self.batch_size, self.seq_length) )
             self.parent.assertEqual(result.end_logits.shape      ,   (self.batch_size, self.seq_length) )





       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       Any					=						self.prepare_config_and_inputs()
             (
                 lowerCamelCase__					
             )	:       List[str]					=						config_and_inputs
             lowerCamelCase__	:       str					=						{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
             return config, inputs_dict







@require_tf
class     _lowercase				(							__SCREAMING_SNAKE_CASE							,						__SCREAMING_SNAKE_CASE							,						unittest.TestCase):


       """simple docstring"""




       A__      		=    (
           (
               TFFunnelModel,
               TFFunnelForMaskedLM,
               TFFunnelForPreTraining,
               TFFunnelForQuestionAnswering,
               TFFunnelForTokenClassification,
           )
           if is_tf_available()
           else ()
       )
       A__      		=    (
           {
               "feature-extraction": (TFFunnelBaseModel, TFFunnelModel),
               "fill-mask": TFFunnelForMaskedLM,
               "question-answering": TFFunnelForQuestionAnswering,
               "text-classification": TFFunnelForSequenceClassification,
               "token-classification": TFFunnelForTokenClassification,
               "zero-shot": TFFunnelForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       A__      		=    False
       A__      		=    False





       def 		lowerCAmelCase  (     self							:    Any ):


             '''simple docstring'''



             lowerCamelCase__	:       int					=						TFFunnelModelTester(self )
             lowerCamelCase__	:       List[Any]					=						ConfigTester(self      ,   config_class=_a )





       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             self.config_tester.run_common_tests()





       def 		lowerCAmelCase  (     self							:    int ):


             '''simple docstring'''



             lowerCamelCase__	:       Tuple					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*_a )





       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       str					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_pretraining(*_a )





       def 		lowerCAmelCase  (     self							:    List[str] ):


             '''simple docstring'''



             lowerCamelCase__	:       Any					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_lm(*_a )





       def 		lowerCAmelCase  (     self							:    List[str] ):


             '''simple docstring'''



             lowerCamelCase__	:       int					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_token_classification(*_a )





       def 		lowerCAmelCase  (     self							:    int ):


             '''simple docstring'''



             lowerCamelCase__	:       List[str]					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_question_answering(*_a )







@require_tf
class     _lowercase				(							__SCREAMING_SNAKE_CASE							,						unittest.TestCase):


       """simple docstring"""




       A__      		=    (
           (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
       )
       A__      		=    False
       A__      		=    False





       def 		lowerCAmelCase  (     self							:    List[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       Dict					=						TFFunnelModelTester(self      ,   base=_a )
             lowerCamelCase__	:       List[Any]					=						ConfigTester(self      ,   config_class=_a )





       def 		lowerCAmelCase  (     self							:    str ):


             '''simple docstring'''



             self.config_tester.run_common_tests()





       def 		lowerCAmelCase  (     self							:    Tuple ):


             '''simple docstring'''



             lowerCamelCase__	:       Dict					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_base_model(*_a )





       def 		lowerCAmelCase  (     self							:    List[str] ):


             '''simple docstring'''



             lowerCamelCase__	:       List[Any]					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_sequence_classification(*_a )





       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       int					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_multiple_choice(*_a )






from __future__ import annotations

def    lowercase_	(	_A    :					str					,      _A    :					list[str] | None = None					,      _A    :					dict[str, float] | None = None					,      _A    :					bool = False					,      ):

      """simple docstring"""




      lowerCamelCase__	:       Tuple					=						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)
            lowerCamelCase__	:       Dict					=						{
                "a": 0.08_497,
                "b": 0.01_492,
                "c": 0.02_202,
                "d": 0.04_253,
                "e": 0.11_162,
                "f": 0.02_228,
                "g": 0.02_015,
                "h": 0.06_094,
                "i": 0.07_546,
                "j": 0.00_153,
                "k": 0.01_292,
                "l": 0.04_025,
                "m": 0.02_406,
                "n": 0.06_749,
                "o": 0.07_507,
                "p": 0.01_929,
                "q": 0.00_095,
                "r": 0.07_587,
                "s": 0.06_327,
                "t": 0.09_356,
                "u": 0.02_758,
                "v": 0.00_978,
                "w": 0.02_560,
                "x": 0.00_150,
                "y": 0.01_994,
                "z": 0.00_077,
            }
      else:
            # Custom frequencies dictionary
            lowerCamelCase__	:       Optional[int]					=						frequencies_dict

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

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

      # cycle through all of the shifts
      for shift in range(len(_A		)		):
            lowerCamelCase__	:       Optional[Any]					=						""

            # decrypt the message with the shift
            for letter in ciphertext:
                  try:
                        # Try to index the letter in the alphabet
                        lowerCamelCase__	:       Dict					=						(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

            lowerCamelCase__	:       str					=						0.0

            # Loop through each letter in the decoded message with the shift
            for letter in decrypted_with_shift:
                  if case_sensitive:
                        lowerCamelCase__	:       List[str]					=						letter.lower()
                        if letter in frequencies:
                              # Get the amount of times the letter occurs in the message
                              lowerCamelCase__	:       List[str]					=						decrypted_with_shift.lower().count(_A		)

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

                              # Complete the chi squared statistic formula
                              lowerCamelCase__	:       str					=						((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
                              lowerCamelCase__	:       Any					=						decrypted_with_shift.count(_A		)

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

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

      lowerCamelCase__	:       int					=						min(
          _A					,      key=_A					,      )

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


