code: 
  
  
  
  
  
  
  import argparse
  import json
  import re
  import string
  import sys
  from collections import Counter
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			Union[str, Any] ):
  
      def remove_articles(SCREAMING_SNAKE_CASE__						:			Optional[Any] ):
          return re.sub(R'''\b(a|an|the)\b'''  ,						''' '''  ,						SCREAMING_SNAKE_CASE__ )
  
      def white_space_fix(SCREAMING_SNAKE_CASE__						:			str ):
          return " ".join(text.split() )
  
      def remove_punc(SCREAMING_SNAKE_CASE__						:			Union[str, Any] ):
          UpperCamelCase :Dict										=     set(string.punctuation )
          return "".join(ch for ch in text if ch not in exclude )
  
      def lower(SCREAMING_SNAKE_CASE__						:			str ):
          return text.lower()
  
      return white_space_fix(remove_articles(remove_punc(lower(SCREAMING_SNAKE_CASE__ ) ) ) )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int  ,						SCREAMING_SNAKE_CASE__						:			Any ):
      UpperCamelCase :str										=     normalize_answer(SCREAMING_SNAKE_CASE__ ).split()
      UpperCamelCase :List[Any]										=     normalize_answer(SCREAMING_SNAKE_CASE__ ).split()
      UpperCamelCase :List[Any]										=     Counter(SCREAMING_SNAKE_CASE__ ) & Counter(SCREAMING_SNAKE_CASE__ )
      UpperCamelCase :Optional[Any]										=     sum(common.values() )
      if num_same == 0:
          return 0
      UpperCamelCase :List[Any]										=     1.0 * num_same / len(SCREAMING_SNAKE_CASE__ )
      UpperCamelCase :List[Any]										=     1.0 * num_same / len(SCREAMING_SNAKE_CASE__ )
      UpperCamelCase :List[Any]										=     (2 * precision * recall) / (precision + recall)
      return fa
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			Union[str, Any]  ,						SCREAMING_SNAKE_CASE__						:			str ):
      return normalize_answer(SCREAMING_SNAKE_CASE__ ) == normalize_answer(SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int  ,						SCREAMING_SNAKE_CASE__						:			int  ,						SCREAMING_SNAKE_CASE__						:			List[Any] ):
      UpperCamelCase :Dict										=     []
      for ground_truth in ground_truths:
          UpperCamelCase :int										=     metric_fn(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
          scores_for_ground_truths.append(SCREAMING_SNAKE_CASE__ )
      return max(SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			Union[str, Any]  ,						SCREAMING_SNAKE_CASE__						:			Any ):
      UpperCamelCase :Dict										=     0
      UpperCamelCase :Dict										=     []
      for passage in dataset:
          for qa in passage["qas"]:
              total += 1
              if qa["id"] not in predictions:
                  UpperCamelCase :int										=     F'''Unanswered question {qa["id"]} will receive score 0.'''
                  print(SCREAMING_SNAKE_CASE__  ,						file=sys.stderr )
                  continue
  
              UpperCamelCase :List[str]										=     [x['''text'''] for x in qa['''answers''']]
              UpperCamelCase :int										=     predictions[qa['''id''']]
  
              UpperCamelCase :List[str]										=     metric_max_over_ground_truths(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
              if int(_exact_match ) == 1:
                  correct_ids.append(qa['''id'''] )
              exact_match += _exact_match
  
              fa += metric_max_over_ground_truths(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
  
      UpperCamelCase :Optional[Any]										=     exact_match / total
      UpperCamelCase :int										=     fa / total
  
      return {"exact_match": exact_match, "f1": fa}, correct_ids
  
  
  if __name__ == "__main__":
   __snake_case							      =						"""1.0"""
   __snake_case							      =						argparse.ArgumentParser("""Official evaluation script for ReCoRD v1.0.""")
   parser.add_argument("""data_file""", help="""The dataset file in JSON format.""")
   parser.add_argument("""pred_file""", help="""The model prediction file in JSON format.""")
   parser.add_argument("""--output_correct_ids""", action="""store_true""", help="""Output the correctly answered query IDs.""")
   __snake_case							      =						parser.parse_args()
  
   with open(args.data_file) as data_file:
    __snake_case							      =						json.load(data_file)
    if dataset_json["version"] != expected_version:
     print(
         f'''Evaluation expects v-{expected_version}, but got dataset with v-{dataset_json["version"]}''',
         file=sys.stderr,
     )
    __snake_case							      =						dataset_json["""data"""]
  
   with open(args.pred_file) as pred_file:
    __snake_case							      =						json.load(pred_file)
  
   __snake_case      ,   __snake_case							      =						evaluate(dataset, predictions)
  
   if args.output_correct_ids:
    print(f'''Output {len(correct_ids)} correctly answered question IDs.''')
    with open("""correct_ids.json""", """w""") as f:
     json.dump(correct_ids, f)
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  __snake_case							      =						[
      ["""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 						_A     (       SCREAMING_SNAKE_CASE__						:			List[Any] ):
      UpperCamelCase :List[Any]										=     set()
      for row in edge_array:
          for item in row:
              distinct_edge.add(item[0] )
      return list(SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			List[str]  ,						SCREAMING_SNAKE_CASE__						:			str ):
      UpperCamelCase :int										=     ['''0'''] * len(SCREAMING_SNAKE_CASE__ )
      for i, row in enumerate(SCREAMING_SNAKE_CASE__ ):
          for item in row:
              if distinct_edge in item[0]:
                  UpperCamelCase :Tuple										=     '''1'''
                  break
      return "".join(SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			Union[str, Any] ):
      UpperCamelCase :Optional[Any]										=     get_distinct_edge(SCREAMING_SNAKE_CASE__ )
      UpperCamelCase :Optional[int]										=     {}
  
      for item in distinct_edge:
          UpperCamelCase :List[str]										=     get_bitcode(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
          # print('bit',bit)
          # bt=''.join(bit)
          UpperCamelCase :str										=     bit.count('''1''' )
          UpperCamelCase :Optional[int]										=     [s, bit]
      # Store [Distinct edge, WT(Bitcode), Bitcode] in descending order
      UpperCamelCase :Optional[int]										=     [
          [k, v[0], v[1]]
          for k, v in sorted(frequency_table.items()  ,						key=lambda SCREAMING_SNAKE_CASE__ : v[1][0]  ,						reverse=SCREAMING_SNAKE_CASE__ )
      ]
      return sorted_frequency_table
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int ):
      UpperCamelCase :List[Any]										=     {}
      for _, item in enumerate(SCREAMING_SNAKE_CASE__ ):
          nodes.setdefault(item[2]  ,						[] ).append(item[0] )
      return nodes
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			Tuple ):
      UpperCamelCase :str										=     {}
      for key, value in nodes.items():
          UpperCamelCase :str										=     value
      return cluster
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			List[Any] ):
      return [i * 100 / len(SCREAMING_SNAKE_CASE__ ) for i in cluster]
  
  
  def 						_A     (       ):
      print('''\nNodes\n''' )
      for key, value in nodes.items():
          print(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
      print('''\nSupport\n''' )
      print(SCREAMING_SNAKE_CASE__ )
      print('''\n Cluster \n''' )
      for key, value in sorted(cluster.items()  ,						reverse=SCREAMING_SNAKE_CASE__ ):
          print(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
      print('''\n Graph\n''' )
      for key, value in graph.items():
          print(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
      print('''\n Edge List of Frequent subgraphs \n''' )
      for edge_list in freq_subgraph_edge_list:
          print(SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			Any  ,						SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			Union[str, Any]  ,						SCREAMING_SNAKE_CASE__						:			Optional[Any] ):
      for i in cluster[ca]:
          UpperCamelCase :Union[str, Any]										=     0
          UpperCamelCase :Dict										=     ca + 1
          while ca < max(cluster.keys() ):
              for j in cluster[ca]:
                  if int(SCREAMING_SNAKE_CASE__  ,						2 ) & int(SCREAMING_SNAKE_CASE__  ,						2 ) == int(SCREAMING_SNAKE_CASE__  ,						2 ):
                      if tuple(nodes[i] ) in graph:
                          graph[tuple(nodes[i] )].append(nodes[j] )
                      else:
                          UpperCamelCase :Union[str, Any]										=     [nodes[j]]
                      count += 1
              if count == 0:
                  UpperCamelCase :int										=     ca + 1
              else:
                  break
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			List[Any]  ,						SCREAMING_SNAKE_CASE__						:			str ):
      UpperCamelCase :str										=     cluster[max(cluster.keys() )]
      UpperCamelCase :Any										=     '''Header'''
      UpperCamelCase :str										=     {}
      for i in x:
          if (["Header"],) in graph:
              graph[(["Header"],)].append(x[i] )
          else:
              UpperCamelCase :str										=     [x[i]]
      for i in x:
          UpperCamelCase :Dict										=     [['''Header''']]
      UpperCamelCase :Union[str, Any]										=     1
      while i < max(SCREAMING_SNAKE_CASE__ ) - 1:
          create_edge(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
          UpperCamelCase :Optional[int]										=     i + 1
      return graph
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			List[str]  ,						SCREAMING_SNAKE_CASE__						:			Tuple  ,						SCREAMING_SNAKE_CASE__						:			Optional[int]  ,						SCREAMING_SNAKE_CASE__						:			List[str]=None ):
      UpperCamelCase :Tuple										=     (path or []) + [start]
      if start == end:
          paths.append(SCREAMING_SNAKE_CASE__ )
      for node in graph[start]:
          if tuple(SCREAMING_SNAKE_CASE__ ) not in path:
              my_dfs(SCREAMING_SNAKE_CASE__  ,						tuple(SCREAMING_SNAKE_CASE__ )  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			List[Any]  ,						SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			Union[str, Any] ):
      UpperCamelCase :str										=     int(s / 100 * (len(SCREAMING_SNAKE_CASE__ ) - 1) )
      for i in cluster[k]:
          my_dfs(SCREAMING_SNAKE_CASE__  ,						tuple(cluster[k][i] )  ,						(['''Header'''],) )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			str ):
      UpperCamelCase :Dict										=     []
      for edges in paths:
          UpperCamelCase :Tuple										=     []
          for j in range(len(SCREAMING_SNAKE_CASE__ ) - 1 ):
              UpperCamelCase :Dict										=     list(edges[j] )
              for e in temp:
                  UpperCamelCase :Union[str, Any]										=     (e[0], e[1])
                  el.append(SCREAMING_SNAKE_CASE__ )
          freq_sub_el.append(SCREAMING_SNAKE_CASE__ )
      return freq_sub_el
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			List[str] ):
      for i in range(len(SCREAMING_SNAKE_CASE__ ) ):
          for j in range(len(edge_array[i] ) ):
              UpperCamelCase :Tuple										=     edge_array[i][j].split('''-''' )
              UpperCamelCase :Dict										=     t
  
  
  if __name__ == "__main__":
   preprocess(edge_array)
   __snake_case							      =						get_frequency_table(edge_array)
   __snake_case							      =						get_nodes(frequency_table)
   __snake_case							      =						get_cluster(nodes)
   __snake_case							      =						get_support(cluster)
   __snake_case							      =						construct_graph(cluster, nodes)
   find_freq_subgraph_given_support(60, cluster, graph)
   __snake_case							      =						[]
   __snake_case							      =						freq_subgraphs_edge_list(paths)
   print_all()
  
  
  
  
  
  