




from __future__ import annotations

from functools import lru_cache
from math import ceil

lowerCamelCase__					:  Any      							=				100

lowerCamelCase__					:  Optional[Any]      							=				set(range(3, NUM_PRIMES, 2))
primes.add(2)
lowerCamelCase__					:  int

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
   if prime not in primes:
      continue
   primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))

@lru_cache(maxsize=1_00				)
def    UpperCAmelCase_				( __UpperCAmelCase		:      int				)   ->					set[int]:
      if number_to_partition < 0:
            return set()
      elif number_to_partition == 0:
            return {1}

      SCREAMING_SNAKE_CASE_      		=     set()
      SCREAMING_SNAKE_CASE_      		=     42
      SCREAMING_SNAKE_CASE_      		=     42

      for prime in primes:
            if prime > number_to_partition:
                  continue
            for sub in partition(number_to_partition - prime				):
                  ret.add(sub * prime				)

      return ret

def    UpperCAmelCase_				( __UpperCAmelCase		:      int = 50_00				)   ->					int | None:
      for number_to_partition in range(1     ,     __UpperCAmelCase				):
            if len(partition(__UpperCAmelCase				)				) > number_unique_partitions:
                  return number_to_partition
      return None


if __name__ == "__main__":
   print(f'''{solution() = }''')





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))