






import argparse


UpperCamelCase 				=	"""docs/source/_static/js/custom.js"""

def        __lowerCamelCase			(		snake_case__		)							->  Optional[int]:






						"""simple docstring"""





						with open(UpperCAmelCase_       ,encoding="""utf-8"""       ,newline="""\n"""		) as f:
												_SCREAMING_SNAKE_CASE	      =  f.readlines()
						_SCREAMING_SNAKE_CASE	      =  0

						# First let's put the right version
						while not lines[index].startswith("""const stableVersion ="""		):
												index += 1
						_SCREAMING_SNAKE_CASE	      =  F'const stableVersion = "v{version}"\n'

						# Then update the dictionary
						while not lines[index].startswith("""const versionMapping = {"""		):
												index += 1

						# We go until the end
						while not lines[index].startswith("""}"""		):
												index += 1
						# We add the new version at the end
						lines[index - 1] += F'    "v{version}": "v{version}",\n'

						with open(UpperCAmelCase_       ,"""w"""       ,encoding="""utf-8"""       ,newline="""\n"""		) as f:
												f.writelines(UpperCAmelCase_		)


if __name__ == "__main__":
		UpperCamelCase 				=	argparse.ArgumentParser()
		parser.add_argument('''--version''', help='''Release version.''')
		UpperCamelCase 				=	parser.parse_args()
		update_custom_js(args.version)





'''simple docstring'''

from __future__ import annotations

from typing import Generic, TypeVar

a_  :				List[str]						= TypeVar("""T""")





class      snake_case    (    Generic[T]			):





  """simple docstring"""




  def __init__(    self			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  data
   lowerCamelCase_      =  self
   lowerCamelCase_      =  0





class      snake_case    (    Generic[T]			):





  """simple docstring"""




  def __init__(    self     ):







   """simple docstring"""
   # map from node name to the node object
   lowerCamelCase_      =  {}






  def   snake_case		(    self			,  UpperCamelCase     ):







   """simple docstring"""
   # create a new set with x as its member
   lowerCamelCase_      =  DisjointSetTreeNode(UpperCamelCase     )






  def   snake_case		(    self			,  UpperCamelCase     ):







   """simple docstring"""
   # find the set x belongs to (with path-compression)
   lowerCamelCase_      =  self.map[data]
   if elem_ref != elem_ref.parent:
    lowerCamelCase_      =  self.find_set(elem_ref.parent.data     )
   return elem_ref.parent






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   # helper function for union operation
   if nodea.rank > nodea.rank:
    lowerCamelCase_      =  nodea
   else:
    lowerCamelCase_      =  nodea
    if nodea.rank == nodea.rank:
     nodea.rank += 1







  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   # merge 2 disjoint sets
   self.link(self.find_set(UpperCamelCase     )			,  self.find_set(UpperCamelCase     )     )





class      snake_case    (    Generic[T]			):





  """simple docstring"""




  def __init__(    self     ):







   """simple docstring"""
   # connections: map from the node to the neighbouring nodes (with weights)
   lowerCamelCase_      =  {}






  def   snake_case		(    self			,  UpperCamelCase     ):







   """simple docstring"""
   # add a node ONLY if its not present in the graph
   if node not in self.connections:
    lowerCamelCase_      =  {}






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   # add an edge with the given weight
   self.add_node(UpperCamelCase     )
   self.add_node(UpperCamelCase     )
   lowerCamelCase_      =  weight
   lowerCamelCase_      =  weight







  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  []
   lowerCamelCase_      =  set()
   for start in self.connections:
    for end in self.connections[start]:
     if (start, end) not in seen:
      seen.add((end, start)     )
      edges.append((start, end, self.connections[start][end])     )
   edges.sort(key=lambda UpperCamelCase     : x[2]     )

   # creating the disjoint set
   lowerCamelCase_      =  DisjointSetTree[T]()
   for node in self.connections:
    disjoint_set.make_set(UpperCamelCase     )

   # MST generation
   lowerCamelCase_      =  0
   lowerCamelCase_      =  0
   lowerCamelCase_      =  GraphUndirectedWeighted[T]()
   while num_edges < len(self.connections     ) - 1:
    lowerCamelCase_ ,lowerCamelCase_ ,lowerCamelCase_      =  edges[index]
    index += 1
    lowerCamelCase_      =  disjoint_set.find_set(UpperCamelCase     )
    lowerCamelCase_      =  disjoint_set.find_set(UpperCamelCase     )
    if parent_u != parent_v:
     num_edges += 1
     graph.add_edge(UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     )
     disjoint_set.union(UpperCamelCase			,  UpperCamelCase     )
   return graph



