



import operator as op
def 			lowercase_				(A					:					Tuple ):
       snake_case__				:      Union[str, Any]        =      []
       snake_case__				:      Any        =      lambda A						,   A : int(x / y )  # noqa: E731 integer division operation
       snake_case__				:      List[str]        =      {
           '^': op.pow,
           '*': op.mul,
           '/': div,
           '+': op.add,
           '-': op.sub,
       }  # operators & their respective operation

       # print table header
       print('Symbol'.center(8 )						,   'Action'.center(1_2 )						,   'Stack'						,   sep=' | ' )
       print('-' * (3_0 + len(__lowerCAmelCase )) )

       for x in post_fix:
              if x.isdigit():  # if x in digit
                     stack.append(__lowerCAmelCase )  # append x to stack
                     # output in tabular format
                     print(x.rjust(8 )						,   ('push(' + x + ')').ljust(1_2 )						,   ','.join(__lowerCAmelCase )						,   sep=' | ' )
              else:
                     snake_case__				:      List[Any]        =      stack.pop()  # pop stack
                     # output in tabular format
                     print(''.rjust(8 )						,   ('pop(' + b + ')').ljust(1_2 )						,   ','.join(__lowerCAmelCase )						,   sep=' | ' )

                     snake_case__				:      Optional[Any]        =      stack.pop()  # pop stack
                     # output in tabular format
                     print(''.rjust(8 )						,   ('pop(' + a + ')').ljust(1_2 )						,   ','.join(__lowerCAmelCase )						,   sep=' | ' )

                     stack.append(
                         str(opr[x](int(__lowerCAmelCase )						,   int(__lowerCAmelCase ) ) ) )  # evaluate the 2 values popped from stack & push result to stack
                     # output in tabular format
                     print(
                         x.rjust(8 )						,   ('push(' + a + x + b + ')').ljust(1_2 )						,   ','.join(__lowerCAmelCase )						,   sep=' | '						,   )

       return int(stack[0] )


if __name__ == "__main__":
 a_  :Union[str, Any]     = input("\n\nEnter a Postfix Equation (space separated) = ").split(" ")
 print("\n\tResult = ", solve(Postfix))







"""simple docstring"""


import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


a				=logging.get_logger(__name__)

a				={
    'ut/deta': 'https://huggingface.co/ut/deta/resolve/main/config.json',
}






class   __UpperCAmelCase		(      __lowerCAmelCase      ):
				A__ :  str    				=			'''deta'''
				A__ :  List[str]    				=			{
				    '''hidden_size''': '''d_model''',
				    '''num_attention_heads''': '''encoder_attention_heads''',
				}

				def __init__( self      ,					_lowerCamelCase=None      ,					_lowerCamelCase=900      ,					_lowerCamelCase=2048      ,					_lowerCamelCase=6      ,					_lowerCamelCase=2048      ,					_lowerCamelCase=8      ,					_lowerCamelCase=6      ,					_lowerCamelCase=1024      ,					_lowerCamelCase=8      ,					_lowerCamelCase=0.0      ,					_lowerCamelCase=True      ,					_lowerCamelCase="relu"      ,					_lowerCamelCase=256      ,					_lowerCamelCase=0.1      ,					_lowerCamelCase=0.0      ,					_lowerCamelCase=0.0      ,					_lowerCamelCase=0.0_2      ,					_lowerCamelCase=1.0      ,					_lowerCamelCase=True      ,					_lowerCamelCase=False      ,					_lowerCamelCase="sine"      ,					_lowerCamelCase=5      ,					_lowerCamelCase=4      ,					_lowerCamelCase=4      ,					_lowerCamelCase=True      ,					_lowerCamelCase=300      ,					_lowerCamelCase=True      ,					_lowerCamelCase=True      ,					_lowerCamelCase=1      ,					_lowerCamelCase=5      ,					_lowerCamelCase=2      ,					_lowerCamelCase=1      ,					_lowerCamelCase=1      ,					_lowerCamelCase=5      ,					_lowerCamelCase=2      ,					_lowerCamelCase=0.1      ,					_lowerCamelCase=0.2_5      ,					**_lowerCamelCase      ,					):
										if backbone_config is None:
																logger.info("`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone." )
																lowerCamelCase__   =CONFIG_MAPPING["resnet"](out_features=["stage2", "stage3", "stage4"] )
										else:
																if isinstance(_lowerCamelCase      ,					_lowerCamelCase ):
																						lowerCamelCase__   =backbone_config.pop("model_type" )
																						lowerCamelCase__   =CONFIG_MAPPING[backbone_model_type]
																						lowerCamelCase__   =config_class.from_dict(_lowerCamelCase )

										lowerCamelCase__   =backbone_config
										lowerCamelCase__   =num_queries
										lowerCamelCase__   =max_position_embeddings
										lowerCamelCase__   =d_model
										lowerCamelCase__   =encoder_ffn_dim
										lowerCamelCase__   =encoder_layers
										lowerCamelCase__   =encoder_attention_heads
										lowerCamelCase__   =decoder_ffn_dim
										lowerCamelCase__   =decoder_layers
										lowerCamelCase__   =decoder_attention_heads
										lowerCamelCase__   =dropout
										lowerCamelCase__   =attention_dropout
										lowerCamelCase__   =activation_dropout
										lowerCamelCase__   =activation_function
										lowerCamelCase__   =init_std
										lowerCamelCase__   =init_xavier_std
										lowerCamelCase__   =encoder_layerdrop
										lowerCamelCase__   =auxiliary_loss
										lowerCamelCase__   =position_embedding_type
										# deformable attributes
										lowerCamelCase__   =num_feature_levels
										lowerCamelCase__   =encoder_n_points
										lowerCamelCase__   =decoder_n_points
										lowerCamelCase__   =two_stage
										lowerCamelCase__   =two_stage_num_proposals
										lowerCamelCase__   =with_box_refine
										lowerCamelCase__   =assign_first_stage
										if two_stage is True and with_box_refine is False:
																raise ValueError("If two_stage is True, with_box_refine must be True." )
										# Hungarian matcher
										lowerCamelCase__   =class_cost
										lowerCamelCase__   =bbox_cost
										lowerCamelCase__   =giou_cost
										# Loss coefficients
										lowerCamelCase__   =mask_loss_coefficient
										lowerCamelCase__   =dice_loss_coefficient
										lowerCamelCase__   =bbox_loss_coefficient
										lowerCamelCase__   =giou_loss_coefficient
										lowerCamelCase__   =eos_coefficient
										lowerCamelCase__   =focal_alpha
										super().__init__(is_encoder_decoder=_lowerCamelCase      ,					**_lowerCamelCase )

				@property
				def 						_a      ( self ):
										return self.encoder_attention_heads

				@property
				def 						_a      ( self ):
										return self.d_model






				def 						_a      ( self ):
										lowerCamelCase__   =copy.deepcopy(self.__dict__ )
										lowerCamelCase__   =self.backbone_config.to_dict()
										lowerCamelCase__   =self.__class__.model_type
										return output


