

def 		_lowercase (     lowercase__						):
      return [
          {
              0: [1, 2],
              1: [0, 2],
              2: [0, 1, 3, 5],
              3: [2, 4],
              4: [3],
              5: [2, 6, 8],
              6: [5, 7],
              7: [6, 8],
              8: [5, 7],
          },
          {
              0: [6],
              1: [9],
              2: [4, 5],
              3: [4],
              4: [2, 3],
              5: [2],
              6: [0, 7],
              7: [6],
              8: [],
              9: [1],
          },
          {
              0: [4],
              1: [6],
              2: [],
              3: [5, 6, 7],
              4: [0, 6],
              5: [3, 8, 9],
              6: [1, 3, 4, 7],
              7: [3, 6, 8, 9],
              8: [5, 7],
              9: [5, 7],
          },
          {
              0: [1, 3],
              1: [0, 2, 4],
              2: [1, 3, 4],
              3: [0, 2, 4],
              4: [1, 2, 3],
          },
      ][index]







def 		_lowercase (     lowercase__						):
      __lowerCAmelCase					:						Dict					=					0
      __lowerCAmelCase					:						List[str]					=					len(UpperCAmelCase__						)  # No of vertices in graph
      __lowerCAmelCase					:						Dict					=					[0] * n
      __lowerCAmelCase					:						int					=					[False] * n

      def dfs(lowercase__   ,	lowercase__   ,	lowercase__   ,	lowercase__						):
            __lowerCAmelCase					:						Dict					=					True
            __lowerCAmelCase					:						str					=					id_
            id_ += 1
            for to in graph[at]:
                  if to == parent:
                        pass
                  elif not visited[to]:
                        dfs(UpperCAmelCase__   ,	UpperCAmelCase__   ,	UpperCAmelCase__   ,	id_						)
                        __lowerCAmelCase					:						List[str]					=					min(low[at]   ,	low[to]						)
                        if id_ <= low[to]:
                              bridges.append((at, to) if at < to else (to, at)						)
                  else:
                        # This edge is a back edge and cannot be a bridge
                        __lowerCAmelCase					:						Optional[int]					=					min(low[at]   ,	low[to]						)

      __lowerCAmelCase					:						list[tuple[int, int]]					=					[]
      for i in range(UpperCAmelCase__						):
            if not visited[i]:
                  dfs(UpperCAmelCase__   ,	-1   ,	UpperCAmelCase__   ,	id_						)
      return bridges


if __name__ == "__main__":
 import doctest

 doctest.testmod()



'''simple docstring'''




from itertools import product




def 							lowerCamelCase	(      UpperCAmelCase__       :					int      ,      UpperCAmelCase__       :					int )			->      list[int]:
							lowercase_					:			List[Any]										=       sides_number
							lowercase_					:			Dict										=       max_face_number * dice_number
							lowercase_					:			List[str]										=       [0] * (max_total + 1)

							lowercase_					:			Union[str, Any]										=       1
							lowercase_					:			Dict										=       range(UpperCAmelCase__      ,      max_face_number + 1 )
							for dice_numbers in product(UpperCAmelCase__      ,      repeat=UpperCAmelCase__ ):
														lowercase_					:			Any										=       sum(UpperCAmelCase__ )
														totals_frequencies[total] += 1

							return totals_frequencies




def 							lowerCamelCase	(      )			->      float:
							lowercase_					:			Optional[Any]										=       total_frequency_distribution(
							    sides_number=4      ,      dice_number=9 )
							lowercase_					:			List[str]										=       total_frequency_distribution(
							    sides_number=6      ,      dice_number=6 )

							lowercase_					:			Union[str, Any]										=       0
							lowercase_					:			Tuple										=       9
							lowercase_					:			Optional[int]										=       4 * 9
							lowercase_					:			List[Any]										=       6
							for peter_total in range(UpperCAmelCase__      ,      max_peter_total + 1 ):
														peter_wins_count += peter_totals_frequencies[peter_total] * sum(
														    colin_totals_frequencies[min_colin_total:peter_total] )

							lowercase_					:			str										=       (4**9) * (6**6)
							lowercase_					:			List[Any]										=       peter_wins_count / total_games_number

							lowercase_					:			Dict										=       round(UpperCAmelCase__      ,      ndigits=7 )

							return rounded_peter_win_probability


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





