






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


snake_case__      :	Tuple       	=      {
    """configuration_electra""": ["""ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ElectraConfig""", """ElectraOnnxConfig"""],
    """tokenization_electra""": ["""ElectraTokenizer"""],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 snake_case__      :	Any       	=      ["""ElectraTokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 snake_case__      :	List[str]       	=      [
     """ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """ElectraForCausalLM""",
     """ElectraForMaskedLM""",
     """ElectraForMultipleChoice""",
     """ElectraForPreTraining""",
     """ElectraForQuestionAnswering""",
     """ElectraForSequenceClassification""",
     """ElectraForTokenClassification""",
     """ElectraModel""",
     """ElectraPreTrainedModel""",
     """load_tf_weights_in_electra""",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 snake_case__      :	Optional[Any]       	=      [
     """TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """TFElectraForMaskedLM""",
     """TFElectraForMultipleChoice""",
     """TFElectraForPreTraining""",
     """TFElectraForQuestionAnswering""",
     """TFElectraForSequenceClassification""",
     """TFElectraForTokenClassification""",
     """TFElectraModel""",
     """TFElectraPreTrainedModel""",
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 snake_case__      :	Tuple       	=      [
     """FlaxElectraForCausalLM""",
     """FlaxElectraForMaskedLM""",
     """FlaxElectraForMultipleChoice""",
     """FlaxElectraForPreTraining""",
     """FlaxElectraForQuestionAnswering""",
     """FlaxElectraForSequenceClassification""",
     """FlaxElectraForTokenClassification""",
     """FlaxElectraModel""",
     """FlaxElectraPreTrainedModel""",
 ]


if TYPE_CHECKING:
 from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
 from .tokenization_electra import ElectraTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_electra_fast import ElectraTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_electra import (
      ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
      ElectraForCausalLM,
      ElectraForMaskedLM,
      ElectraForMultipleChoice,
      ElectraForPreTraining,
      ElectraForQuestionAnswering,
      ElectraForSequenceClassification,
      ElectraForTokenClassification,
      ElectraModel,
      ElectraPreTrainedModel,
      load_tf_weights_in_electra,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_electra import (
      TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFElectraForMaskedLM,
      TFElectraForMultipleChoice,
      TFElectraForPreTraining,
      TFElectraForQuestionAnswering,
      TFElectraForSequenceClassification,
      TFElectraForTokenClassification,
      TFElectraModel,
      TFElectraPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_electra import (
      FlaxElectraForCausalLM,
      FlaxElectraForMaskedLM,
      FlaxElectraForMultipleChoice,
      FlaxElectraForPreTraining,
      FlaxElectraForQuestionAnswering,
      FlaxElectraForSequenceClassification,
      FlaxElectraForTokenClassification,
      FlaxElectraModel,
      FlaxElectraPreTrainedModel,
  )

else:
 import sys

 snake_case__      :	Union[str, Any]       	=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)













def     _snake_case    (__lowercase    ,      __lowercase):
   _enforce_args(__lowercase    ,      __lowercase)
   if n == 0:
      return 0
   UpperCamelCase_									=     float('-inf')
   for i in range(1    ,      n + 1):
      UpperCamelCase_									=     max(
          __lowercase    ,      prices[i - 1] + naive_cut_rod_recursive(n - i    ,      __lowercase))

   return max_revue






def     _snake_case    (__lowercase    ,      __lowercase):
   _enforce_args(__lowercase    ,      __lowercase)
   UpperCamelCase_									=     [float('-inf') for _ in range(n + 1)]
   return _top_down_cut_rod_recursive(__lowercase    ,      __lowercase    ,      __lowercase)






def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   if max_rev[n] >= 0:
      return max_rev[n]
   elif n == 0:
      return 0
   else:
      UpperCamelCase_									=     float('-inf')
      for i in range(1    ,      n + 1):
         UpperCamelCase_									=     max(
             __lowercase    ,      prices[i - 1] + _top_down_cut_rod_recursive(n - i    ,      __lowercase    ,      __lowercase)    ,      )

      UpperCamelCase_									=     max_revenue

   return max_rev[n]






def     _snake_case    (__lowercase    ,      __lowercase):
   _enforce_args(__lowercase    ,      __lowercase)

   # length(max_rev) = n + 1, to accommodate for the revenue obtainable from a rod of
   # length 0.
   UpperCamelCase_									=     [float('-inf') for _ in range(n + 1)]
   UpperCamelCase_									=     0

   for i in range(1    ,      n + 1):
      UpperCamelCase_									=     max_rev[i]
      for j in range(1    ,      i + 1):
         UpperCamelCase_									=     max(__lowercase    ,      prices[j - 1] + max_rev[i - j])

      UpperCamelCase_									=     max_revenue_i

   return max_rev[n]






def     _snake_case    (__lowercase    ,      __lowercase):
   if n < 0:
      UpperCamelCase_									=     f"""n must be greater than or equal to 0. Got n = {n}"""
      raise ValueError(__lowercase)

   if n > len(__lowercase):
      UpperCamelCase_									=     (
          'Each integral piece of rod must have a corresponding price. '
          f"""Got n = {n} but length of prices = {len(__lowercase)}"""
      )
      raise ValueError(__lowercase)






def     _snake_case    ():
   UpperCamelCase_									=     [6, 10, 12, 15, 20, 23]
   UpperCamelCase_									=     len(__lowercase)

   # the best revenue comes from cutting the rod into 6 pieces, each
   # of length 1 resulting in a revenue of 6 * 6 = 36.
   UpperCamelCase_									=     36

   UpperCamelCase_									=     top_down_cut_rod(__lowercase    ,      __lowercase)
   UpperCamelCase_									=     bottom_up_cut_rod(__lowercase    ,      __lowercase)
   UpperCamelCase_									=     naive_cut_rod_recursive(__lowercase    ,      __lowercase)

   assert expected_max_revenue == max_rev_top_down
   assert max_rev_top_down == max_rev_bottom_up
   assert max_rev_bottom_up == max_rev_naive


if __name__ == "__main__":
 main()





