




from __future__ import annotations

from collections.abc import Iterable
class      _UpperCamelCase :
      def __init__(     self				:Union[str, Any]	, lowerCamelCase				:Dict	, lowerCamelCase				:int )       ->     Dict:
       UpperCAmelCase__	,	UpperCAmelCase__								=  float(UpperCamelCase__ ), float(UpperCamelCase__ )
      def __eq__(     self				:str	, lowerCamelCase				:Any )       ->     Optional[int]:
       return self.x == other.x and self.y == other.y
      def __ne__(     self				:int	, lowerCamelCase				:Any )       ->     str:
       return not self == other
      def __gt__(     self				:List[str]	, lowerCamelCase				:Tuple )       ->     List[Any]:






       if self.x > other.x:
        return True
       elif self.x == other.x:
        return self.y > other.y
       return False
      def __lt__(     self				:Any	, lowerCamelCase				:int )       ->     Optional[Any]:
       return not self > other
      def __ge__(     self				:Optional[Any]	, lowerCamelCase				:Union[str, Any] )       ->     int:






       if self.x > other.x:
        return True
       elif self.x == other.x:
        return self.y >= other.y
       return False
      def __le__(     self				:Any	, lowerCamelCase				:Tuple )       ->     Tuple:






       if self.x < other.x:
        return True
       elif self.x == other.x:
        return self.y <= other.y
       return False
      def __repr__(     self				:Union[str, Any] )       ->     int:
       return f'''({self.x}, {self.y})'''







      def __hash__(     self				:List[Any] )       ->     Dict:
       return hash(self.x )



def   lowerCAmelCase						(						_lowerCAmelCase							:				List[str]  ,							):




 """simple docstring"""







 UpperCAmelCase__								=  []
 if list_of_tuples:
  for p in list_of_tuples:
   if isinstance(A_  ,							A_		):
    points.append(A_		)
   else:
    try:
     points.append(Point(p[0]  ,							p[1]		)		)
    except (IndexError, TypeError):
     print(
         F'''Ignoring deformed point {p}. All points'''
         " must have at least 2 coordinates."		)
 return points



def   lowerCAmelCase						(						_lowerCAmelCase							:				Dict		):




 """simple docstring"""







 if not hasattr(A_  ,							"__iter__"		):
  UpperCAmelCase__								=  F'''Expecting an iterable object but got an non-iterable type {points}'''
  raise ValueError(A_		)

 if not points:
  UpperCAmelCase__								=  F'''Expecting a list of points but got {points}'''
  raise ValueError(A_		)

 return _construct_points(A_		)



def   lowerCAmelCase						(						_lowerCAmelCase							:				Union[str, Any]  ,							_lowerCAmelCase							:				Dict  ,							_lowerCAmelCase							:				Any		):




 """simple docstring"""







 UpperCAmelCase__								=  (a.x * b.y + b.x * c.y + c.x * a.y) - (a.y * b.x + b.y * c.x + c.y * a.x)
 return det



def   lowerCAmelCase						(						_lowerCAmelCase							:				Dict		):




 """simple docstring"""







 UpperCAmelCase__								=  sorted(_validate_input(A_		)		)
 UpperCAmelCase__								=  len(A_		)
 UpperCAmelCase__								=  set()

 for i in range(n - 1		):
  for j in range(i + 1  ,							A_		):
   UpperCAmelCase__								=  UpperCAmelCase__								=  False
   UpperCAmelCase__								=  True
   for k in range(A_		):
    if k != i and k != j:
     UpperCAmelCase__								=  _det(points[i]  ,							points[j]  ,							points[k]		)

     if det_k > 0:
      UpperCAmelCase__								=  True
     elif det_k < 0:
      UpperCAmelCase__								=  True
     else:
      # point[i], point[j], point[k] all lie on a straight line
      # if point[k] is to the left of point[i] or it's to the
      # right of point[j], then point[i], point[j] cannot be
      # part of the convex hull of A
      if points[k] < points[i] or points[k] > points[j]:
       UpperCAmelCase__								=  False
       break

    if points_left_of_ij and points_right_of_ij:
     UpperCAmelCase__								=  False
     break

   if ij_part_of_convex_hull:
    convex_set.update([points[i], points[j]]		)

 return sorted(A_		)



def   lowerCAmelCase						(						_lowerCAmelCase							:				Any		):




 """simple docstring"""







 UpperCAmelCase__								=  sorted(_validate_input(A_		)		)
 UpperCAmelCase__								=  len(A_		)

 # divide all the points into an upper hull and a lower hull
 # the left most point and the right most point are definitely
 # members of the convex hull by definition.
 # use these two anchors to divide all the points into two hulls,
 # an upper hull and a lower hull.

 # all points to the left (above) the line joining the extreme points belong to the
 # upper hull
 # all points to the right (below) the line joining the extreme points below to the
 # lower hull
 # ignore all points on the line joining the extreme points since they cannot be
 # part of the convex hull

 UpperCAmelCase__								=  points[0]
 UpperCAmelCase__								=  points[n - 1]

 UpperCAmelCase__								=  {left_most_point, right_most_point}
 UpperCAmelCase__								=  []
 UpperCAmelCase__								=  []

 for i in range(1  ,							n - 1		):
  UpperCAmelCase__								=  _det(A_  ,							A_  ,							points[i]		)

  if det > 0:
   upper_hull.append(points[i]		)
  elif det < 0:
   lower_hull.append(points[i]		)

 _construct_hull(A_  ,							A_  ,							A_  ,							A_		)
 _construct_hull(A_  ,							A_  ,							A_  ,							A_		)

 return sorted(A_		)



def   lowerCAmelCase						(						_lowerCAmelCase							:				Any  ,							_lowerCAmelCase							:				Optional[Any]  ,							_lowerCAmelCase							:				Union[str, Any]  ,							_lowerCAmelCase							:				List[str]		):




 """simple docstring"""







 if points:
  UpperCAmelCase__								=  None
  UpperCAmelCase__								=  float("-inf"		)
  UpperCAmelCase__								=  []

  for p in points:
   UpperCAmelCase__								=  _det(A_  ,							A_  ,							A_		)

   if det > 0:
    candidate_points.append(A_		)

    if det > extreme_point_distance:
     UpperCAmelCase__								=  det
     UpperCAmelCase__								=  p

  if extreme_point:
   _construct_hull(A_  ,							A_  ,							A_  ,							A_		)
   convex_set.add(A_		)
   _construct_hull(A_  ,							A_  ,							A_  ,							A_		)



def   lowerCAmelCase						(						_lowerCAmelCase							:				Any		):




 """simple docstring"""







 UpperCAmelCase__								=  sorted(_validate_input(A_		)		)
 UpperCAmelCase__								=  len(A_		)

 UpperCAmelCase__								=  points[:2]
 for i in range(2  ,							A_		):
  UpperCAmelCase__								=  _det(convex_hull[1]  ,							convex_hull[0]  ,							points[i]		)
  if det > 0:
   convex_hull.insert(0  ,							points[i]		)
   break
  elif det < 0:
   convex_hull.append(points[i]		)
   break
  else:
   UpperCAmelCase__								=  points[i]
 i += 1

 for j in range(A_  ,							A_		):
  if (
      _det(convex_hull[0]  ,							convex_hull[-1]  ,							points[j]		) > 0
      and _det(convex_hull[-1]  ,							convex_hull[0]  ,							points[1]		) < 0
  ):
   # The point lies within the convex hull
   continue

  convex_hull.insert(0  ,							points[j]		)
  convex_hull.append(points[j]		)
  while _det(convex_hull[0]  ,							convex_hull[1]  ,							convex_hull[2]		) >= 0:
   del convex_hull[1]
  while _det(convex_hull[-1]  ,							convex_hull[-2]  ,							convex_hull[-3]		) <= 0:
   del convex_hull[-2]

  # `convex_hull` is contains the convex hull in circular order
 return sorted(convex_hull[1:] if len(A_		) > 3 else convex_hull		)



def   lowerCAmelCase						(						):




 """simple docstring"""







 UpperCAmelCase__								=  [
     (0, 3),
     (2, 2),
     (1, 1),
     (2, 1),
     (3, 0),
     (0, 0),
     (3, 3),
     (2, -1),
     (2, -4),
     (1, -3),
 ]
 # the convex set of points is
 # [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
 UpperCAmelCase__								=  convex_hull_bf(A_		)

 UpperCAmelCase__								=  convex_hull_recursive(A_		)
 assert results_bf == results_recursive

 UpperCAmelCase__								=  convex_hull_melkman(A_		)
 assert results_bf == results_melkman

 print(A_		)


if __name__ == "__main__":
  main()






from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_lowerCAmelCase  :				Dict						=				logging.get_logger(__name__)

_lowerCAmelCase  :				Optional[int]						=				{
    "google/rembert": "https://huggingface.co/google/rembert/resolve/main/config.json",
    # See all RemBERT models at https://huggingface.co/models?filter=rembert
}
class      _UpperCamelCase (			lowerCAmelCase						):
      UpperCAmelCase_            =						"""rembert"""
      def __init__(     self				:Union[str, Any]	, lowerCamelCase				:Union[str, Any]=25_0300	, lowerCamelCase				:Optional[Any]=1152	, lowerCamelCase				:Optional[int]=32	, lowerCamelCase				:Union[str, Any]=18	, lowerCamelCase				:str=256	, lowerCamelCase				:Any=1664	, lowerCamelCase				:Any=4608	, lowerCamelCase				:List[str]="gelu"	, lowerCamelCase				:Optional[Any]=0.0	, lowerCamelCase				:Optional[int]=0.0	, lowerCamelCase				:Dict=0.1	, lowerCamelCase				:List[str]=512	, lowerCamelCase				:int=2	, lowerCamelCase				:str=0.02	, lowerCamelCase				:Optional[int]=1e-12	, lowerCamelCase				:List[Any]=True	, lowerCamelCase				:Optional[Any]=0	, lowerCamelCase				:Optional[Any]=312	, lowerCamelCase				:int=313	, **lowerCamelCase				:Dict	, )       ->     Any:
       super().__init__(pad_token_id=lowerCamelCase	, bos_token_id=lowerCamelCase	, eos_token_id=lowerCamelCase	, **lowerCamelCase )

       UpperCAmelCase__								=  vocab_size
       UpperCAmelCase__								=  input_embedding_size
       UpperCAmelCase__								=  output_embedding_size
       UpperCAmelCase__								=  max_position_embeddings
       UpperCAmelCase__								=  hidden_size
       UpperCAmelCase__								=  num_hidden_layers
       UpperCAmelCase__								=  num_attention_heads
       UpperCAmelCase__								=  intermediate_size
       UpperCAmelCase__								=  hidden_act
       UpperCAmelCase__								=  hidden_dropout_prob
       UpperCAmelCase__								=  attention_probs_dropout_prob
       UpperCAmelCase__								=  classifier_dropout_prob
       UpperCAmelCase__								=  initializer_range
       UpperCAmelCase__								=  type_vocab_size
       UpperCAmelCase__								=  layer_norm_eps
       UpperCAmelCase__								=  use_cache
       UpperCAmelCase__								=  False



class      _UpperCamelCase (			lowerCAmelCase						):
      @property
      def 		UpperCAmelCase_  (     self				:List[Any] )       ->     Mapping[str, Mapping[int, str]]:
       if self.task == "multiple-choice":
        UpperCAmelCase__								=  {0: "batch", 1: "choice", 2: "sequence"}
       else:
        UpperCAmelCase__								=  {0: "batch", 1: "sequence"}
       return OrderedDict(
           [
               ("input_ids", dynamic_axis),
               ("attention_mask", dynamic_axis),
               ("token_type_ids", dynamic_axis),
           ] )







      @property
      def 		UpperCAmelCase_  (     self				:Union[str, Any] )       ->     float:
       return 1e-4





