*/
  public static char[] toArray(Collection<Character> collection) {
    if (collection instanceof CharArrayAsList) {
      return ((CharArrayAsList) collection).toCharArray();
    }

    Object[] boxedArray = collection.toArray();
    int len = boxedArray.length;
    char[] array = new char[len];
    for (int i = 0; i < len; i++) {
      // checkNotNull for GWT (do not optimize)

            + "\u3000\uf8ff\ufeff\ufffb";

    static final CharMatcher INSTANCE = new Invisible();

    private Invisible() {
      super("CharMatcher.invisible()", RANGE_STARTS.toCharArray(), RANGE_ENDS.toCharArray());
    }
  }

  /** Implementation of {@link #singleWidth()}. */
  private static final class SingleWidth extends RangesMatcher {

            + "\u3000\uf8ff\ufeff\ufffb";

    static final CharMatcher INSTANCE = new Invisible();

    private Invisible() {
      super("CharMatcher.invisible()", RANGE_STARTS.toCharArray(), RANGE_ENDS.toCharArray());
    }
  }

  /** Implementation of {@link #singleWidth()}. */
  private static final class SingleWidth extends RangesMatcher {

        }
    }

    void consultDictionary() throws IOException {
        if (synonymMap == null) {
            return;
        }
        synonyms.clear();
        final char[] key = block.toString().toCharArray();
        for (int start = 0; start < block.length();) {
            final BytesRef matchOutput = getLongestMatchOutput(key, start);
            if (matchOutput == null) {
                start++;

            return getFirstAddress();
        }
        return this.addresses[this.addressIndex - 1];
    }

    static String queryLookup(final String query, final String param) {
        final char in[] = query.toCharArray();
        int i, ch, st, eq;

        st = eq = 0;
        for (i = 0; i < in.length; i++) {
            ch = in[i];
            if (ch == '&') {
                if (eq > st) {

    for (byte b : bytes) {
      sb.append(hexDigits[(b >> 4) & 0xf]).append(hexDigits[b & 0xf]);
    }
    return sb.toString();
  }

  private static final char[] hexDigits = "0123456789abcdef".toCharArray();

    Collector<String, ?, ImmutableSetMultimap<Character, Character>> collector =
        flatteningToImmutableSetMultimap(
            str -> str.charAt(0), str -> asList(str.substring(1).toCharArray()).stream());
    BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
        Equivalence.equals()
            .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))

    Collector<String, ?, ImmutableListMultimap<Character, Character>> collector =
        flatteningToImmutableListMultimap(
            str -> str.charAt(0), str -> Chars.asList(str.substring(1).toCharArray()).stream());
    BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
        Equivalence.equals()
            .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))

  public void testCharsIgnored() {
    for (char c : IGNORED.toCharArray()) {
      String str = String.valueOf(c);
      assertEquals(str, c, Ascii.toLowerCase(c));
      assertEquals(str, c, Ascii.toUpperCase(c));
      assertFalse(str, Ascii.isLowerCase(c));
      assertFalse(str, Ascii.isUpperCase(c));
    }
  }

  public void testCharsLower() {
    for (char c : LOWER.toCharArray()) {
      String str = String.valueOf(c);

  public void testCharsIgnored() {
    for (char c : IGNORED.toCharArray()) {
      String str = String.valueOf(c);
      assertEquals(str, c, Ascii.toLowerCase(c));
      assertEquals(str, c, Ascii.toUpperCase(c));
      assertFalse(str, Ascii.isLowerCase(c));
      assertFalse(str, Ascii.isUpperCase(c));
    }
  }

  public void testCharsLower() {
    for (char c : LOWER.toCharArray()) {
      String str = String.valueOf(c);