docs: private void lfMerge() throws ParserConfigurationException {
          tc = "lfMerge - ";
          if (debug)
              Tr.info(traceComponent, tc + "Merging plugins.");
          Iterator<PluginInfo> itrShared = null;
          // p2 - UniquePluginRep - always an input plugin-cfg.xml
          // p1 - UniquePluginRep - may be shared plugin or an input plugin found to the left of input plugin-cfg.xml held by p2
          Hashtable<String, AppInfo> p1, p2 = null;
          // place holders for all info related to the uid
          AppInfo p1AppInfo, p2AppInfo = null;
          Enumeration<String> p1Uids = null;
          // String uid - unique identifier - uri/vhostdef
          String uid = null;
          // loop thru all input plugin-cfg.xml files starting at the second input plugin-cfg.xml
          // inner loop will take care of matching the first input plugin-cfg.xml
          if (debug)
              Tr.info(traceComponent, tc + "Looping through all input files");
          for (int i = 1; i < plugins.length - paramCnt; i++) {
              p2 = plugins[i].getUniquePluginRep();
  
              sharedPlugins.trimToSize();
              PluginInfo sharedPlugin = null;
              itrShared = sharedPlugins.iterator();
              // if there is a shared plugin representation compare them to the selected input plugin (p2) first
              // this ensures uids that have already been noted as being shared between input plugins correctly end up in a shared group
              while (itrShared.hasNext()) {
                  sharedPlugin = (itrShared.next());
                  p1 = sharedPlugin.getUniquePluginRep();
                  p1Uids = p1.keys();
  
                  // loop thru the shared uids
                  while (p1Uids.hasMoreElements()) {
                      uid = p1Uids.nextElement();
                      if (debug)
                          Tr.info(traceComponent, tc + "UID: " + uid);
                      if (p2.containsKey(uid)) {
                          if (debug)
                              Tr.info(traceComponent, tc + "Adding UID to shared: " + uid);
                          p2AppInfo = p2.get(uid);
                          // add the servers from the input plugin-cfg.xml that correspond to the shared uid
                          // to the shared uid in the shared plugin representation
                          sharedPlugin.addSharedServers(plugins[i].getSeqNum(), p2AppInfo.getServerCluster(), (p1.get(uid)), true); /* 654526 */
                          // remove the uid from the input plugin-cfg.xml representation as it's now handles be a shared plugin representation
                          p2.remove(uid);
                      }
                  }
              }
  
              // after all uids that are already known to be shared have been removed from the input plugin-cfg.xml
              // compare the input plugin-cfg.xml being processed to all the input plugin-cfg.xml files to it's left
              // this will result in at most one new shared plugin representation
              PluginInfo newSharedPlugin = null;
              for (int j = 0; j < i; j++) {
                  p1 = plugins[j].getUniquePluginRep();
                  p1Uids = p1.keys();
                  while (p1Uids.hasMoreElements()) {
                      uid = p1Uids.nextElement();
                      // if a common uid is found
                      if (p2.containsKey(uid)) {
                          p1AppInfo = p1.get(uid);
                          p2AppInfo = p2.get(uid);
                          // create a new shared plugin representation unless one was already created
                          // when processing the current input plugin-cfg.xml (p2)
                          if (newSharedPlugin == null) {
                              newSharedPlugin = new PluginInfo(seqNum, p1AppInfo.getServerCluster());
                              seqNum++;
                          }
  
                          // add the app info to the new shared plugin-cfg.xml
                          // if the uid has already been matched once the servers corresposnding to this uid will be updated
                          newSharedPlugin.addMatch(uid, p1AppInfo.getAppName(), p1AppInfo.getServerCluster(), plugins[j].getSeqNum(),
                                                   p2AppInfo.getServerCluster(), plugins[i].getSeqNum(), p1AppInfo.getUri(), p1AppInfo.getVh());
  
                          p1.remove(uid);
                          p2.remove(uid);
                      }
                  }
                  // for all unique uids that remain in the two input plugin-cfg.xmls being processed compare the uris
                  // if a uri is found in one that is not in the other mark that uid as needing a unique vhostGrp
                  // because that uri was not found to be common due to vhost definition
                  //
                  //maybe rewrite setReasonForUniqueness()
                  //so that it doesn't need to be called twice to ensure that something wasn't skipped
                  setReasonForUniqueness(plugins[j], p2);
                  setReasonForUniqueness(plugins[i], p1);
                  tc = "lfMerge - ";
              }
  
              // if a newShared plugin was created when comparing input plugin-cfg.xml files add it to the know sharedPlugins list
              if (newSharedPlugin != null)
                  sharedPlugins.add(newSharedPlugin);
              if (debug)
                  Tr.info(traceComponent, " ");
          }
      }