"""simple docstring"""
from __future__ import annotations

import math
from itertools import permutations







def 		__a  (      _SCREAMING_SNAKE_CASE  )      ->bool:

  if 1 < number < 4:
    # 2 and 3 are primes
    return True
  elif number < 2 or number % 2 == 0 or number % 3 == 0:
    # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
    return False

  # All primes number are in format of 6k +/- 1
  for i in range(5						,	int(math.sqrt(_SCREAMING_SNAKE_CASE  ) + 1  )						,	6  ):
    if number % i == 0 or number % (i + 2) == 0:
      return False
  return True







def 		__a  (      _SCREAMING_SNAKE_CASE = 7  )      ->int:
  a__:	Union[str, Any]     				=      ''.join(str(_SCREAMING_SNAKE_CASE  ) for i in range(1						,	n + 1  )  )
  a__:	Dict     				=      [int(''.join(_SCREAMING_SNAKE_CASE  )  ) for i in permutations(_SCREAMING_SNAKE_CASE						,	_SCREAMING_SNAKE_CASE  )]
  a__:	Dict     				=      [num for num in perm_list if is_prime(_SCREAMING_SNAKE_CASE  )]
  return max(_SCREAMING_SNAKE_CASE  ) if pandigitals else 0


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



lowerCAmelCase      :				Union[str, Any]     			=1000







def     A__	(       __A						):







    '''simple docstring'''
    return x * x







def     A__	(       __A ,			__A ,			__A ,			__A = 4						):







    '''simple docstring'''
    assert callable(
        __A						), F"""the function(object) passed should be callable your input : {function}"""
    assert isinstance(__A ,			(float, int)						), F"""a should be float or integer your input : {a}"""
    assert isinstance(function(__A						) ,			(float, int)						), (
        "the function should return integer or float return type of your function, "
        F"""{type(__A						)}"""
    )
    assert isinstance(__A ,			(float, int)						), F"""b should be float or integer your input : {b}"""
    assert (
        isinstance(__A ,			__A						) and precision > 0
    ), F"""precision should be positive integer your input : {precision}"""

    # just applying the formula of simpson for approximate integration written in
    # mentioned article in first comment of this file and above this function

    _lowerCamelCase  :		Optional[Any]			    =    (b - a) / N_STEPS
    _lowerCamelCase  :		str			    =    function(__A						) + function(__A						)

    for i in range(1 ,			__A						):
        _lowerCamelCase  :		str			    =    a + h * i
        result += function(__A						) * (4 if i % 2 else 2)

    result *= h / 3
    return round(__A ,			__A						)


if __name__ == "__main__":
    import doctest

    doctest.testmod()




