






from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__UpperCAmelCase							:   List[str]							=  logging.get_logger(__name__)

__UpperCAmelCase							:   Optional[Any]							=  {
    "google/bit-50": "https://huggingface.co/google/bit-50/resolve/main/config.json",
}


class 					_snake_case						(			UpperCAmelCase_       ,    UpperCAmelCase_ ):
	_A          =   "bit"
	_A          =   ["preactivation", "bottleneck"]
	_A          =   ["SAME", "VALID"]






	def __init__(		self					,UpperCamelCase=3					,UpperCamelCase=64					,UpperCamelCase=[256, 512, 1_024, 2_048]					,UpperCamelCase=[3, 4, 6, 3]					,UpperCamelCase="preactivation"					,UpperCamelCase="relu"					,UpperCamelCase=None					,UpperCamelCase=32					,UpperCamelCase=0.0					,UpperCamelCase=False					,UpperCamelCase=32					,UpperCamelCase=1					,UpperCamelCase=None					,UpperCamelCase=None					,**UpperCamelCase					,)						->    List[Any]:
					super().__init__(**_snake_case       )
					if layer_type not in self.layer_types:
									raise ValueError(f'layer_type={layer_type} is not one of {",".join(self.layer_types       )}'       )
					if global_padding is not None:
									if global_padding.upper() in self.supported_padding:
													snake_case__      :List[Any]         =   global_padding.upper()
									else:
													raise ValueError(f'Padding strategy {global_padding} not supported'       )
					snake_case__      :str         =   num_channels
					snake_case__      :Dict         =   embedding_size
					snake_case__      :Tuple         =   hidden_sizes
					snake_case__      :List[Any]         =   depths
					snake_case__      :List[str]         =   layer_type
					snake_case__      :Optional[int]         =   hidden_act
					snake_case__      :Union[str, Any]         =   global_padding
					snake_case__      :int         =   num_groups
					snake_case__      :Optional[Any]         =   drop_path_rate
					snake_case__      :Any         =   embedding_dynamic_padding
					snake_case__      :Union[str, Any]         =   output_stride
					snake_case__      :List[str]         =   width_factor

					snake_case__      :str         =   ["stem"] + [f'stage{idx}' for idx in range(1					,len(_snake_case       ) + 1       )]
					snake_case__    ,						snake_case__      :List[Any]         =   get_aligned_output_features_output_indices(
					    out_features=_snake_case					,out_indices=_snake_case					,stage_names=self.stage_names       )







def 					lowercase_ (    __snake_case     :							int = 10_00      )     -> int:





				'''simple docstring'''


				snake_case__      :int         =   3
				snake_case__      :int         =   0
				while a < n:
								if a % 3 == 0 or a % 5 == 0:
												result += a
								elif a % 15 == 0:
												result -= a
								a += 1
				return result


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