




# Lint as: python3
# pylint: enable=line-too-long
# pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position

lowerCamelCase__					:  int      							=				'2.13.1'

import platform

import pyarrow
from packaging import version


if version.parse(platform.python_version()) < version.parse('3.7'):
   raise ImportWarning(
       'To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.'
   )

if version.parse(pyarrow.__version__).major < 8:
   raise ImportWarning(
       'To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n'
       'If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.'
   )

del platform
del pyarrow
del version

from .arrow_dataset import Dataset
from .arrow_reader import ReadInstruction
from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder
from .combine import concatenate_datasets, interleave_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .download import *
from .features import *
from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled
from .info import DatasetInfo, MetricInfo
from .inspect import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
    list_datasets,
    list_metrics,
)
from .iterable_dataset import IterableDataset
from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric
from .metric import Metric
from .splits import (
    NamedSplit,
    NamedSplitAll,
    Split,
    SplitBase,
    SplitDict,
    SplitGenerator,
    SplitInfo,
    SubSplitInfo,
    percent,
)
from .tasks import *
from .utils import *
from .utils import logging


# deprecated modules
from datasets import arrow_dataset as _arrow_dataset  # isort:skip
from datasets import utils as _utils  # isort:skip
from datasets.utils import download_manager as _deprecated_download_manager  # isort:skip

lowerCamelCase__					:  int      							=				concatenate_datasets
lowerCamelCase__					:  List[Any]      							=				DownloadConfig
lowerCamelCase__					:  int      							=				DownloadManager
lowerCamelCase__					:  List[str]      							=				DownloadMode
lowerCamelCase__					:  List[str]      							=				DownloadConfig
lowerCamelCase__					:  int      							=				DownloadMode
lowerCamelCase__					:  List[Any]      							=				DownloadManager

del _arrow_dataset, _utils, _deprecated_download_manager





import operator as op

def    UpperCAmelCase_				( __UpperCAmelCase		:      str				)   ->					Any:
      SCREAMING_SNAKE_CASE_      		=     []
      SCREAMING_SNAKE_CASE_      		=     lambda __UpperCAmelCase     ,     __UpperCAmelCase				: int(x / y				)  # noqa: E731 integer division operation
      SCREAMING_SNAKE_CASE_      		=     {
          '^': op.pow,
          '*': op.mul,
          '/': div,
          '+': op.add,
          '-': op.sub,
      }  # operators & their respective operation

      # print table header
      print('Symbol'.center(8				)     ,     'Action'.center(12				)     ,     'Stack'     ,     sep=' | '				)
      print('-' * (30 + len(__UpperCAmelCase				))				)

      for x in post_fix:
            if x.isdigit():  # if x in digit
                  stack.append(__UpperCAmelCase				)  # append x to stack
                  # output in tabular format
                  print(x.rjust(8				)     ,     ('push(' + x + ')').ljust(12				)     ,     ','.join(__UpperCAmelCase				)     ,     sep=' | '				)
            else:
                  SCREAMING_SNAKE_CASE_      		=     stack.pop()  # pop stack
                  # output in tabular format
                  print(''.rjust(8				)     ,     ('pop(' + b + ')').ljust(12				)     ,     ','.join(__UpperCAmelCase				)     ,     sep=' | '				)

                  SCREAMING_SNAKE_CASE_      		=     stack.pop()  # pop stack
                  # output in tabular format
                  print(''.rjust(8				)     ,     ('pop(' + a + ')').ljust(12				)     ,     ','.join(__UpperCAmelCase				)     ,     sep=' | '				)

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

      return int(stack[0]				)


if __name__ == "__main__":
   lowerCamelCase__					:  Tuple      							=				input('\n\nEnter a Postfix Equation (space separated) = ').split(' ')
   print('\n\tResult = ', solve(Postfix))