





"""simple docstring"""
class 					_SCREAMING_SNAKE_CASE:




       def __init__(						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      Tuple:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :str						=  name
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  val




       def __str__(						self							)			->      List[Any]:





             """simple docstring"""






             return f'''{self.__class__.__name__}({self.name}, {self.val})'''




       def __lt__(						self		,SCREAMING_SNAKE_CASE__							)			->      Tuple:





             """simple docstring"""






             return self.val < other.val






class 					_SCREAMING_SNAKE_CASE:




       def __init__(						self		,SCREAMING_SNAKE_CASE__							)			->      List[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Optional[Any]						=  {}
             __SCREAMING_SNAKE_CASE   :List[Any]						=  {}
             __SCREAMING_SNAKE_CASE   :Any						=  self.build_heap(SCREAMING_SNAKE_CASE__							)




       def __getitem__(						self		,SCREAMING_SNAKE_CASE__							)			->      Dict:





             """simple docstring"""






             return self.get_value(SCREAMING_SNAKE_CASE__							)




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__							)			->      Optional[Any]:





             """simple docstring"""






             return (idx - 1) // 2




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__							)			->      Optional[Any]:





             """simple docstring"""






             return idx * 2 + 1




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__							)			->      Optional[Any]:





             """simple docstring"""






             return idx * 2 + 2




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__							)			->      Tuple:





             """simple docstring"""






             return self.heap_dict[key]




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__							)			->      Any:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Dict						=  len(SCREAMING_SNAKE_CASE__							) - 1
             __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  self.get_parent_idx(SCREAMING_SNAKE_CASE__							)

             for idx, i in enumerate(SCREAMING_SNAKE_CASE__							):
                   __SCREAMING_SNAKE_CASE   :int						=  idx
                   __SCREAMING_SNAKE_CASE   :Optional[int]						=  i.val

             for i in range(SCREAMING_SNAKE_CASE__		,-1		,-1							):
                   self.sift_down(SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)
             return array




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      Dict:





             """simple docstring"""






             while True:
                   __SCREAMING_SNAKE_CASE   :str						=  self.get_left_child_idx(SCREAMING_SNAKE_CASE__							)  # noqa: E741
                   __SCREAMING_SNAKE_CASE   :Optional[Any]						=  self.get_right_child_idx(SCREAMING_SNAKE_CASE__							)

                   __SCREAMING_SNAKE_CASE   :List[Any]						=  idx
                   if l < len(SCREAMING_SNAKE_CASE__							) and array[l] < array[idx]:
                         __SCREAMING_SNAKE_CASE   :Union[str, Any]						=  l
                   if r < len(SCREAMING_SNAKE_CASE__							) and array[r] < array[smallest]:
                         __SCREAMING_SNAKE_CASE   :Dict						=  r

                   if smallest != idx:
                         __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Optional[int]						=  array[smallest], array[idx]
                         (
                             (
                             __SCREAMING_SNAKE_CASE
                         )				,(
                             __SCREAMING_SNAKE_CASE
                         )				,
                         )   :Union[str, Any]						=  (
                             self.idx_of_element[array[smallest]],
                             self.idx_of_element[array[idx]],
                         )
                         __SCREAMING_SNAKE_CASE   :str						=  smallest
                   else:
                         break




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__							)			->      Dict:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE   :Any						=  self.get_parent_idx(SCREAMING_SNAKE_CASE__							)
             while p >= 0 and self.heap[p] > self.heap[idx]:
                   __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Dict						=  self.heap[idx], self.heap[p]
                   __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :int						=  (
                       self.idx_of_element[self.heap[idx]],
                       self.idx_of_element[self.heap[p]],
                   )
                   __SCREAMING_SNAKE_CASE   :Optional[int]						=  p
                   __SCREAMING_SNAKE_CASE   :List[str]						=  self.get_parent_idx(SCREAMING_SNAKE_CASE__							)




       def     _UpperCamelCase     (						self							)			->      Union[str, Any]:





             """simple docstring"""






             return self.heap[0]




       def     _UpperCamelCase     (						self							)			->      Optional[Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Union[str, Any]						=  self.heap[-1], self.heap[0]
             __SCREAMING_SNAKE_CASE				,__SCREAMING_SNAKE_CASE   :Any						=  (
                 self.idx_of_element[self.heap[-1]],
                 self.idx_of_element[self.heap[0]],
             )

             __SCREAMING_SNAKE_CASE   :List[str]						=  self.heap.pop()
             del self.idx_of_element[x]
             self.sift_down(0		,self.heap							)
             return x




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__							)			->      List[str]:





             """simple docstring"""






             self.heap.append(SCREAMING_SNAKE_CASE__							)
             __SCREAMING_SNAKE_CASE   :Dict						=  len(self.heap							) - 1
             __SCREAMING_SNAKE_CASE   :Optional[int]						=  node.val
             self.sift_up(len(self.heap							) - 1							)




       def     _UpperCamelCase     (						self							)			->      str:





             """simple docstring"""






             return len(self.heap							) == 0




       def     _UpperCamelCase     (						self		,SCREAMING_SNAKE_CASE__		,SCREAMING_SNAKE_CASE__							)			->      Any:





             """simple docstring"""






             assert (
                 self.heap[self.idx_of_element[node]].val > new_value
             ), "newValue must be less that current value"
             __SCREAMING_SNAKE_CASE   :Any						=  new_value
             __SCREAMING_SNAKE_CASE   :Dict						=  new_value
             self.sift_up(self.idx_of_element[node]							)




lowerCamelCase_								=		Node("R", -1)
lowerCamelCase_								=		Node("B", 6)
lowerCamelCase_								=		Node("A", 3)
lowerCamelCase_								=		Node("X", 1)
lowerCamelCase_								=		Node("E", 4)

# Use one of these two ways to generate Min-Heap

# Generating Min-Heap from array
lowerCamelCase_								=		MinHeap([r, b, a, x, e])

# Generating Min-Heap by Insert method
# myMinHeap.insert(a)
# myMinHeap.insert(b)
# myMinHeap.insert(x)
# myMinHeap.insert(r)
# myMinHeap.insert(e)

# Before
print("Min Heap - before decrease key")
for i in my_min_heap.heap:
  print(i)

print("Min Heap - After decrease key of node [B -> -17]")
my_min_heap.decrease_key(b, -1_7)

# After
for i in my_min_heap.heap:
  print(i)

if __name__ == "__main__":
  import doctest

  doctest.testmod()






"""simple docstring"""
def      __lowerCamelCase   (							a_     :		Union[str, Any]							)			->      Optional[int]:
      __SCREAMING_SNAKE_CASE   :List[str]						=  1
      __SCREAMING_SNAKE_CASE   :Dict						=  2
      while i * i <= n:
            __SCREAMING_SNAKE_CASE   :Tuple						=  0
            while n % i == 0:
                  n //= i
                  multiplicity += 1
            n_divisors *= multiplicity + 1
            i += 1
      if n > 1:
            n_divisors *= 2
      return n_divisors



def      __lowerCamelCase   (							)			->      int:
      __SCREAMING_SNAKE_CASE   :Dict						=  1
      __SCREAMING_SNAKE_CASE   :Dict						=  1

      while True:
            i += 1
            t_num += i

            if count_divisors(a_							) > 5_00:
                  break

      return t_num


if __name__ == "__main__":
  print(solution())