




from __future__ import annotations

from abc import abstractmethod
from collections.abc import Iterable
from typing import Generic, Protocol, TypeVar

class      UpperCAmelCase						(			A   ):






   @abstractmethod
   def __lt__(	self   :       T						,					UpperCamelCase_   :       T     )->			bool:
     pass






   @abstractmethod
   def __gt__(	self   :       T						,					UpperCamelCase_   :       T     )->			bool:
     pass






   @abstractmethod
   def __eq__(	self   :       T						,					UpperCamelCase_   :       object     )->			bool:
     pass
UpperCAmelCase__						:       int							=    TypeVar('T', bound=Comparable)

class      UpperCAmelCase						(			Generic[T]   ):






   def __init__(	self   :       Any     )->			None:
     _lowercase: list[T]						     =    []
     _lowercase: int						     =    0






   def __repr__(	self   :       List[str]     )->			str:
     return str(self.h     )






   def  _a						(	self   :       Dict						,					UpperCamelCase_   :       int     )->			int | None:
     if child_idx > 0:
       return (child_idx - 1) // 2
     return None






   def  _a						(	self   :       Tuple						,					UpperCamelCase_   :       int     )->			int | None:
     _lowercase: Any						     =    2 * parent_idx + 1
     if left_child_index < self.heap_size:
       return left_child_index
     return None






   def  _a						(	self   :       str						,					UpperCamelCase_   :       int     )->			int | None:
     _lowercase: Tuple						     =    2 * parent_idx + 2
     if right_child_index < self.heap_size:
       return right_child_index
     return None






   def  _a						(	self   :       Optional[Any]						,					UpperCamelCase_   :       int     )->			None:
     if index < self.heap_size:
       _lowercase: int						     =    index
       _lowercase: Dict						     =    self.left_child_idx(UpperCamelCase_     )
       _lowercase: Optional[Any]						     =    self.right_child_idx(UpperCamelCase_     )
       # check which child is larger than its parent
       if left_child is not None and self.h[left_child] > self.h[violation]:
         _lowercase: Union[str, Any]						     =    left_child
       if right_child is not None and self.h[right_child] > self.h[violation]:
         _lowercase: List[Any]						     =    right_child
       # if violation indeed exists
       if violation != index:
         # swap to fix the violation
         _lowercase     ,					_lowercase: Any						     =    self.h[index], self.h[violation]
         # fix the subsequent violation recursively if any
         self.max_heapify(UpperCamelCase_     )






   def  _a						(	self   :       str						,					UpperCamelCase_   :       Iterable[T]     )->			None:
     _lowercase: Tuple						     =    list(UpperCamelCase_     )
     _lowercase: List[str]						     =    len(self.h     )
     if self.heap_size > 1:
       # max_heapify from right to left but exclude leaves (last level)
       for i in range(self.heap_size // 2 - 1						,					-1						,					-1     ):
         self.max_heapify(UpperCamelCase_     )






   def  _a						(	self   :       Union[str, Any]     )->			T:
     if self.heap_size >= 2:
       _lowercase: Optional[int]						     =    self.h[0]
       _lowercase: int						     =    self.h.pop(-1     )
       self.heap_size -= 1
       self.max_heapify(0     )
       return me
     elif self.heap_size == 1:
       self.heap_size -= 1
       return self.h.pop(-1     )
     else:
       raise Exception('Empty heap'     )






   def  _a						(	self   :       Union[str, Any]						,					UpperCamelCase_   :       T     )->			None:
     self.h.append(UpperCamelCase_     )
     _lowercase: int						     =    (self.heap_size - 1) // 2
     self.heap_size += 1
     while idx >= 0:
       self.max_heapify(UpperCamelCase_     )
       _lowercase: Any						     =    (idx - 1) // 2






   def  _a						(	self   :       str     )->			None:
     _lowercase: Any						     =    self.heap_size
     for j in range(size - 1						,					0						,					-1     ):
       _lowercase     ,					_lowercase: int						     =    self.h[j], self.h[0]
       self.heap_size -= 1
       self.max_heapify(0     )
     _lowercase: List[str]						     =    size


if __name__ == "__main__":
   import doctest

   # run doc test
   doctest.testmod()

   # demo
   for unsorted in [
       [0],
       [2],
       [3, 5],
       [5, 3],
       [5, 5],
       [0, 0, 0, 0],
       [1, 1, 1, 1],
       [2, 2, 3, 5],
       [0, 2, 2, 3, 5],
       [2, 5, 3, 0, 2, 3, 0, 3],
       [6, 1, 2, 7, 9, 3, 4, 5, 10, 8],
       [103, 9, 1, 7, 11, 15, 25, 201, 209, 107, 5],
       [-45, -2, -5],
   ]:
      print(f'''unsorted array: {unsorted}''')

      UpperCAmelCase__						:       Heap[int]							=    Heap()
      heap.build_max_heap(unsorted)
      print(f'''after build heap: {heap}''')

      print(f'''max value: {heap.extract_max()}''')
      print(f'''after max value removed: {heap}''')

      heap.insert(100)
      print(f'''after new value 100 inserted: {heap}''')

      heap.heap_sort()
      print(f'''heap-sorted array: {heap}\n''')






from __future__ import annotations

from pathlib import Path


def 		_lowerCamelCase				(					UpperCamelCase					,     UpperCamelCase							)			->		int:





  """simple docstring"""





  return pointa[0] * pointa[1] - pointa[1] * pointa[0]


def 		_lowerCamelCase				(					UpperCamelCase					,     UpperCamelCase					,     UpperCamelCase					,     UpperCamelCase					,     UpperCamelCase					,     UpperCamelCase							)			->		bool:





  """simple docstring"""





  _lowercase: tuple[int, int]						     =    (xa, ya)
  _lowercase: tuple[int, int]						     =    (xa - xa, ya - ya)
  _lowercase: tuple[int, int]						     =    (xa - xa, ya - ya)
  _lowercase: float						     =    -vector_product(UpperCamelCase					,     UpperCamelCase							) / vector_product(
      UpperCamelCase					,     UpperCamelCase							)
  _lowercase: float						     =    +vector_product(UpperCamelCase					,     UpperCamelCase							) / vector_product(
      UpperCamelCase					,     UpperCamelCase							)

  return a > 0 and b > 0 and a + b < 1


def 		_lowerCamelCase				(					UpperCamelCase = "p102_triangles.txt"							)			->		int:





  """simple docstring"""





  _lowercase: str						     =    Path(UpperCamelCase							).parent.joinpath(UpperCamelCase							).read_text(encoding='utf-8'							)

  _lowercase: list[list[int]]						     =    []
  for line in data.strip().split('\n'							):
    triangles.append([int(UpperCamelCase							) for number in line.split(','							)]							)

  _lowercase: int						     =    0
  _lowercase: list[int]

  for triangle in triangles:
    ret += contains_origin(*UpperCamelCase							)

  return ret


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