return comparator.compare(a, b);
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ComparatorOrdering) {
      ComparatorOrdering<?> that = (ComparatorOrdering<?>) object;
      return this.comparator.equals(that.comparator);
    }
    return false;
  }

  @Override

  public int compare(@CheckForNull Object left, @CheckForNull Object right) {
    return 0;
  }

  @Override
  public <E extends @Nullable Object> List<E> sortedCopy(Iterable<E> iterable) {
    return Lists.newArrayList(iterable);
  }

  @Override
  public <E> ImmutableList<E> immutableSortedCopy(Iterable<E> iterable) {
    return ImmutableList.copyOf(iterable);
  }

  @SuppressWarnings("unchecked")
  @Override

    public String getRepositoryUrl() {
        return repositoryUrl;
    }

    public String getName() {
        String name = resource.getName();

        if (name == null) {
            name = "";
        } else if (name.startsWith("/")) {
            name = name.substring(1);
        }

        return name;
    }

    public String getUrl() {
        return getRepositoryUrl() + getName();
    }

                    resp.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                    resp.setContentLength(0);
                    resp.flushBuffer();
                    return null;
                }
            }
        }

        return ntlm;
    }


    private synchronized NtlmChallenge getChallengeForDomain ( String domain ) throws UnknownHostException, ServletException {
        if ( domain == null ) {

        if (map != null) {
            final String[] queries = map.get(toLowerCase(query));
            if (queries != null) {
                return queries;
            }
        }
        return StringUtil.EMPTY_STRINGS;
    }

    private String toLowerCase(final String term) {
        return term != null ? term.toLowerCase(Locale.ROOT) : term;
    }

    public EncryptionNegotiateContext () {}


    /**
     * @return the ciphers
     */
    public int[] getCiphers () {
        return this.ciphers;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.nego.NegotiateContextRequest#getContextType()
     */
    @Override
    public int getContextType () {
        return NEGO_CTX_ENC_TYPE;
    }


    /**
     * {@inheritDoc}

    table.put("z", 1, 'a');
    return table;
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    TreeBasedTable<String, Integer, Character> table = makeTable();
    populateTable(table);
    return table.rowMap().subMap("b", "x");
  }

  @Override
  protected Map<String, Map<Integer, Character>> makeEmptyMap() {
    return makeTable().rowMap().subMap("b", "x");
  }

    map.put("three", 3);
    return SerializableTester.reserialize(map);
  }

  @Override
  protected SortedMap<String, Integer> makeEmptyMap() throws UnsupportedOperationException {
    NavigableMap<String, Integer> map = new SafeTreeMap<>();
    return SerializableTester.reserialize(map);
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "minus one";
  }

  @Override

        this(encode(targetName));
    }


    /**
     * 
     * @return the target name
     */
    public String getTargetName () {
        return new String(getRaw(), UTF16LE);
    }


    /**
     * @param targetName
     * @return
     */
    private static byte[] encode ( String targetName ) {
        return targetName.getBytes(UTF16LE);
    }

  istioctl admin log`,
		Aliases: []string{"istiod"},
		Args: func(cmd *cobra.Command, args []string) error {
			if len(args) != 0 {
				return fmt.Errorf("unknown subcommand %q", args[0])
			}
			return nil
		},
		RunE: func(cmd *cobra.Command, args []string) error {
			cmd.HelpFunc()(cmd, args)
			return nil
		},
	}

	istiodLog := istiodLogCmd(ctx)
	adminCmd.AddCommand(istiodLog)