



"""simple docstring"""
from __future__ import annotations

import os
from collections.abc import Mapping

A:     Union[str, Any]										=	tuple[int, int]



class    SCREAMING_SNAKE_CASE__						:

   def __init__(     self   ,  _SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE		)						->   None:





    '''simple docstring'''




    UpperCAmelCase			:      set[int]			=			vertices
    UpperCAmelCase			:      dict[EdgeT, int]			=			{
        (min(_SCREAMING_SNAKE_CASE		), max(_SCREAMING_SNAKE_CASE		)): weight for edge, weight in edges.items()
    }

   def 			SCREAMING_SNAKE_CASE  (     self   ,  _SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE		)						->   None:





    '''simple docstring'''




    self.vertices.add(edge[0]		)
    self.vertices.add(edge[1]		)
    UpperCAmelCase			:      List[str]			=			weight




   def 			SCREAMING_SNAKE_CASE  (     self		)						->   Graph:





    '''simple docstring'''




    UpperCAmelCase			:      Graph			=			Graph({min(self.vertices		)}   ,  {}		)
    UpperCAmelCase			:      EdgeT
    UpperCAmelCase			:      int
    UpperCAmelCase			:      EdgeT
    UpperCAmelCase			:      int

    while len(subgraph.vertices		) < len(self.vertices		):
     UpperCAmelCase			:      Union[str, Any]			=			max(self.edges.values()		) + 1
     for edge, weight in self.edges.items():
      if (edge[0] in subgraph.vertices) ^ (edge[1] in subgraph.vertices):
       if weight < min_weight:
        UpperCAmelCase			:      Optional[Any]			=			edge
        UpperCAmelCase			:      Any			=			weight

     subgraph.add_edge(_SCREAMING_SNAKE_CASE   ,  _SCREAMING_SNAKE_CASE		)

    return subgraph

def    _snake_case		(		UpperCamelCase		:	str = "p107_network.txt"		):
 UpperCAmelCase			:      str			=			os.path.abspath(os.path.dirname(UpperCamelCase		)		)
 UpperCAmelCase			:      str			=			os.path.join(UpperCamelCase    ,	UpperCamelCase		)
 UpperCAmelCase			:      dict[EdgeT, int]			=			{}
 UpperCAmelCase			:      list[str]
 UpperCAmelCase			:      int
 UpperCAmelCase			:      int

 with open(UpperCamelCase		) as f:
  UpperCAmelCase			:      Dict			=			f.read().strip().split("""\n"""		)

 UpperCAmelCase			:      List[Any]			=			[line.split(""","""		) for line in data]

 for edgea in range(1    ,	len(UpperCamelCase		)		):
  for edgea in range(UpperCamelCase		):
   if adjaceny_matrix[edgea][edgea] != "-":
    UpperCAmelCase			:      Any			=			int(adjaceny_matrix[edgea][edgea]		)

 UpperCAmelCase			:      Graph			=			Graph(set(range(len(UpperCamelCase		)		)		)    ,	UpperCamelCase		)

 UpperCAmelCase			:      Graph			=			graph.prims_algorithm()

 UpperCAmelCase			:      int			=			sum(graph.edges.values()		)
 UpperCAmelCase			:      int			=			sum(subgraph.edges.values()		)

 return initial_total - optimal_total


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











"""simple docstring"""
import math
from datetime import datetime, timedelta

def    _snake_case		(		UpperCamelCase		:	int		):
 UpperCAmelCase			:      Any			=			year % 19
 UpperCAmelCase			:      Any			=			year % 4
 UpperCAmelCase			:      str			=			year % 7
 UpperCAmelCase			:      Union[str, Any]			=			math.floor(year / 100		)
 UpperCAmelCase			:      Optional[Any]			=			math.floor((13 + 8 * leap_day_inhibits) / 25		)
 UpperCAmelCase			:      int			=			leap_day_inhibits / 4
 UpperCAmelCase			:      int			=			(
     15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
 ) % 30
 UpperCAmelCase			:      Tuple			=			(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

 # days to be added to March 21
 UpperCAmelCase			:      int			=			(19 * metonic_cycle + secular_moon_shift) % 30

 # PHM -> Paschal Full Moon
 UpperCAmelCase			:      Tuple			=			(
     2 * julian_leap_year
     + 4 * non_leap_year
     + 6 * days_to_add
     + century_starting_point
 ) % 7

 if days_to_add == 29 and days_from_phm_to_sunday == 6:
  return datetime(UpperCamelCase    ,	4    ,	19		)
 elif days_to_add == 28 and days_from_phm_to_sunday == 6:
  return datetime(UpperCamelCase    ,	4    ,	18		)
 else:
  return datetime(UpperCamelCase    ,	3    ,	22		) + timedelta(
      days=int(days_to_add + days_from_phm_to_sunday		)		)


if __name__ == "__main__":
      for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3):
            A:     Any										=	"will be" if year > datetime.now().year else "was"
            print(f"""Easter in {year} {tense} {gauss_easter(year)}""")
