code: 
  '''simple docstring'''
  
  from typing import List
  
  from tokenizers import NormalizedString, PreTokenizedString, normalizers
  
  
  class   a_  :
  
  
  
  
         def __init__(     self   ,   snake_case_  ):
           _lowerCAmelCase       :  Union[str, Any]   				=					vocab
           _lowerCAmelCase       :  Union[str, Any]   				=					normalizers.BertNormalizer(
               clean_text=snake_case_   ,   handle_chinese_chars=snake_case_   ,   strip_accents=snake_case_   ,   lowercase=snake_case_   ,   )
           try:
             import rjieba
           except ImportError:
             raise ImportError(
                 """You need to install rjieba to use RoFormerTokenizer. """
                 """See https://pypi.org/project/rjieba/ for installation."""  )
           _lowerCAmelCase       :  List[str]   				=					rjieba
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_   ,   snake_case_  ):
           _lowerCAmelCase       :  Union[str, Any]   				=					[]
  
           # this code slice normalized_string is too slow (6s) but test_alignement_methods can pass
           for token, start, end in self.jieba.tokenize(str(snake_case_  )   ,   hmm=snake_case_  ):
             if token in self.vocab:
               splits.append(normalized_string[start:end]  )
             else:
               _lowerCAmelCase       :  str   				=					self.normalizers.normalize_str(snake_case_  ).split()
               for token in token_list:
                 if token:
                   _lowerCAmelCase       :  Union[str, Any]   				=					start + len(snake_case_  )
                   splits.append(normalized_string[start:end]  )
                   _lowerCAmelCase       :  List[Any]   				=					end
  
          # this code test_alignement_methods can't pass but fast (300ms)
          # for token in self.jieba.cut(str(normalized_string), False):
          #     if token in self.vocab:
          #         splits.append(NormalizedString(token))
          #     else:
          #         token_list = self.normalizers.normalize_str(token).split()
          #         for token in token_list:
          #             if token:
          #                 splits.append(NormalizedString(token))
  
           return splits
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_  ):
           pretok.split(self.jieba_split  )
  
  
  
style_context: 
  '''simple docstring'''
  
  import random
  
  
  class   a_  :
  
  
  
  
         def __init__(     self   ,   snake_case_   ,   snake_case_  ):
           _lowerCAmelCase       :  List[str]   				=					x
           _lowerCAmelCase       :  List[str]   				=					y
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           return (self.x**2 + self.y**2) <= 1
  
  
  
  
  
  
  
         @classmethod
         def 							__UpperCamelCase       (     cls  ):
           return cls(x=random.random()   ,   y=random.random()  )
  
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int		)    ->						float:
    if number_of_simulations < 1:
      raise ValueError("""At least one simulation is necessary to estimate PI."""		)
  
    _lowerCAmelCase       :  Tuple   				=					0
    for _ in range(_lowerCamelCase		):
      _lowerCAmelCase       :  Union[str, Any]   				=					Point.random_unit_square()
  
      if random_point.is_in_unit_circle():
        number_in_unit_circle += 1
  
    return 4 * number_in_unit_circle / number_of_simulations
  
  
  if __name__ == "__main__":
       # import doctest
  
       # doctest.testmod()
       from math import pi
  
       UpperCamelCase_     			=       """Please enter the desired number of Monte Carlo simulations: """
       UpperCamelCase_     			=       estimate_pi(int(input(prompt).strip()))
       print(F'An estimate of PI is {my_pi} with an error of {abs(my_pi - pi)}')
  
  
  