anchor.diff:          }
           return true;
       }
  -
       private String getFullUrl(String url){
           return url.startsWith("//") ? url.replace("//","https://") : url;
       }
  -
       private String exchangePortalTokenForServerToken(String portalToken, ServerUrl su) throws IOException{
           String url = getFullUrl(su.getUrl());
           _log(Level.INFO, "[Info]: Exchanging Portal token for Server-specific token for " + url + "...");
  
positive.code:             e.printStackTrace();
          }
      }
  
      private static void _log(String s, Throwable thrown){
          _log(Level.SEVERE, s, thrown);
      }
  
      private static void _log(Level level, String s){
          _log(level, s, null);
      }
  
      public static class ProxyConfig
      {
          public boolean canReadProxyConfig(){
              InputStream configFile = ProxyConfig.class.getClassLoader().getResourceAsStream("proxy.config");
              return (configFile != null);
          }
  
          public synchronized static ProxyConfig loadProxyConfig()  throws IOException{
              ProxyConfig config = null;
  
              InputStream configFile = ProxyConfig.class.getClassLoader().getResourceAsStream("proxy.config");
              if (configFile != null) {
                  BufferedReader reader = new BufferedReader( new InputStreamReader (configFile, "UTF-8"));
                  String line;
                  StringBuilder stringBuilder = new StringBuilder();
  
                  while( ( line = reader.readLine() ) != null ) {
                      stringBuilder.append( line );
                  }
                  reader.close();
  
                  String configFileStr = stringBuilder.toString();
                  configFileStr = configFileStr.replaceAll("(?ms)<!\\-\\-(.+?)\\-\\->", "");
  
                  Pattern p = Pattern.compile("<\\s*ProxyConfig(.+?)>", Pattern.MULTILINE | Pattern.DOTALL);
                  Matcher m = p.matcher(configFileStr);
                  boolean found = m.find();
  
                  if (found){
  
                      String proxyConfigAttributes = m.group(1);
  
                      config = new ProxyConfig();
  
                      if (proxyConfigAttributes != null && !proxyConfigAttributes.isEmpty()){
                          String mustMatch = ProxyConfig.getAttributeWithRegex("mustMatch", proxyConfigAttributes);
                          if (mustMatch != null && !mustMatch.isEmpty()){
                              config.setMustMatch(Boolean.parseBoolean(mustMatch));
                          }
  
                          String allowedReferers = ProxyConfig.getAttributeWithRegex("allowedReferers", proxyConfigAttributes);
                          if (allowedReferers != null && !allowedReferers.isEmpty()){
                              config.setAllowedReferers(allowedReferers.split(","));
                          }
  
                          String logFile = ProxyConfig.getAttributeWithRegex("logFile", proxyConfigAttributes);
                          if (logFile != null && !logFile.isEmpty()){
                              config.setLogFile(logFile);
                          }
  
                          String logLevel = ProxyConfig.getAttributeWithRegex("logLevel", proxyConfigAttributes);
                          if (logLevel != null && !logLevel.isEmpty()){
                              config.setLogLevel(logLevel);
                          }
  
  
                          p = Pattern.compile("<\\s*serverUrls\\s*>(.+?)<\\s*/\\s*serverUrls\\s*>", Pattern.MULTILINE | Pattern.DOTALL);
                          m = p.matcher(configFileStr);
                          found = m.find();
  
                          if (found) {
                              String serverUrls = m.group(1);
                              if (serverUrls != null && !serverUrls.isEmpty()) {
                                  p = Pattern.compile("<\\s*serverUrl (.+?)((<\\s*/\\s*serverUrl\\s*)|/)>", Pattern.MULTILINE | Pattern.DOTALL);
                                  m = p.matcher(serverUrls);
  
                                  ArrayList<ServerUrl> serverList = new ArrayList<ServerUrl>();
                                  while(m.find()){
                                      String server = m.group(1);
  
negative.code:         }
          return token;
      }
      private boolean pathMatched(String allowedRefererPath, String refererPath){
          //If equal, return true
          if (refererPath.equals(allowedRefererPath)){
              return true;
          }
          //If the allowedRefererPath contain a ending star and match the begining part of referer, it is proper start with.
          if (allowedRefererPath.endsWith("*")){
              allowedRefererPath = allowedRefererPath.substring(0, allowedRefererPath.length()-1);
  