
'''simple docstring'''

def     snake_case__						(   UpperCamelCase						)			->   Any:

		# bit count represents no. of bits in the gray code
		if bit_count < 0:
				raise ValueError('''The given input must be positive'''						)

		# get the generated string sequence
		_UpperCamelCase							:			Optional[Any]     =   gray_code_sequence_string(_A						)
		#
		# convert them to integers
		for i in range(len(_A						)						):
				_UpperCamelCase							:			Union[str, Any]     =   int(sequence[i]      ,2						)

		return sequence







def     snake_case__						(   UpperCamelCase						)			->   str:

		# The approach is a recursive one
		# Base case achieved when either n = 0 or n=1
		if bit_count == 0:
				return ["0"]

		if bit_count == 1:
				return ["0", "1"]

		_UpperCamelCase							:			Dict     =   1 << bit_count  # defines the length of the sequence
		# 1<< n is equivalent to 2^n

		# recursive answer will generate answer for n-1 bits
		_UpperCamelCase							:			Dict     =   gray_code_sequence_string(bit_count - 1						)

		_UpperCamelCase							:			int     =   []

		# append 0 to first half of the smaller sequence generated
		for i in range(seq_len // 2						):
				_UpperCamelCase							:			Dict     =   '0' + smaller_sequence[i]
				sequence.append(_A						)

		# append 1 to second half ... start from the end of the list
		for i in reversed(range(seq_len // 2						)						):
				_UpperCamelCase							:			int     =   '1' + smaller_sequence[i]
				sequence.append(_A						)

		return sequence


if __name__ == "__main__":
	import doctest

	doctest.testmod()










'''simple docstring'''






from typing import TYPE_CHECKING

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


lowerCAmelCase:   Dict					=		{'configuration_vit_mae': ['VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMAEConfig']}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase:   Optional[int]					=		[
         'VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST',
         'ViTMAEForPreTraining',
         'ViTMAELayer',
         'ViTMAEModel',
         'ViTMAEPreTrainedModel',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCAmelCase:   List[Any]					=		[
         'TFViTMAEForPreTraining',
         'TFViTMAEModel',
         'TFViTMAEPreTrainedModel',
     ]

if TYPE_CHECKING:
     from .configuration_vit_mae import VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMAEConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_vit_mae import (
              VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST,
              ViTMAEForPreTraining,
              ViTMAELayer,
              ViTMAEModel,
              ViTMAEPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_vit_mae import TFViTMAEForPreTraining, TFViTMAEModel, TFViTMAEPreTrainedModel


else:
     import sys

     lowerCAmelCase:   Tuple					=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)