


"""simple docstring"""






from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


_lowerCamelCase     =  logging.get_logger(__name__)

# General docstring
_lowerCamelCase     =  'RegNetConfig'

# Base docstring
_lowerCamelCase     =  'facebook/regnet-y-040'
_lowerCamelCase     =  [1, 1088, 7, 7]

# Image classification docstring
_lowerCamelCase     =  'facebook/regnet-y-040'
_lowerCamelCase     =  'tabby, tabby cat'

_lowerCamelCase     =  [
    'facebook/regnet-y-040',
    # See all regnet models at https://huggingface.co/models?filter=regnet
]


class 			lowerCamelCase_		(			tf.keras.layers.Layer   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = 3       ,		UpperCAmelCase__ = 1       ,		UpperCAmelCase__ = 1       ,		UpperCAmelCase__ = "relu"       ,		**UpperCAmelCase__       ,		):
								super().__init__(**UpperCAmelCase__     )
								# The padding and conv has been verified in
								# https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
								SCREAMING_SNAKE_CASE__     							=				tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2     )
								SCREAMING_SNAKE_CASE__     							=				tf.keras.layers.ConvaD(
								    filters=UpperCAmelCase__       ,		kernel_size=UpperCAmelCase__       ,		strides=UpperCAmelCase__       ,		padding="VALID"       ,		groups=UpperCAmelCase__       ,		use_bias=UpperCAmelCase__       ,		name="convolution"       ,		)
								SCREAMING_SNAKE_CASE__     							=				tf.keras.layers.BatchNormalization(epsilon=1e-5       ,		momentum=0.9       ,		name="normalization"     )
								SCREAMING_SNAKE_CASE__     							=				ACTaFN[activation] if activation is not None else tf.identity






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				self.convolution(self.padding(UpperCAmelCase__     )     )
								SCREAMING_SNAKE_CASE__     							=				self.normalization(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				self.activation(UpperCAmelCase__     )
								return hidden_state


class 			lowerCamelCase_		(			tf.keras.layers.Layer   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		**UpperCAmelCase__     ):
								super().__init__(**UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				config.num_channels
								SCREAMING_SNAKE_CASE__     							=				TFRegNetConvLayer(
								    out_channels=config.embedding_size       ,		kernel_size=3       ,		stride=2       ,		activation=config.hidden_act       ,		name="embedder"       ,		)






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				shape_list(UpperCAmelCase__     )[1]
								if tf.executing_eagerly() and num_channels != self.num_channels:
												raise ValueError(
												    "Make sure that the channel dimension of the pixel values match with the one set in the configuration."     )

								# When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
								# So change the input format from `NCHW` to `NHWC`.
								# shape = (batch_size, in_height, in_width, in_channels=num_channels)
								SCREAMING_SNAKE_CASE__     							=				tf.transpose(UpperCAmelCase__       ,		perm=(0, 2, 3, 1)     )
								SCREAMING_SNAKE_CASE__     							=				self.embedder(UpperCAmelCase__     )
								return hidden_state


class 			lowerCamelCase_		(			tf.keras.layers.Layer   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = 2       ,		**UpperCAmelCase__     ):
								super().__init__(**UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				tf.keras.layers.ConvaD(
								    filters=UpperCAmelCase__       ,		kernel_size=1       ,		strides=UpperCAmelCase__       ,		use_bias=UpperCAmelCase__       ,		name="convolution"     )
								SCREAMING_SNAKE_CASE__     							=				tf.keras.layers.BatchNormalization(epsilon=1e-5       ,		momentum=0.9       ,		name="normalization"     )






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = False     ):
								return self.normalization(self.convolution(UpperCAmelCase__     )       ,		training=UpperCAmelCase__     )


class 			lowerCamelCase_		(			tf.keras.layers.Layer   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		**UpperCAmelCase__     ):
								super().__init__(**UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCAmelCase__       ,		name="pooler"     )
								SCREAMING_SNAKE_CASE__     							=				[
								    tf.keras.layers.ConvaD(filters=UpperCAmelCase__       ,		kernel_size=1       ,		activation="relu"       ,		name="attention.0"     ),
								    tf.keras.layers.ConvaD(filters=UpperCAmelCase__       ,		kernel_size=1       ,		activation="sigmoid"       ,		name="attention.2"     ),
								]






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								# [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
								SCREAMING_SNAKE_CASE__     							=				self.pooler(UpperCAmelCase__     )
								for layer_module in self.attention:
												SCREAMING_SNAKE_CASE__     							=				layer_module(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				hidden_state * pooled
								return hidden_state


class 			lowerCamelCase_		(			tf.keras.layers.Layer   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = 1       ,		**UpperCAmelCase__     ):
								super().__init__(**UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				in_channels != out_channels or stride != 1
								SCREAMING_SNAKE_CASE__     							=				max(1       ,		out_channels // config.groups_width     )
								SCREAMING_SNAKE_CASE__     							=				(
								    TFRegNetShortCut(UpperCAmelCase__       ,		stride=UpperCAmelCase__       ,		name="shortcut"     )
								    if should_apply_shortcut
								    else tf.keras.layers.Activation("linear"       ,		name="shortcut"     )
								)
								# `self.layers` instead of `self.layer` because that is a reserved argument.
								SCREAMING_SNAKE_CASE__     							=				[
								    TFRegNetConvLayer(UpperCAmelCase__       ,		kernel_size=1       ,		activation=config.hidden_act       ,		name="layer.0"     ),
								    TFRegNetConvLayer(
								        UpperCAmelCase__       ,		stride=UpperCAmelCase__       ,		groups=UpperCAmelCase__       ,		activation=config.hidden_act       ,		name="layer.1"     ),
								    TFRegNetConvLayer(UpperCAmelCase__       ,		kernel_size=1       ,		activation=UpperCAmelCase__       ,		name="layer.2"     ),
								]
								SCREAMING_SNAKE_CASE__     							=				ACTaFN[config.hidden_act]






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				hidden_state
								for layer_module in self.layers:
												SCREAMING_SNAKE_CASE__     							=				layer_module(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				self.shortcut(UpperCAmelCase__     )
								hidden_state += residual
								SCREAMING_SNAKE_CASE__     							=				self.activation(UpperCAmelCase__     )
								return hidden_state


class 			lowerCamelCase_		(			tf.keras.layers.Layer   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = 1       ,		**UpperCAmelCase__     ):
								super().__init__(**UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				in_channels != out_channels or stride != 1
								SCREAMING_SNAKE_CASE__     							=				max(1       ,		out_channels // config.groups_width     )
								SCREAMING_SNAKE_CASE__     							=				(
								    TFRegNetShortCut(UpperCAmelCase__       ,		stride=UpperCAmelCase__       ,		name="shortcut"     )
								    if should_apply_shortcut
								    else tf.keras.layers.Activation("linear"       ,		name="shortcut"     )
								)
								SCREAMING_SNAKE_CASE__     							=				[
								    TFRegNetConvLayer(UpperCAmelCase__       ,		kernel_size=1       ,		activation=config.hidden_act       ,		name="layer.0"     ),
								    TFRegNetConvLayer(
								        UpperCAmelCase__       ,		stride=UpperCAmelCase__       ,		groups=UpperCAmelCase__       ,		activation=config.hidden_act       ,		name="layer.1"     ),
								    TFRegNetSELayer(UpperCAmelCase__       ,		reduced_channels=int(round(in_channels / 4     )     )       ,		name="layer.2"     ),
								    TFRegNetConvLayer(UpperCAmelCase__       ,		kernel_size=1       ,		activation=UpperCAmelCase__       ,		name="layer.3"     ),
								]
								SCREAMING_SNAKE_CASE__     							=				ACTaFN[config.hidden_act]






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				hidden_state
								for layer_module in self.layers:
												SCREAMING_SNAKE_CASE__     							=				layer_module(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				self.shortcut(UpperCAmelCase__     )
								hidden_state += residual
								SCREAMING_SNAKE_CASE__     							=				self.activation(UpperCAmelCase__     )
								return hidden_state


class 			lowerCamelCase_		(			tf.keras.layers.Layer   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = 2       ,		UpperCAmelCase__ = 2       ,		**UpperCAmelCase__     ):
								super().__init__(**UpperCAmelCase__     )

								SCREAMING_SNAKE_CASE__     							=				TFRegNetXLayer if config.layer_type == "x" else TFRegNetYLayer
								SCREAMING_SNAKE_CASE__     							=				[
								    # downsampling is done in the first layer with stride of 2
								    layer(UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		stride=UpperCAmelCase__       ,		name="layers.0"     ),
								    *[layer(UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		name=f'''layers.{i+1}'''     ) for i in range(depth - 1     )],
								]






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								for layer_module in self.layers:
												SCREAMING_SNAKE_CASE__     							=				layer_module(UpperCAmelCase__     )
								return hidden_state


class 			lowerCamelCase_		(			tf.keras.layers.Layer   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		**UpperCAmelCase__     ):
								super().__init__(**UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				[]
								# based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
								self.stages.append(
								    TFRegNetStage(
								        UpperCAmelCase__       ,		config.embedding_size       ,		config.hidden_sizes[0]       ,		stride=2 if config.downsample_in_first_stage else 1       ,		depth=config.depths[0]       ,		name="stages.0"       ,		)     )
								SCREAMING_SNAKE_CASE__     							=				zip(config.hidden_sizes       ,		config.hidden_sizes[1:]     )
								for i, ((in_channels, out_channels), depth) in enumerate(zip(UpperCAmelCase__       ,		config.depths[1:]     )     ):
												self.stages.append(TFRegNetStage(UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		depth=UpperCAmelCase__       ,		name=f'''stages.{i+1}'''     )     )






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = False       ,		UpperCAmelCase__ = True     ):
								SCREAMING_SNAKE_CASE__     							=				() if output_hidden_states else None

								for stage_module in self.stages:
												if output_hidden_states:
																SCREAMING_SNAKE_CASE__     							=				hidden_states + (hidden_state,)

												SCREAMING_SNAKE_CASE__     							=				stage_module(UpperCAmelCase__     )

								if output_hidden_states:
												SCREAMING_SNAKE_CASE__     							=				hidden_states + (hidden_state,)

								if not return_dict:
												return tuple(v for v in [hidden_state, hidden_states] if v is not None     )

								return TFBaseModelOutputWithNoAttention(last_hidden_state=UpperCAmelCase__       ,		hidden_states=UpperCAmelCase__     )


@keras_serializable
class 			lowerCamelCase_		(			tf.keras.layers.Layer   ):





				"""simple docstring"""







				_lowerCAmelCase      :      List[str]      							=					RegNetConfig



				def __init__(						self       ,		UpperCAmelCase__       ,		**UpperCAmelCase__     ):
								super().__init__(**UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				config
								SCREAMING_SNAKE_CASE__     							=				TFRegNetEmbeddings(UpperCAmelCase__       ,		name="embedder"     )
								SCREAMING_SNAKE_CASE__     							=				TFRegNetEncoder(UpperCAmelCase__       ,		name="encoder"     )
								SCREAMING_SNAKE_CASE__     							=				tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCAmelCase__       ,		name="pooler"     )






				@unpack_inputs
				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = False       ,		):
								SCREAMING_SNAKE_CASE__     							=				(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								SCREAMING_SNAKE_CASE__     							=				return_dict if return_dict is not None else self.config.use_return_dict

								SCREAMING_SNAKE_CASE__     							=				self.embedder(UpperCAmelCase__       ,		training=UpperCAmelCase__     )

								SCREAMING_SNAKE_CASE__     							=				self.encoder(
								    UpperCAmelCase__       ,		output_hidden_states=UpperCAmelCase__       ,		return_dict=UpperCAmelCase__       ,		training=UpperCAmelCase__     )

								SCREAMING_SNAKE_CASE__     							=				encoder_outputs[0]
								SCREAMING_SNAKE_CASE__     							=				self.pooler(UpperCAmelCase__     )

								# Change to NCHW output format have uniformity in the modules
								SCREAMING_SNAKE_CASE__     							=				tf.transpose(UpperCAmelCase__       ,		perm=(0, 3, 1, 2)     )
								SCREAMING_SNAKE_CASE__     							=				tf.transpose(UpperCAmelCase__       ,		perm=(0, 3, 1, 2)     )

								# Change the other hidden state outputs to NCHW as well
								if output_hidden_states:
												SCREAMING_SNAKE_CASE__     							=				tuple([tf.transpose(UpperCAmelCase__       ,		perm=(0, 3, 1, 2)     ) for h in encoder_outputs[1]]     )

								if not return_dict:
												return (last_hidden_state, pooled_output) + encoder_outputs[1:]

								return TFBaseModelOutputWithPoolingAndNoAttention(
								    last_hidden_state=UpperCAmelCase__       ,		pooler_output=UpperCAmelCase__       ,		hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states       ,		)


class 			lowerCamelCase_		(			lowercase   ):





				"""simple docstring"""







				_lowerCAmelCase      :      str      							=					RegNetConfig
				_lowerCAmelCase      :      Dict      							=					"regnet"
				_lowerCAmelCase      :      Optional[int]      							=					"pixel_values"



				@property
				def   lowerCAmelCase__		(						self     ):
								return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)       ,		dtype=tf.floataa     )}


_lowerCamelCase     =  R'\n    Parameters:\n    This model is a Tensorflow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and\n    behavior.\n        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n'

_lowerCamelCase     =  R'\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConveNextImageProcessor.__call__`] for details.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n'


@add_start_docstrings(
    "The bare RegNet model outputting raw features without any specific head on top."       ,  lowercase       ,  )
class 			lowerCamelCase_		(			lowercase   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		*UpperCAmelCase__       ,		**UpperCAmelCase__     ):
								super().__init__(UpperCAmelCase__       ,		*UpperCAmelCase__       ,		**UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				TFRegNetMainLayer(UpperCAmelCase__       ,		name="regnet"     )






				@unpack_inputs
				@add_start_docstrings_to_model_forward(UpperCAmelCase__     )
				@add_code_sample_docstrings(
				    checkpoint=_CHECKPOINT_FOR_DOC       ,		output_type=UpperCAmelCase__       ,		config_class=_CONFIG_FOR_DOC       ,		modality="vision"       ,		expected_output=_EXPECTED_OUTPUT_SHAPE       ,		)
				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__=False       ,		):
								SCREAMING_SNAKE_CASE__     							=				(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								SCREAMING_SNAKE_CASE__     							=				return_dict if return_dict is not None else self.config.use_return_dict

								SCREAMING_SNAKE_CASE__     							=				self.regnet(
								    pixel_values=UpperCAmelCase__       ,		output_hidden_states=UpperCAmelCase__       ,		return_dict=UpperCAmelCase__       ,		training=UpperCAmelCase__       ,		)
								if not return_dict:
												return (outputs[0],) + outputs[1:]

								return TFBaseModelOutputWithPoolingAndNoAttention(
								    last_hidden_state=outputs.last_hidden_state       ,		pooler_output=outputs.pooler_output       ,		hidden_states=outputs.hidden_states       ,		)


@add_start_docstrings(
    "\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "       ,  lowercase       ,  )
class 			lowerCamelCase_		(			lowercase       ,  lowercase   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		*UpperCAmelCase__       ,		**UpperCAmelCase__     ):
								super().__init__(UpperCAmelCase__       ,		*UpperCAmelCase__       ,		**UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				config.num_labels
								SCREAMING_SNAKE_CASE__     							=				TFRegNetMainLayer(UpperCAmelCase__       ,		name="regnet"     )
								# classification head
								SCREAMING_SNAKE_CASE__     							=				[
								    tf.keras.layers.Flatten(),
								    tf.keras.layers.Dense(config.num_labels       ,		name="classifier.1"     ) if config.num_labels > 0 else tf.identity,
								]






				@unpack_inputs
				@add_start_docstrings_to_model_forward(UpperCAmelCase__     )
				@add_code_sample_docstrings(
				    checkpoint=_IMAGE_CLASS_CHECKPOINT       ,		output_type=UpperCAmelCase__       ,		config_class=_CONFIG_FOR_DOC       ,		expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT       ,		)
				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__=False       ,		):
								SCREAMING_SNAKE_CASE__     							=				(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								SCREAMING_SNAKE_CASE__     							=				return_dict if return_dict is not None else self.config.use_return_dict

								SCREAMING_SNAKE_CASE__     							=				self.regnet(
								    UpperCAmelCase__       ,		output_hidden_states=UpperCAmelCase__       ,		return_dict=UpperCAmelCase__       ,		training=UpperCAmelCase__     )

								SCREAMING_SNAKE_CASE__     							=				outputs.pooler_output if return_dict else outputs[1]

								SCREAMING_SNAKE_CASE__     							=				self.classifier[0](UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				self.classifier[1](UpperCAmelCase__     )

								SCREAMING_SNAKE_CASE__     							=				None if labels is None else self.hf_compute_loss(labels=UpperCAmelCase__       ,		logits=UpperCAmelCase__     )

								if not return_dict:
												SCREAMING_SNAKE_CASE__     							=				(logits,) + outputs[2:]
												return ((loss,) + output) if loss is not None else output

								return TFSequenceClassifierOutput(loss=UpperCAmelCase__       ,		logits=UpperCAmelCase__       ,		hidden_states=outputs.hidden_states     )




"""simple docstring"""






def __lowercase     (      lowerCamelCase_  :      Tuple  ):
				SCREAMING_SNAKE_CASE__     							=				[]
				SCREAMING_SNAKE_CASE__     							=				[]
				SCREAMING_SNAKE_CASE__     							=				{
				    "^": 3,
				    "*": 2,
				    "/": 2,
				    "%": 2,
				    "+": 1,
				    "-": 1,
				}  # Priority of each operator
				SCREAMING_SNAKE_CASE__     							=				len(lowerCamelCase_  ) if (len(lowerCamelCase_  ) > 7) else 7

				# Print table header for output
				print(
				    "Symbol".center(8  )						,					"Stack".center(lowerCamelCase_  )						,					"Postfix".center(lowerCamelCase_  )						,					sep=" | "						,					)
				print("-" * (print_width * 3 + 7)  )

				for x in infix:
								if x.isalpha() or x.isdigit():
												post_fix.append(lowerCamelCase_  )  # if x is Alphabet / Digit, add it to Postfix
								elif x == "(":
												stack.append(lowerCamelCase_  )  # if x is "(" push to Stack
								elif x == ")":  # if x is ")" pop stack until "(" is encountered
												while stack[-1] != "(":
																post_fix.append(stack.pop()  )  # Pop stack & add the content to Postfix
												stack.pop()
								else:
												if len(lowerCamelCase_  ) == 0:
																stack.append(lowerCamelCase_  )  # If stack is empty, push x to stack
												else:  # while priority of x is not > priority of element in the stack
																while len(lowerCamelCase_  ) > 0 and priority[x] <= priority[stack[-1]]:
																				post_fix.append(stack.pop()  )  # pop stack & add to Postfix
																stack.append(lowerCamelCase_  )  # push x to stack

								print(
								    x.center(8  )						,					("".join(lowerCamelCase_  )).ljust(lowerCamelCase_  )						,					("".join(lowerCamelCase_  )).ljust(lowerCamelCase_  )						,					sep=" | "						,					)  # Output in tabular format

				while len(lowerCamelCase_  ) > 0:  # while stack is not empty
								post_fix.append(stack.pop()  )  # pop stack & add to Postfix
								print(
								    " ".center(8  )						,					("".join(lowerCamelCase_  )).ljust(lowerCamelCase_  )						,					("".join(lowerCamelCase_  )).ljust(lowerCamelCase_  )						,					sep=" | "						,					)  # Output in tabular format

				return "".join(lowerCamelCase_  )  # return Postfix as str


def __lowercase     (      lowerCamelCase_  :      str  ):
				SCREAMING_SNAKE_CASE__     							=				list(infix[::-1]  )  # reverse the infix equation

				for i in range(len(lowerCamelCase_  )  ):
								if infix[i] == "(":
												SCREAMING_SNAKE_CASE__     							=				")"  # change "(" to ")"
								elif infix[i] == ")":
												SCREAMING_SNAKE_CASE__     							=				"("  # change ")" to "("

				return (infix_2_postfix("".join(lowerCamelCase_  )  ))[
				    ::-1
				]  # call infix_2_postfix on Infix, return reverse of Postfix


if __name__ == "__main__":
	_lowerCamelCase     =  input('\nEnter an Infix Equation = ')  # Input an Infix equation
	_lowerCamelCase     =  ''.join(Infix.split())  # Remove spaces from the input
	print('\n\t', Infix, '(Infix) -> ', infix_2_prefix(Infix), '(Prefix)')
