code: 
  
  import copy
  import inspect
  
  from transformers.testing_utils import require_torch, torch_device
  from transformers.utils.backbone_utils import BackboneType
  
  @require_torch
  class __UpperCamelCase    :
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					__magic_name__     			=      ()
  					__magic_name__     			=      True
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Any		       =   self.config_class
  
  						# test default config
  						UpperCAmelCase__:  Any		       =   config_class()
  						self.assertIsNotNone(lowerCamelCase__	)
  						UpperCAmelCase__:  List[Any]		       =   ["stem"] + [F"stage{idx}" for idx in range(1							,			len(config.depths	) + 1	)]
  						self.assertEqual(config.stage_names							,			lowerCamelCase__	)
  						self.assertTrue(set(config.out_features	).issubset(set(config.stage_names	)	)	)
  
  						# Test out_features and out_indices are correctly set
  						# out_features and out_indices both None
  						UpperCAmelCase__:  Dict		       =   config_class(out_features=lowerCamelCase__							,			out_indices=lowerCamelCase__	)
  						self.assertEqual(config.out_features							,			[config.stage_names[-1]]	)
  						self.assertEqual(config.out_indices							,			[len(config.stage_names	) - 1]	)
  
  						# out_features and out_indices both set
  						UpperCAmelCase__:  Dict		       =   config_class(out_features=["stem", "stage1"]							,			out_indices=[0, 1]	)
  						self.assertEqual(config.out_features							,			["stem", "stage1"]	)
  						self.assertEqual(config.out_indices							,			[0, 1]	)
  
  						# Only out_features set
  						UpperCAmelCase__:  str		       =   config_class(out_features=["stage1", "stage3"]	)
  						self.assertEqual(config.out_features							,			["stage1", "stage3"]	)
  						self.assertEqual(config.out_indices							,			[1, 3]	)
  
  						# Only out_indices set
  						UpperCAmelCase__:  Dict		       =   config_class(out_indices=[0, 2]	)
  						self.assertEqual(config.out_features							,			[config.stage_names[0], config.stage_names[2]]	)
  						self.assertEqual(config.out_indices							,			[0, 2]	)
  
  						# Error raised when out_indices do not correspond to out_features
  						with self.assertRaises(lowerCamelCase__	):
  							UpperCAmelCase__:  Union[str, Any]		       =   config_class(out_features=["stage1", "stage2"]							,			out_indices=[0, 2]	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__       ,	UpperCAmelCase__:  Optional[int]		       =   self.model_tester.prepare_config_and_inputs_for_common()
  
  						for model_class in self.all_model_classes:
  							UpperCAmelCase__:  List[str]		       =   model_class(lowerCamelCase__	)
  							UpperCAmelCase__:  int		       =   inspect.signature(model.forward	)
  							# signature.parameters is an OrderedDict => so arg_names order is deterministic
  							UpperCAmelCase__:  Optional[int]		       =   [*signature.parameters.keys()]
  							UpperCAmelCase__:  Any		       =   ["pixel_values"]
  							self.assertListEqual(arg_names[:1]							,			lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__       ,	UpperCAmelCase__:  Any		       =   self.model_tester.prepare_config_and_inputs_for_common()
  
  						for model_class in self.all_model_classes:
  							UpperCAmelCase__:  List[Any]		       =   model_class(lowerCamelCase__	)
  							self.assertEqual(len(model.channels	)							,			len(config.out_features	)	)
  							UpperCAmelCase__:  Optional[int]		       =   model.num_features
  							UpperCAmelCase__:  str		       =   [config.stage_names.index(lowerCamelCase__	) for feat in config.out_features]
  							UpperCAmelCase__:  List[str]		       =   [num_features[idx] for idx in out_indices]
  							self.assertListEqual(model.channels							,			lowerCamelCase__	)
  
  							UpperCAmelCase__:  Union[str, Any]		       =   copy.deepcopy(lowerCamelCase__	)
  							UpperCAmelCase__:  str		       =   None
  							UpperCAmelCase__:  List[Any]		       =   model_class(lowerCamelCase__	)
  							self.assertEqual(len(model.channels	)							,			1	)
  							self.assertListEqual(model.channels							,			[num_features[-1]]	)
  
  							UpperCAmelCase__:  Dict		       =   copy.deepcopy(lowerCamelCase__	)
  							UpperCAmelCase__:  Any		       =   None
  							UpperCAmelCase__:  str		       =   model_class(lowerCamelCase__	)
  							self.assertEqual(len(model.channels	)							,			1	)
  							self.assertListEqual(model.channels							,			[num_features[-1]]	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__       ,	UpperCAmelCase__:  Union[str, Any]		       =   self.model_tester.prepare_config_and_inputs_for_common()
  
  						for model_class in self.all_model_classes:
  							UpperCAmelCase__:  List[Any]		       =   model_class(lowerCamelCase__	)
  							model.to(lowerCamelCase__	)
  							model.eval()
  							UpperCAmelCase__:  int		       =   model(**lowerCamelCase__	)
  
  							self.assertEqual(len(result.feature_maps	)							,			len(config.out_features	)	)
  							self.assertEqual(len(model.channels	)							,			len(config.out_features	)	)
  							self.assertEqual(len(result.feature_maps	)							,			len(config.out_indices	)	)
  							self.assertEqual(len(model.channels	)							,			len(config.out_indices	)	)
  
  							# Check output of last stage is taken if out_features=None, out_indices=None
  							UpperCAmelCase__:  Any		       =   copy.deepcopy(lowerCamelCase__	)
  							UpperCAmelCase__:  List[Any]		       =   None
  							UpperCAmelCase__:  Optional[Any]		       =   model_class(lowerCamelCase__	)
  							model.to(lowerCamelCase__	)
  							model.eval()
  							UpperCAmelCase__:  Optional[int]		       =   model(**lowerCamelCase__	)
  
  							self.assertEqual(len(result.feature_maps	)							,			1	)
  							self.assertEqual(len(model.channels	)							,			1	)
  
  							UpperCAmelCase__:  Any		       =   copy.deepcopy(lowerCamelCase__	)
  							UpperCAmelCase__:  Tuple		       =   None
  							UpperCAmelCase__:  Dict		       =   model_class(lowerCamelCase__	)
  							model.to(lowerCamelCase__	)
  							model.eval()
  							UpperCAmelCase__:  List[str]		       =   model(**lowerCamelCase__	)
  
  							self.assertEqual(len(result.feature_maps	)							,			1	)
  							self.assertEqual(len(model.channels	)							,			1	)
  
  							# Check backbone can be initialized with fresh weights
  							UpperCAmelCase__:  Optional[Any]		       =   copy.deepcopy(lowerCamelCase__	)
  							UpperCAmelCase__:  Any		       =   False
  							UpperCAmelCase__:  Union[str, Any]		       =   model_class(lowerCamelCase__	)
  							model.to(lowerCamelCase__	)
  							model.eval()
  							UpperCAmelCase__:  Dict		       =   model(**lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__       ,	UpperCAmelCase__:  int		       =   self.model_tester.prepare_config_and_inputs_for_common()
  
  						for backbone_class in self.all_model_classes:
  							UpperCAmelCase__:  Any		       =   backbone_class(lowerCamelCase__	)
  
  							self.assertTrue(hasattr(lowerCamelCase__							,			"backbone_type"	)	)
  							self.assertTrue(hasattr(lowerCamelCase__							,			"stage_names"	)	)
  							self.assertTrue(hasattr(lowerCamelCase__							,			"num_features"	)	)
  							self.assertTrue(hasattr(lowerCamelCase__							,			"out_indices"	)	)
  							self.assertTrue(hasattr(lowerCamelCase__							,			"out_features"	)	)
  							self.assertTrue(hasattr(lowerCamelCase__							,			"out_feature_channels"	)	)
  							self.assertTrue(hasattr(lowerCamelCase__							,			"channels"	)	)
  
  							self.assertIsInstance(backbone.backbone_type							,			lowerCamelCase__	)
  							# Verify num_features has been initialized in the backbone init
  							self.assertIsNotNone(backbone.num_features	)
  							self.assertTrue(len(backbone.channels	) == len(backbone.out_indices	)	)
  							self.assertTrue(len(backbone.stage_names	) == len(backbone.num_features	)	)
  							self.assertTrue(len(backbone.channels	) <= len(backbone.num_features	)	)
  							self.assertTrue(len(backbone.out_feature_channels	) == len(backbone.stage_names	)	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__       ,	UpperCAmelCase__:  int		       =   self.model_tester.prepare_config_and_inputs_for_common()
  						UpperCAmelCase__:  Union[str, Any]		       =   inputs_dict["pixel_values"].shape[0]
  
  						for backbone_class in self.all_model_classes:
  							UpperCAmelCase__:  Union[str, Any]		       =   backbone_class(lowerCamelCase__	)
  							backbone.to(lowerCamelCase__	)
  							backbone.eval()
  
  							UpperCAmelCase__:  List[Any]		       =   backbone(**lowerCamelCase__	)
  
  							# Test default outputs and verify feature maps
  							self.assertIsInstance(outputs.feature_maps							,			lowerCamelCase__	)
  							self.assertTrue(len(outputs.feature_maps	) == len(backbone.channels	)	)
  							for feature_map, n_channels in zip(outputs.feature_maps							,			backbone.channels	):
  								self.assertTrue(feature_map.shape[:2]							,			(batch_size, n_channels)	)
  							self.assertIsNone(outputs.hidden_states	)
  							self.assertIsNone(outputs.attentions	)
  
  							# Test output_hidden_states=True
  							UpperCAmelCase__:  Optional[int]		       =   backbone(**lowerCamelCase__							,			output_hidden_states=lowerCamelCase__	)
  							self.assertIsNotNone(outputs.hidden_states	)
  							self.assertTrue(len(outputs.hidden_states	)							,			len(backbone.stage_names	)	)
  							for hidden_state, n_channels in zip(outputs.hidden_states							,			backbone.channels	):
  								self.assertTrue(hidden_state.shape[:2]							,			(batch_size, n_channels)	)
  
  							# Test output_attentions=True
  							if self.has_attentions:
  								UpperCAmelCase__:  Union[str, Any]		       =   backbone(**lowerCamelCase__							,			output_attentions=lowerCamelCase__	)
  								self.assertIsNotNone(outputs.attentions	)
style_context: 
  
  _lowerCAmelCase     :			Optional[int]    ={
      """+""": lambda x, y: x + y,
      """-""": lambda x, y: x - y,
      """*""": lambda x, y: x * y,
      """/""": lambda x, y: x / y,
  }
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	return c.isdigit()
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  str		       =   []
  
  	# iterate over the string in reverse order
  	for c in expression.split()[::-1]:
  		# push operand to stack
  		if is_operand(SCREAMING_SNAKE_CASE			):
  			stack.append(int(SCREAMING_SNAKE_CASE			)			)
  
  		else:
  			# pop values from stack can calculate the result
  			# push the result onto the stack again
  			UpperCAmelCase__:  Any		       =   stack.pop()
  			UpperCAmelCase__:  int		       =   stack.pop()
  			stack.append(calc[c](SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)			)
  
  	return stack.pop()
  
  
  # Driver code
  if __name__ == "__main__":
  					_lowerCAmelCase     :			Optional[int]    ="""+ 9 * 2 6"""
  					print(evaluate(test_expression))
  
  					_lowerCAmelCase     :			Optional[Any]    ="""/ * 10 2 + 4 1 """
  					print(evaluate(test_expression))