docs: def get_best_match(instance1, attribute1, relation1,
                     instance2, attribute2, relation2,
                     prefix1, prefix2, doinstance=True, doattribute=True, dorelation=True):
      """
      Get the highest triple match number between two sets of triples via hill-climbing.
      Arguments:
          instance1: instance triples of AMR 1 ("instance", node name, node value)
          attribute1: attribute triples of AMR 1 (attribute name, node name, attribute value)
          relation1: relation triples of AMR 1 (relation name, node 1 name, node 2 name)
          instance2: instance triples of AMR 2 ("instance", node name, node value)
          attribute2: attribute triples of AMR 2 (attribute name, node name, attribute value)
          relation2: relation triples of AMR 2 (relation name, node 1 name, node 2 name)
          prefix1: prefix label for AMR 1
          prefix2: prefix label for AMR 2
      Returns:
          best_match: the node mapping that results in the highest triple matching number
          best_match_num: the highest triple matching number
  
      """
      # Compute candidate pool - all possible node match candidates.
      # In the hill-climbing, we only consider candidate in this pool to save computing time.
      # weight_dict is a dictionary that maps a pair of node
      (candidate_mappings, weight_dict) = compute_pool(instance1, attribute1, relation1,
                                                       instance2, attribute2, relation2,
                                                       prefix1, prefix2, doinstance=doinstance, doattribute=doattribute,
                                                       dorelation=dorelation)
      if veryVerbose:
          print("Candidate mappings:", file=DEBUG_LOG)
          print(candidate_mappings, file=DEBUG_LOG)
          print("Weight dictionary", file=DEBUG_LOG)
          print(weight_dict, file=DEBUG_LOG)
  
      best_match_num = 0
      # initialize best match mapping
      # the ith entry is the node index in AMR 2 which maps to the ith node in AMR 1
      best_mapping = [-1] * len(instance1)
      for i in range(iteration_num):
          if veryVerbose:
              print("Iteration", i, file=DEBUG_LOG)
          if i == 0:
              # smart initialization used for the first round
              cur_mapping = smart_init_mapping(candidate_mappings, instance1, instance2)
          else:
              # random initialization for the other round
              cur_mapping = random_init_mapping(candidate_mappings)
          # compute current triple match number
          match_num = compute_match(cur_mapping, weight_dict)
          if veryVerbose:
              print("Node mapping at start", cur_mapping, file=DEBUG_LOG)
              print("Triple match number at start:", match_num, file=DEBUG_LOG)
          while True:
              # get best gain
              (gain, new_mapping) = get_best_gain(cur_mapping, candidate_mappings, weight_dict,
                                                  len(instance2), match_num)
              if veryVerbose:
                  print("Gain after the hill-climbing", gain, file=DEBUG_LOG)
              # hill-climbing until there will be no gain for new node mapping
              if gain <= 0:
                  break
              # otherwise update match_num and mapping
              match_num += gain
              cur_mapping = new_mapping[:]
              if veryVerbose:
                  print("Update triple match number to:", match_num, file=DEBUG_LOG)
                  print("Current mapping:", cur_mapping, file=DEBUG_LOG)
          if match_num > best_match_num:
              best_mapping = cur_mapping[:]
              best_match_num = match_num
      return best_mapping, best_match_num