
'''simple docstring'''





a__		: List[str]  							=							[
    ["ab-e1", "ac-e3", "ad-e5", "bc-e4", "bd-e2", "be-e6", "bh-e12", "cd-e2", "ce-e4",
     "de-e1", "df-e8", "dg-e5", "dh-e10", "ef-e3", "eg-e2", "fg-e6", "gh-e6", "hi-e3"],
    ["ab-e1", "ac-e3", "ad-e5", "bc-e4", "bd-e2", "be-e6", "cd-e2", "de-e1", "df-e8",
     "ef-e3", "eg-e2", "fg-e6"],
    ["ab-e1", "ac-e3", "bc-e4", "bd-e2", "de-e1", "df-e8", "dg-e5", "ef-e3", "eg-e2",
     "eh-e12", "fg-e6", "fh-e10", "gh-e6"],
    ["ab-e1", "ac-e3", "bc-e4", "bd-e2", "bh-e12", "cd-e2", "df-e8", "dh-e10"],
    ["ab-e1", "ac-e3", "ad-e5", "bc-e4", "bd-e2", "cd-e2", "ce-e4", "de-e1", "df-e8",
     "dg-e5", "ef-e3", "eg-e2", "fg-e6"]
]





def 							snake_case				(		UpperCAmelCase						)->      Union[str, Any]:







      """simple docstring"""
      __A													=      set()
      for row in edge_array:
            for item in row:
                  distinct_edge.add(item[0]						)
      return list(UpperCAmelCase						)





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase						)->      Tuple:







      """simple docstring"""
      __A													=      ['0'] * len(UpperCAmelCase						)
      for i, row in enumerate(UpperCAmelCase						):
            for item in row:
                  if distinct_edge in item[0]:
                        __A													=      '1'
                        break
      return "".join(UpperCAmelCase						)





def 							snake_case				(		UpperCAmelCase						)->      Optional[Any]:







      """simple docstring"""
      __A													=      get_distinct_edge(UpperCAmelCase						)
      __A													=      {}

      for item in distinct_edge:
            __A													=      get_bitcode(UpperCAmelCase   ,	UpperCAmelCase						)
            # print('bit',bit)
            # bt=''.join(bit)
            __A													=      bit.count('1'						)
            __A													=      [s, bit]
      # Store [Distinct edge, WT(Bitcode), Bitcode] in descending order
      __A													=      [
          [k, v[0], v[1]]
          for k, v in sorted(frequency_table.items()   ,	key=lambda UpperCAmelCase						: v[1][0]   ,	reverse=UpperCAmelCase						)
      ]
      return sorted_frequency_table





def 							snake_case				(		UpperCAmelCase						)->      List[str]:







      """simple docstring"""
      __A													=      {}
      for _, item in enumerate(UpperCAmelCase						):
            nodes.setdefault(item[2]   ,	[]						).append(item[0]						)
      return nodes





def 							snake_case				(		UpperCAmelCase						)->      List[Any]:







      """simple docstring"""
      __A													=      {}
      for key, value in nodes.items():
            __A													=      value
      return cluster





def 							snake_case				(		UpperCAmelCase						)->      str:







      """simple docstring"""
      return [i * 1_0_0 / len(UpperCAmelCase						) for i in cluster]





def 							snake_case				(		)->      None:







      """simple docstring"""
      print('\nNodes\n'						)
      for key, value in nodes.items():
            print(UpperCAmelCase   ,	UpperCAmelCase						)
      print('\nSupport\n'						)
      print(UpperCAmelCase						)
      print('\n Cluster \n'						)
      for key, value in sorted(cluster.items()   ,	reverse=UpperCAmelCase						):
            print(UpperCAmelCase   ,	UpperCAmelCase						)
      print('\n Graph\n'						)
      for key, value in graph.items():
            print(UpperCAmelCase   ,	UpperCAmelCase						)
      print('\n Edge List of Frequent subgraphs \n'						)
      for edge_list in freq_subgraph_edge_list:
            print(UpperCAmelCase						)





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase						)->      Dict:







      """simple docstring"""
      for i in cluster[ca]:
            __A													=      0
            __A													=      ca + 1
            while ca < max(cluster.keys()						):
                  for j in cluster[ca]:
                        if int(UpperCAmelCase   ,	2						) & int(UpperCAmelCase   ,	2						) == int(UpperCAmelCase   ,	2						):
                              if tuple(nodes[i]						) in graph:
                                    graph[tuple(nodes[i]						)].append(nodes[j]						)
                              else:
                                    __A													=      [nodes[j]]
                              count += 1
                  if count == 0:
                        __A													=      ca + 1
                  else:
                        break





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase						)->      Any:







      """simple docstring"""
      __A													=      cluster[max(cluster.keys()						)]
      __A													=      'Header'
      __A													=      {}
      for i in x:
            if (["Header"],) in graph:
                  graph[(["Header"],)].append(x[i]						)
            else:
                  __A													=      [x[i]]
      for i in x:
            __A													=      [['Header']]
      __A													=      1
      while i < max(UpperCAmelCase						) - 1:
            create_edge(UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase						)
            __A													=      i + 1
      return graph





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase=None						)->      Optional[int]:







      """simple docstring"""
      __A													=      (path or []) + [start]
      if start == end:
            paths.append(UpperCAmelCase						)
      for node in graph[start]:
            if tuple(UpperCAmelCase						) not in path:
                  my_dfs(UpperCAmelCase   ,	tuple(UpperCAmelCase						)   ,	UpperCAmelCase   ,	UpperCAmelCase						)





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase   ,	UpperCAmelCase						)->      Tuple:







      """simple docstring"""
      __A													=      int(s / 1_0_0 * (len(UpperCAmelCase						) - 1)						)
      for i in cluster[k]:
            my_dfs(UpperCAmelCase   ,	tuple(cluster[k][i]						)   ,	(['Header'],)						)





def 							snake_case				(		UpperCAmelCase						)->      Tuple:







      """simple docstring"""
      __A													=      []
      for edges in paths:
            __A													=      []
            for j in range(len(UpperCAmelCase						) - 1						):
                  __A													=      list(edges[j]						)
                  for e in temp:
                        __A													=      (e[0], e[1])
                        el.append(UpperCAmelCase						)
            freq_sub_el.append(UpperCAmelCase						)
      return freq_sub_el





def 							snake_case				(		UpperCAmelCase						)->      Any:







      """simple docstring"""
      for i in range(len(UpperCAmelCase						)						):
            for j in range(len(edge_array[i]						)						):
                  __A													=      edge_array[i][j].split('-'						)
                  __A													=      t


if __name__ == "__main__":
 preprocess(edge_array)
 a__		: Optional[int]  							=							get_frequency_table(edge_array)
 a__		: Optional[int]  							=							get_nodes(frequency_table)
 a__		: str  							=							get_cluster(nodes)
 a__		: int  							=							get_support(cluster)
 a__		: Union[str, Any]  							=							construct_graph(cluster, nodes)
 find_freq_subgraph_given_support(6_0, cluster, graph)
 a__		: list  							=							[]
 a__		: Optional[Any]  							=							freq_subgraphs_edge_list(paths)
 print_all()








from __future__ import annotations

import math
import random

def    UpperCamelCase_ (	a_  ,				a_  ,				a_		)     ->list[int]:
		A				=d * e - 1
		A				=0
		A				=0
		while p == 0:
				A				=random.randint(2  ,				n - 1		)
				A				=k
				while True:
						if t % 2 == 0:
								A				=t // 2
								A				=(g**t) % n
								A				=math.gcd(x - 1  ,				a_		)
								if x > 1 and y > 1:
										A				=y
										A				=n // y
										break  # find the correct factors
						else:
								break  # t is not divisible by 2, break and choose another g
		return sorted([p, q]		)


if __name__ == "__main__":
	import doctest

	doctest.testmod()




