





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCAmelCase     :     Optional[int]							=	{
    """configuration_data2vec_audio""": ["""DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP""", """Data2VecAudioConfig"""],
    """configuration_data2vec_text""": [
        """DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """Data2VecTextConfig""",
        """Data2VecTextOnnxConfig""",
    ],
    """configuration_data2vec_vision""": [
        """DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """Data2VecVisionConfig""",
        """Data2VecVisionOnnxConfig""",
    ],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase     :     List[Any]							=	[
         """DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """Data2VecAudioForAudioFrameClassification""",
         """Data2VecAudioForCTC""",
         """Data2VecAudioForSequenceClassification""",
         """Data2VecAudioForXVector""",
         """Data2VecAudioModel""",
         """Data2VecAudioPreTrainedModel""",
     ]
     UpperCAmelCase     :     Tuple							=	[
         """DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """Data2VecTextForCausalLM""",
         """Data2VecTextForMaskedLM""",
         """Data2VecTextForMultipleChoice""",
         """Data2VecTextForQuestionAnswering""",
         """Data2VecTextForSequenceClassification""",
         """Data2VecTextForTokenClassification""",
         """Data2VecTextModel""",
         """Data2VecTextPreTrainedModel""",
     ]
     UpperCAmelCase     :     Optional[Any]							=	[
         """DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """Data2VecVisionForImageClassification""",
         """Data2VecVisionForMaskedImageModeling""",
         """Data2VecVisionForSemanticSegmentation""",
         """Data2VecVisionModel""",
         """Data2VecVisionPreTrainedModel""",
     ]

if is_tf_available():
     UpperCAmelCase     :     Dict							=	[
         """TFData2VecVisionForImageClassification""",
         """TFData2VecVisionForSemanticSegmentation""",
         """TFData2VecVisionModel""",
         """TFData2VecVisionPreTrainedModel""",
     ]

if TYPE_CHECKING:
     from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
     from .configuration_dataavec_text import (
         DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
         DataaVecTextConfig,
         DataaVecTextOnnxConfig,
     )
     from .configuration_dataavec_vision import (
         DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
         DataaVecVisionConfig,
         DataaVecVisionOnnxConfig,
     )

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_dataavec_audio import (
              DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
              DataaVecAudioForAudioFrameClassification,
              DataaVecAudioForCTC,
              DataaVecAudioForSequenceClassification,
              DataaVecAudioForXVector,
              DataaVecAudioModel,
              DataaVecAudioPreTrainedModel,
          )
          from .modeling_dataavec_text import (
              DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
              DataaVecTextForCausalLM,
              DataaVecTextForMaskedLM,
              DataaVecTextForMultipleChoice,
              DataaVecTextForQuestionAnswering,
              DataaVecTextForSequenceClassification,
              DataaVecTextForTokenClassification,
              DataaVecTextModel,
              DataaVecTextPreTrainedModel,
          )
          from .modeling_dataavec_vision import (
              DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
              DataaVecVisionForImageClassification,
              DataaVecVisionForMaskedImageModeling,
              DataaVecVisionForSemanticSegmentation,
              DataaVecVisionModel,
              DataaVecVisionPreTrainedModel,
          )
     if is_tf_available():
          from .modeling_tf_dataavec_vision import (
              TFDataaVecVisionForImageClassification,
              TFDataaVecVisionForSemanticSegmentation,
              TFDataaVecVisionModel,
              TFDataaVecVisionPreTrainedModel,
          )

else:
     import sys

     UpperCAmelCase     :     Optional[Any]							=	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)













UpperCAmelCase     :     Dict							=	[0, 2, 4, 6, 8]
UpperCAmelCase     :     Tuple							=	[1, 3, 5, 7, 9]
def 					_A	(		SCREAMING_SNAKE_CASE					:       int	,	SCREAMING_SNAKE_CASE					:       int	,	SCREAMING_SNAKE_CASE					:       list[int]	,	SCREAMING_SNAKE_CASE					:       int						):





  """simple docstring"""



  if remaining_length == 0:
    if digits[0] == 0 or digits[-1] == 0:
      return 0

    for i in range(length // 2 - 1	,	-1	,	-1						):
      remainder += digits[i] + digits[length - i - 1]

      if remainder % 2 == 0:
        return 0

      remainder //= 10

    return 1

  if remaining_length == 1:
    if remainder % 2 == 0:
      return 0

    a__     : str  =0
    for digit in range(10						):
      a__     : int  =digit
      result += reversible_numbers(
          0	,	(remainder + 2 * digit) // 10	,	SCREAMING_SNAKE_CASE	,	SCREAMING_SNAKE_CASE						)
    return result

  a__     : List[str]  =0
  for digita in range(10						):
    a__     : Optional[int]  =digita

    if (remainder + digita) % 2 == 0:
      a__     : Dict  =ODD_DIGITS
    else:
      a__     : Any  =EVEN_DIGITS

    for digita in other_parity_digits:
      a__     : Union[str, Any]  =digita
      result += reversible_numbers(
          remaining_length - 2	,	(remainder + digita + digita) // 10	,	SCREAMING_SNAKE_CASE	,	SCREAMING_SNAKE_CASE	,	)
  return result
def 					_A	(		SCREAMING_SNAKE_CASE					:       int = 9						):





  """simple docstring"""



  a__     : List[str]  =0
  for length in range(1	,	max_power + 1						):
    result += reversible_numbers(SCREAMING_SNAKE_CASE	,	0	,	[0] * length	,	SCREAMING_SNAKE_CASE						)
  return result


if __name__ == "__main__":
     print(F"""{solution() = }""")






