


from collections import OrderedDict
from typing import Mapping

from packaging import version

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


__lowerCAmelCase	: Optional[Any]  				=logging.get_logger(__name__)

__lowerCAmelCase	: Optional[int]  				={
    'microsoft/resnet-50': 'https://huggingface.co/microsoft/resnet-50/blob/main/config.json',
}
class        _lowercase      (			A__						,			A__       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			Optional[int]						=		'''resnet'''
				SCREAMING_SNAKE_CASE__				:			Optional[Any]						=		['''basic''', '''bottleneck''']


				def __init__(       self			:List[Any]			,			lowerCAmelCase__			:Dict=3			,			lowerCAmelCase__			:int=64			,			lowerCAmelCase__			:List[str]=[256, 512, 1_024, 2_048]			,			lowerCAmelCase__			:Any=[3, 4, 6, 3]			,			lowerCAmelCase__			:str="bottleneck"			,			lowerCAmelCase__			:List[Any]="relu"			,			lowerCAmelCase__			:List[Any]=False			,			lowerCAmelCase__			:int=None			,			lowerCAmelCase__			:Dict=None			,			**lowerCAmelCase__			:Tuple			,			)		->			Optional[int]:
										super().__init__(**lowerCAmelCase__	)
										if layer_type not in self.layer_types:
																raise ValueError(f'''layer_type={layer_type} is not one of {','.join(self.layer_types	)}'''	)
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		num_channels
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		embedding_size
										__SCREAMING_SNAKE_CASE						:     Tuple					=		hidden_sizes
										__SCREAMING_SNAKE_CASE						:     List[str]					=		depths
										__SCREAMING_SNAKE_CASE						:     Tuple					=		layer_type
										__SCREAMING_SNAKE_CASE						:     Tuple					=		hidden_act
										__SCREAMING_SNAKE_CASE						:     int					=		downsample_in_first_stage
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		['''stem'''] + [f'''stage{idx}''' for idx in range(1			,			len(lowerCAmelCase__	) + 1	)]
										__SCREAMING_SNAKE_CASE			,			__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		get_aligned_output_features_output_indices(
										    out_features=lowerCAmelCase__			,			out_indices=lowerCAmelCase__			,			stage_names=self.stage_names	)




class        _lowercase      (			A__       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			int						=		version.parse('''1.11'''       )


				@property
				def 		__magic_name__(       self			:List[str]	)		->			Mapping[str, Mapping[int, str]]:
										return OrderedDict(
										    [
										        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
										    ]	)



				@property
				def 		__magic_name__(       self			:Optional[Any]	)		->			float:
										return 1E-3




from __future__ import annotations




def    snake_case_     (  snake_case			,							snake_case     )  ->				bool:
       if len(snake_case     ) == 0:
              return False
       lowercase__:   Any  			=   len(snake_case     ) // 2
       if a_list[midpoint] == item:
              return True
       if item < a_list[midpoint]:
              return binary_search(a_list[:midpoint]			,							snake_case     )
       else:
              return binary_search(a_list[midpoint + 1 :]			,							snake_case     )


if __name__ == "__main__":
 __lowerCAmelCase		       =							input('''Enter numbers separated by comma:\n''').strip()
 __lowerCAmelCase		       =							[int(item.strip()) for item in user_input.split(''',''')]
 __lowerCAmelCase		       =							int(input('''Enter the number to be found in the list:\n''').strip())
 __lowerCAmelCase		       =							'''''' if binary_search(sequence, target) else '''not '''
 print(F'''{target} was {not_str}found in {sequence}''')


