




'''simple docstring'''


def 		_lowerCAmelCase							(   lowercase							: int = 1_0					,  lowercase							: int = 1_0_0_0					,  lowercase							: bool = True    )			->int:
   """simple docstring"""




   assert (
       isinstance(__UpperCAmelCase					,  __UpperCAmelCase    )
       and isinstance(__UpperCAmelCase					,  __UpperCAmelCase    )
       and isinstance(__UpperCAmelCase					,  __UpperCAmelCase    )
   ), "Invalid type of value(s) specified to function!"

   if min_val > max_val:
      raise ValueError('''Invalid value for min_val or max_val (min_value < max_value)'''    )
   return min_val if option else max_val






def 		_lowerCAmelCase							(   lowercase							: int					,  lowercase							: int    )			->int:
   """simple docstring"""




   return int((number_a + number_a) / 2    )






def 		_lowerCAmelCase							(   lowercase							: int					,  lowercase							: int					,  lowercase							: int    )			->None:
   """simple docstring"""




   assert (
       isinstance(__UpperCAmelCase					,  __UpperCAmelCase    ) and isinstance(__UpperCAmelCase					,  __UpperCAmelCase    ) and isinstance(__UpperCAmelCase					,  __UpperCAmelCase    )
   ), 'argument values must be type of "int"'

   if lower > higher:
      raise ValueError('''argument value for lower and higher must be(lower > higher)'''    )

   if not lower < to_guess < higher:
      raise ValueError(
          '''guess value must be within the range of lower and higher value'''    )

   def answer(lowercase							: int    ) -> str:
      if number > to_guess:
         return "high"
      elif number < to_guess:
         return "low"
      else:
         return "same"

   print('''started...'''    )

   lowercase__       							=							lower
   lowercase__       							=							higher

   lowercase__       							=							[]

   while True:
      lowercase__       							=							get_avg(__UpperCAmelCase					,  __UpperCAmelCase    )
      last_numbers.append(__UpperCAmelCase    )

      if answer(__UpperCAmelCase    ) == "low":
         lowercase__       							=							number
      elif answer(__UpperCAmelCase    ) == "high":
         lowercase__       							=							number
      else:
         break

   print(F'''guess the number : {last_numbers[-1]}'''    )
   print(F'''details : {last_numbers!s}'''    )






def 		_lowerCAmelCase							(   )			->None:
   """simple docstring"""




   lowercase__       							=							int(input('''Enter lower value : '''    ).strip()    )
   lowercase__       							=							int(input('''Enter high value : '''    ).strip()    )
   lowercase__       							=							int(input('''Enter value to guess : '''    ).strip()    )
   guess_the_number(__UpperCAmelCase					,  __UpperCAmelCase					,  __UpperCAmelCase    )


if __name__ == "__main__":
  main()










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