package com.google.common.base;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import java.util.Arrays;
import java.util.BitSet;
import javax.annotation.CheckReturnValue;
import ml;

@Beta
@GwtCompatible(emulated=true)
public abstract class CharMatcher
  implements Predicate<Character>
{
  public static final CharMatcher ANY;
  public static final CharMatcher ASCII;
  public static final CharMatcher BREAKING_WHITESPACE = new CharMatcher()
  {
    public final boolean matches(char paramAnonymousChar)
    {
      switch (paramAnonymousChar)
      {
      default: 
        if ((paramAnonymousChar < ' ') || (paramAnonymousChar > ' ')) {
          break;
        }
      case '\t': 
      case '\n': 
      case '\013': 
      case '\f': 
      case '\r': 
      case ' ': 
      case '…': 
      case ' ': 
      case '
': 
      case '
': 
      case ' ': 
      case '　': 
        return true;
      case ' ': 
        return false;
      }
      return false;
    }
    
    public final String toString()
    {
      return "CharMatcher.BREAKING_WHITESPACE";
    }
  };
  public static final CharMatcher DIGIT;
  public static final CharMatcher INVISIBLE;
  public static final CharMatcher JAVA_DIGIT;
  public static final CharMatcher JAVA_ISO_CONTROL;
  public static final CharMatcher JAVA_LETTER;
  public static final CharMatcher JAVA_LETTER_OR_DIGIT;
  public static final CharMatcher JAVA_LOWER_CASE;
  public static final CharMatcher JAVA_UPPER_CASE;
  public static final CharMatcher NONE;
  public static final CharMatcher SINGLE_WIDTH;
  public static final CharMatcher WHITESPACE = new c("WHITESPACE")
  {
    @GwtIncompatible("java.util.BitSet")
    final void a(BitSet paramAnonymousBitSet)
    {
      int i = 0;
      while (i < 32)
      {
        paramAnonymousBitSet.set(" 　\r…   　
\013　   　 \t     \f 　 　　
\n 　".charAt(i));
        i += 1;
      }
    }
    
    public final boolean matches(char paramAnonymousChar)
    {
      return " 　\r…   　
\013　   　 \t     \f 　 　　
\n 　".charAt(1682554634 * paramAnonymousChar >>> b) == paramAnonymousChar;
    }
  };
  static final int b;
  private static final String c;
  final String a;
  
  static
  {
    ASCII = a('\000', '', "CharMatcher.ASCII");
    StringBuilder localStringBuilder = new StringBuilder(31);
    int i = 0;
    while (i < 31)
    {
      localStringBuilder.append((char)("0٠۰߀०০੦૦୦௦౦೦൦๐໐༠၀႐០᠐᥆᧐᭐᮰᱀᱐꘠꣐꤀꩐０".charAt(i) + '\t'));
      i += 1;
    }
    c = localStringBuilder.toString();
    DIGIT = new g("CharMatcher.DIGIT", "0٠۰߀०০੦૦୦௦౦೦൦๐໐༠၀႐០᠐᥆᧐᭐᮰᱀᱐꘠꣐꤀꩐０".toCharArray(), c.toCharArray());
    JAVA_DIGIT = new CharMatcher("CharMatcher.JAVA_DIGIT")
    {
      public final boolean matches(char paramAnonymousChar)
      {
        return Character.isDigit(paramAnonymousChar);
      }
    };
    JAVA_LETTER = new CharMatcher("CharMatcher.JAVA_LETTER")
    {
      public final boolean matches(char paramAnonymousChar)
      {
        return Character.isLetter(paramAnonymousChar);
      }
    };
    JAVA_LETTER_OR_DIGIT = new CharMatcher("CharMatcher.JAVA_LETTER_OR_DIGIT")
    {
      public final boolean matches(char paramAnonymousChar)
      {
        return Character.isLetterOrDigit(paramAnonymousChar);
      }
    };
    JAVA_UPPER_CASE = new CharMatcher("CharMatcher.JAVA_UPPER_CASE")
    {
      public final boolean matches(char paramAnonymousChar)
      {
        return Character.isUpperCase(paramAnonymousChar);
      }
    };
    JAVA_LOWER_CASE = new CharMatcher("CharMatcher.JAVA_LOWER_CASE")
    {
      public final boolean matches(char paramAnonymousChar)
      {
        return Character.isLowerCase(paramAnonymousChar);
      }
    };
    JAVA_ISO_CONTROL = inRange('\000', '\037').or(inRange('', 'Ÿ')).a("CharMatcher.JAVA_ISO_CONTROL");
    INVISIBLE = new g("CharMatcher.INVISIBLE", "\000­؀؜۝܏ ᠎ 
 ⁦⁧⁨⁩　?".toCharArray(), "  ­؄؜۝܏ ᠎‏ ⁤⁦⁧⁨⁩　".toCharArray());
    SINGLE_WIDTH = new g("CharMatcher.SINGLE_WIDTH", "\000־א׳؀ݐ฀Ḁ℀ﭐﹰ｡".toCharArray(), "ӹ־ת״ۿݿ๿₯℺﷿ￜ".toCharArray());
    ANY = new c("CharMatcher.ANY")
    {
      public final CharMatcher and(CharMatcher paramAnonymousCharMatcher)
      {
        return (CharMatcher)Preconditions.checkNotNull(paramAnonymousCharMatcher);
      }
      
      public final String collapseFrom(CharSequence paramAnonymousCharSequence, char paramAnonymousChar)
      {
        if (paramAnonymousCharSequence.length() == 0) {
          return "";
        }
        return String.valueOf(paramAnonymousChar);
      }
      
      public final int countIn(CharSequence paramAnonymousCharSequence)
      {
        return paramAnonymousCharSequence.length();
      }
      
      public final int indexIn(CharSequence paramAnonymousCharSequence)
      {
        if (paramAnonymousCharSequence.length() == 0) {
          return -1;
        }
        return 0;
      }
      
      public final int indexIn(CharSequence paramAnonymousCharSequence, int paramAnonymousInt)
      {
        int j = paramAnonymousCharSequence.length();
        Preconditions.checkPositionIndex(paramAnonymousInt, j);
        int i = paramAnonymousInt;
        if (paramAnonymousInt == j) {
          i = -1;
        }
        return i;
      }
      
      public final int lastIndexIn(CharSequence paramAnonymousCharSequence)
      {
        return paramAnonymousCharSequence.length() - 1;
      }
      
      public final boolean matches(char paramAnonymousChar)
      {
        return true;
      }
      
      public final boolean matchesAllOf(CharSequence paramAnonymousCharSequence)
      {
        Preconditions.checkNotNull(paramAnonymousCharSequence);
        return true;
      }
      
      public final boolean matchesNoneOf(CharSequence paramAnonymousCharSequence)
      {
        return paramAnonymousCharSequence.length() == 0;
      }
      
      public final CharMatcher negate()
      {
        return NONE;
      }
      
      public final CharMatcher or(CharMatcher paramAnonymousCharMatcher)
      {
        Preconditions.checkNotNull(paramAnonymousCharMatcher);
        return this;
      }
      
      public final String removeFrom(CharSequence paramAnonymousCharSequence)
      {
        Preconditions.checkNotNull(paramAnonymousCharSequence);
        return "";
      }
      
      public final String replaceFrom(CharSequence paramAnonymousCharSequence, char paramAnonymousChar)
      {
        paramAnonymousCharSequence = new char[paramAnonymousCharSequence.length()];
        Arrays.fill(paramAnonymousCharSequence, paramAnonymousChar);
        return new String(paramAnonymousCharSequence);
      }
      
      public final String replaceFrom(CharSequence paramAnonymousCharSequence1, CharSequence paramAnonymousCharSequence2)
      {
        StringBuilder localStringBuilder = new StringBuilder(paramAnonymousCharSequence1.length() * paramAnonymousCharSequence2.length());
        int i = 0;
        while (i < paramAnonymousCharSequence1.length())
        {
          localStringBuilder.append(paramAnonymousCharSequence2);
          i += 1;
        }
        return localStringBuilder.toString();
      }
      
      public final String trimFrom(CharSequence paramAnonymousCharSequence)
      {
        Preconditions.checkNotNull(paramAnonymousCharSequence);
        return "";
      }
    };
    NONE = new c("CharMatcher.NONE")
    {
      public final CharMatcher and(CharMatcher paramAnonymousCharMatcher)
      {
        Preconditions.checkNotNull(paramAnonymousCharMatcher);
        return this;
      }
      
      public final String collapseFrom(CharSequence paramAnonymousCharSequence, char paramAnonymousChar)
      {
        return paramAnonymousCharSequence.toString();
      }
      
      public final int countIn(CharSequence paramAnonymousCharSequence)
      {
        Preconditions.checkNotNull(paramAnonymousCharSequence);
        return 0;
      }
      
      public final int indexIn(CharSequence paramAnonymousCharSequence)
      {
        Preconditions.checkNotNull(paramAnonymousCharSequence);
        return -1;
      }
      
      public final int indexIn(CharSequence paramAnonymousCharSequence, int paramAnonymousInt)
      {
        Preconditions.checkPositionIndex(paramAnonymousInt, paramAnonymousCharSequence.length());
        return -1;
      }
      
      public final int lastIndexIn(CharSequence paramAnonymousCharSequence)
      {
        Preconditions.checkNotNull(paramAnonymousCharSequence);
        return -1;
      }
      
      public final boolean matches(char paramAnonymousChar)
      {
        return false;
      }
      
      public final boolean matchesAllOf(CharSequence paramAnonymousCharSequence)
      {
        return paramAnonymousCharSequence.length() == 0;
      }
      
      public final boolean matchesNoneOf(CharSequence paramAnonymousCharSequence)
      {
        Preconditions.checkNotNull(paramAnonymousCharSequence);
        return true;
      }
      
      public final CharMatcher negate()
      {
        return ANY;
      }
      
      public final CharMatcher or(CharMatcher paramAnonymousCharMatcher)
      {
        return (CharMatcher)Preconditions.checkNotNull(paramAnonymousCharMatcher);
      }
      
      public final String removeFrom(CharSequence paramAnonymousCharSequence)
      {
        return paramAnonymousCharSequence.toString();
      }
      
      public final String replaceFrom(CharSequence paramAnonymousCharSequence, char paramAnonymousChar)
      {
        return paramAnonymousCharSequence.toString();
      }
      
      public final String replaceFrom(CharSequence paramAnonymousCharSequence1, CharSequence paramAnonymousCharSequence2)
      {
        Preconditions.checkNotNull(paramAnonymousCharSequence2);
        return paramAnonymousCharSequence1.toString();
      }
      
      public final String trimFrom(CharSequence paramAnonymousCharSequence)
      {
        return paramAnonymousCharSequence.toString();
      }
      
      public final String trimLeadingFrom(CharSequence paramAnonymousCharSequence)
      {
        return paramAnonymousCharSequence.toString();
      }
      
      public final String trimTrailingFrom(CharSequence paramAnonymousCharSequence)
      {
        return paramAnonymousCharSequence.toString();
      }
    };
    b = Integer.numberOfLeadingZeros(31);
  }
  
  protected CharMatcher()
  {
    this.a = super.toString();
  }
  
  CharMatcher(String paramString)
  {
    this.a = paramString;
  }
  
  private static CharMatcher a(final char paramChar1, final char paramChar2)
  {
    String str1 = String.valueOf(String.valueOf(a(paramChar1)));
    String str2 = String.valueOf(String.valueOf(a(paramChar2)));
    new c(str1.length() + 21 + str2.length() + "CharMatcher.anyOf(\"" + str1 + str2 + "\")")
    {
      @GwtIncompatible("java.util.BitSet")
      final void a(BitSet paramAnonymousBitSet)
      {
        paramAnonymousBitSet.set(paramChar1);
        paramAnonymousBitSet.set(paramChar2);
      }
      
      public final boolean matches(char paramAnonymousChar)
      {
        return (paramAnonymousChar == paramChar1) || (paramAnonymousChar == paramChar2);
      }
    };
  }
  
  private static CharMatcher a(final char paramChar1, final char paramChar2, String paramString)
  {
    new c(paramString)
    {
      @GwtIncompatible("java.util.BitSet")
      final void a(BitSet paramAnonymousBitSet)
      {
        paramAnonymousBitSet.set(paramChar1, paramChar2 + '\001');
      }
      
      public final boolean matches(char paramAnonymousChar)
      {
        return (paramChar1 <= paramAnonymousChar) && (paramAnonymousChar <= paramChar2);
      }
    };
  }
  
  @GwtIncompatible("java.util.BitSet")
  private static CharMatcher a(int paramInt, BitSet paramBitSet, String paramString)
  {
    long l;
    int j;
    boolean bool;
    char[] arrayOfChar;
    switch (paramInt)
    {
    default: 
      i = paramBitSet.length();
      if ((paramInt <= 1023) && (i > paramInt * 4 * 16))
      {
        paramInt = 1;
        if (paramInt == 0) {
          break label249;
        }
        l = 0L;
        j = paramBitSet.cardinality();
        bool = paramBitSet.get(0);
        if (j != 1) {
          break label189;
        }
        i = 2;
        arrayOfChar = new char[i];
        j = arrayOfChar.length - 1;
        paramInt = paramBitSet.nextSetBit(0);
        label102:
        if (paramInt == -1) {
          break label234;
        }
        l |= 1L << paramInt;
      }
      break;
    }
    for (int i = ml.a(paramInt) & j;; i = i + 1 & j) {
      if (arrayOfChar[i] == 0)
      {
        arrayOfChar[i] = ((char)paramInt);
        paramInt = paramBitSet.nextSetBit(paramInt + 1);
        break label102;
        return NONE;
        return is((char)paramBitSet.nextSetBit(0));
        char c1 = (char)paramBitSet.nextSetBit(0);
        return a(c1, (char)paramBitSet.nextSetBit(c1 + '\001'));
        paramInt = 0;
        break;
        label189:
        paramInt = Integer.highestOneBit(j - 1) << 1;
        for (;;)
        {
          i = paramInt;
          if (paramInt * 0.5D >= j) {
            break;
          }
          paramInt <<= 1;
        }
      }
    }
    label234:
    return new ml(arrayOfChar, l, bool, paramString);
    label249:
    return new b(paramBitSet, paramString, (byte)0);
  }
  
  private static String a(char paramChar)
  {
    char[] arrayOfChar = new char[6];
    char[] tmp6_5 = arrayOfChar;
    tmp6_5[0] = 92;
    char[] tmp12_6 = tmp6_5;
    tmp12_6[1] = 117;
    char[] tmp18_12 = tmp12_6;
    tmp18_12[2] = 0;
    char[] tmp24_18 = tmp18_12;
    tmp24_18[3] = 0;
    char[] tmp30_24 = tmp24_18;
    tmp30_24[4] = 0;
    char[] tmp36_30 = tmp30_24;
    tmp36_30[5] = 0;
    tmp36_30;
    char c1 = '\000';
    int i = paramChar;
    paramChar = c1;
    while (paramChar < '\004')
    {
      arrayOfChar[('\005' - paramChar)] = "0123456789ABCDEF".charAt(i & 0xF);
      i = (char)(i >> 4);
      paramChar += '\001';
    }
    return String.copyValueOf(arrayOfChar);
  }
  
  private String a(CharSequence paramCharSequence, int paramInt1, int paramInt2, char paramChar, StringBuilder paramStringBuilder, boolean paramBoolean)
  {
    boolean bool = paramBoolean;
    if (paramInt1 < paramInt2)
    {
      char c1 = paramCharSequence.charAt(paramInt1);
      if (matches(c1))
      {
        paramBoolean = bool;
        if (!bool) {
          paramStringBuilder.append(paramChar);
        }
      }
      for (paramBoolean = true;; paramBoolean = false)
      {
        paramInt1 += 1;
        bool = paramBoolean;
        break;
        paramStringBuilder.append(c1);
      }
    }
    return paramStringBuilder.toString();
  }
  
  public static CharMatcher anyOf(final CharSequence paramCharSequence)
  {
    int i = 0;
    StringBuilder localStringBuilder;
    int j;
    switch (paramCharSequence.length())
    {
    default: 
      paramCharSequence = paramCharSequence.toString().toCharArray();
      Arrays.sort(paramCharSequence);
      localStringBuilder = new StringBuilder("CharMatcher.anyOf(\"");
      j = paramCharSequence.length;
    }
    while (i < j)
    {
      localStringBuilder.append(a(paramCharSequence[i]));
      i += 1;
      continue;
      return NONE;
      return is(paramCharSequence.charAt(0));
      return a(paramCharSequence.charAt(0), paramCharSequence.charAt(1));
    }
    localStringBuilder.append("\")");
    new CharMatcher(localStringBuilder.toString())
    {
      @GwtIncompatible("java.util.BitSet")
      final void a(BitSet paramAnonymousBitSet)
      {
        char[] arrayOfChar = paramCharSequence;
        int j = arrayOfChar.length;
        int i = 0;
        while (i < j)
        {
          paramAnonymousBitSet.set(arrayOfChar[i]);
          i += 1;
        }
      }
      
      public final boolean matches(char paramAnonymousChar)
      {
        return Arrays.binarySearch(paramCharSequence, paramAnonymousChar) >= 0;
      }
    };
  }
  
  public static CharMatcher forPredicate(final Predicate<? super Character> paramPredicate)
  {
    Preconditions.checkNotNull(paramPredicate);
    if ((paramPredicate instanceof CharMatcher)) {
      return (CharMatcher)paramPredicate;
    }
    String str = String.valueOf(String.valueOf(paramPredicate));
    new CharMatcher(str.length() + 26 + "CharMatcher.forPredicate(" + str + ")")
    {
      public final boolean apply(Character paramAnonymousCharacter)
      {
        return paramPredicate.apply(Preconditions.checkNotNull(paramAnonymousCharacter));
      }
      
      public final boolean matches(char paramAnonymousChar)
      {
        return paramPredicate.apply(Character.valueOf(paramAnonymousChar));
      }
    };
  }
  
  public static CharMatcher inRange(char paramChar1, char paramChar2)
  {
    if (paramChar2 >= paramChar1) {}
    for (boolean bool = true;; bool = false)
    {
      Preconditions.checkArgument(bool);
      String str1 = String.valueOf(String.valueOf(a(paramChar1)));
      String str2 = String.valueOf(String.valueOf(a(paramChar2)));
      return a(paramChar1, paramChar2, str1.length() + 27 + str2.length() + "CharMatcher.inRange('" + str1 + "', '" + str2 + "')");
    }
  }
  
  public static CharMatcher is(final char paramChar)
  {
    String str = String.valueOf(String.valueOf(a(paramChar)));
    new c(str.length() + 18 + "CharMatcher.is('" + str + "')")
    {
      @GwtIncompatible("java.util.BitSet")
      final void a(BitSet paramAnonymousBitSet)
      {
        paramAnonymousBitSet.set(paramChar);
      }
      
      public final CharMatcher and(CharMatcher paramAnonymousCharMatcher)
      {
        if (paramAnonymousCharMatcher.matches(paramChar)) {
          return this;
        }
        return NONE;
      }
      
      public final boolean matches(char paramAnonymousChar)
      {
        return paramAnonymousChar == paramChar;
      }
      
      public final CharMatcher negate()
      {
        return isNot(paramChar);
      }
      
      public final CharMatcher or(CharMatcher paramAnonymousCharMatcher)
      {
        if (paramAnonymousCharMatcher.matches(paramChar)) {
          return paramAnonymousCharMatcher;
        }
        return super.or(paramAnonymousCharMatcher);
      }
      
      public final String replaceFrom(CharSequence paramAnonymousCharSequence, char paramAnonymousChar)
      {
        return paramAnonymousCharSequence.toString().replace(paramChar, paramAnonymousChar);
      }
    };
  }
  
  public static CharMatcher isNot(final char paramChar)
  {
    String str = String.valueOf(String.valueOf(a(paramChar)));
    new c(str.length() + 21 + "CharMatcher.isNot('" + str + "')")
    {
      @GwtIncompatible("java.util.BitSet")
      final void a(BitSet paramAnonymousBitSet)
      {
        paramAnonymousBitSet.set(0, paramChar);
        paramAnonymousBitSet.set(paramChar + '\001', 65536);
      }
      
      public final CharMatcher and(CharMatcher paramAnonymousCharMatcher)
      {
        CharMatcher localCharMatcher = paramAnonymousCharMatcher;
        if (paramAnonymousCharMatcher.matches(paramChar)) {
          localCharMatcher = super.and(paramAnonymousCharMatcher);
        }
        return localCharMatcher;
      }
      
      public final boolean matches(char paramAnonymousChar)
      {
        return paramAnonymousChar != paramChar;
      }
      
      public final CharMatcher negate()
      {
        return is(paramChar);
      }
      
      public final CharMatcher or(CharMatcher paramAnonymousCharMatcher)
      {
        Object localObject = this;
        if (paramAnonymousCharMatcher.matches(paramChar)) {
          localObject = ANY;
        }
        return (CharMatcher)localObject;
      }
    };
  }
  
  public static CharMatcher noneOf(CharSequence paramCharSequence)
  {
    return anyOf(paramCharSequence).negate();
  }
  
  CharMatcher a(String paramString)
  {
    throw new UnsupportedOperationException();
  }
  
  @GwtIncompatible("java.util.BitSet")
  public void a(BitSet paramBitSet)
  {
    int i = 65535;
    while (i >= 0)
    {
      if (matches((char)i)) {
        paramBitSet.set(i);
      }
      i -= 1;
    }
  }
  
  public CharMatcher and(CharMatcher paramCharMatcher)
  {
    return new a(this, (CharMatcher)Preconditions.checkNotNull(paramCharMatcher));
  }
  
  @Deprecated
  public boolean apply(Character paramCharacter)
  {
    return matches(paramCharacter.charValue());
  }
  
  @CheckReturnValue
  public String collapseFrom(CharSequence paramCharSequence, char paramChar)
  {
    int k = paramCharSequence.length();
    int i = 0;
    while (i < k)
    {
      char c1 = paramCharSequence.charAt(i);
      int j = i;
      if (matches(c1))
      {
        if ((c1 == paramChar) && ((i == k - 1) || (!matches(paramCharSequence.charAt(i + 1))))) {
          j = i + 1;
        }
      }
      else
      {
        i = j + 1;
        continue;
      }
      return a(paramCharSequence, i + 1, k, paramChar, new StringBuilder(k).append(paramCharSequence.subSequence(0, i)).append(paramChar), true);
    }
    return paramCharSequence.toString();
  }
  
  public int countIn(CharSequence paramCharSequence)
  {
    int i = 0;
    int k;
    for (int j = 0; i < paramCharSequence.length(); j = k)
    {
      k = j;
      if (matches(paramCharSequence.charAt(i))) {
        k = j + 1;
      }
      i += 1;
    }
    return j;
  }
  
  public int indexIn(CharSequence paramCharSequence)
  {
    int j = paramCharSequence.length();
    int i = 0;
    while (i < j)
    {
      if (matches(paramCharSequence.charAt(i))) {
        return i;
      }
      i += 1;
    }
    return -1;
  }
  
  public int indexIn(CharSequence paramCharSequence, int paramInt)
  {
    int i = paramCharSequence.length();
    Preconditions.checkPositionIndex(paramInt, i);
    while (paramInt < i)
    {
      if (matches(paramCharSequence.charAt(paramInt))) {
        return paramInt;
      }
      paramInt += 1;
    }
    return -1;
  }
  
  public int lastIndexIn(CharSequence paramCharSequence)
  {
    int i = paramCharSequence.length() - 1;
    while (i >= 0)
    {
      if (matches(paramCharSequence.charAt(i))) {
        return i;
      }
      i -= 1;
    }
    return -1;
  }
  
  public abstract boolean matches(char paramChar);
  
  public boolean matchesAllOf(CharSequence paramCharSequence)
  {
    int i = paramCharSequence.length() - 1;
    while (i >= 0)
    {
      if (!matches(paramCharSequence.charAt(i))) {
        return false;
      }
      i -= 1;
    }
    return true;
  }
  
  public boolean matchesAnyOf(CharSequence paramCharSequence)
  {
    return !matchesNoneOf(paramCharSequence);
  }
  
  public boolean matchesNoneOf(CharSequence paramCharSequence)
  {
    return indexIn(paramCharSequence) == -1;
  }
  
  public CharMatcher negate()
  {
    return new e(this);
  }
  
  public CharMatcher or(CharMatcher paramCharMatcher)
  {
    return new f(this, (CharMatcher)Preconditions.checkNotNull(paramCharMatcher));
  }
  
  public CharMatcher precomputed()
  {
    BitSet localBitSet = new BitSet();
    a(localBitSet);
    int i = localBitSet.cardinality();
    if (i * 2 <= 65536) {
      return a(i, localBitSet, this.a);
    }
    localBitSet.flip(0, 65536);
    String str1;
    if (this.a.endsWith(".negate()")) {
      str1 = this.a.substring(0, this.a.length() - ".negate()".length());
    }
    for (;;)
    {
      return new d(toString(), a(65536 - i, localBitSet, str1));
      str1 = String.valueOf(this.a);
      String str2 = String.valueOf(".negate()");
      if (str2.length() != 0) {
        str1 = str1.concat(str2);
      } else {
        str1 = new String(str1);
      }
    }
  }
  
  @CheckReturnValue
  public String removeFrom(CharSequence paramCharSequence)
  {
    paramCharSequence = paramCharSequence.toString();
    int j = indexIn(paramCharSequence);
    if (j == -1) {
      return paramCharSequence;
    }
    paramCharSequence = paramCharSequence.toCharArray();
    int i = 1;
    for (;;)
    {
      j += 1;
      if (j == paramCharSequence.length) {
        break;
      }
      if (!matches(paramCharSequence[j])) {
        paramCharSequence[(j - i)] = paramCharSequence[j];
      } else {
        i += 1;
      }
    }
    return new String(paramCharSequence, 0, j - i);
  }
  
  @CheckReturnValue
  public String replaceFrom(CharSequence paramCharSequence, char paramChar)
  {
    paramCharSequence = paramCharSequence.toString();
    int i = indexIn(paramCharSequence);
    if (i == -1) {
      return paramCharSequence;
    }
    paramCharSequence = paramCharSequence.toCharArray();
    paramCharSequence[i] = paramChar;
    i += 1;
    while (i < paramCharSequence.length)
    {
      if (matches(paramCharSequence[i])) {
        paramCharSequence[i] = paramChar;
      }
      i += 1;
    }
    return new String(paramCharSequence);
  }
  
  @CheckReturnValue
  public String replaceFrom(CharSequence paramCharSequence1, CharSequence paramCharSequence2)
  {
    int j = 0;
    int i = paramCharSequence2.length();
    if (i == 0) {
      return removeFrom(paramCharSequence1);
    }
    if (i == 1) {
      return replaceFrom(paramCharSequence1, paramCharSequence2.charAt(0));
    }
    paramCharSequence1 = paramCharSequence1.toString();
    i = indexIn(paramCharSequence1);
    if (i == -1) {
      return paramCharSequence1;
    }
    int n = paramCharSequence1.length();
    StringBuilder localStringBuilder = new StringBuilder(n * 3 / 2 + 16);
    int k;
    int m;
    do
    {
      localStringBuilder.append(paramCharSequence1, j, i);
      localStringBuilder.append(paramCharSequence2);
      k = i + 1;
      m = indexIn(paramCharSequence1, k);
      j = k;
      i = m;
    } while (m != -1);
    localStringBuilder.append(paramCharSequence1, k, n);
    return localStringBuilder.toString();
  }
  
  @CheckReturnValue
  public String retainFrom(CharSequence paramCharSequence)
  {
    return negate().removeFrom(paramCharSequence);
  }
  
  public String toString()
  {
    return this.a;
  }
  
  @CheckReturnValue
  public String trimAndCollapseFrom(CharSequence paramCharSequence, char paramChar)
  {
    int k = paramCharSequence.length();
    int i = 0;
    while ((i < k) && (matches(paramCharSequence.charAt(i)))) {
      i += 1;
    }
    int j = k - 1;
    while ((j > i) && (matches(paramCharSequence.charAt(j)))) {
      j -= 1;
    }
    if ((i == 0) && (j == k - 1)) {
      return collapseFrom(paramCharSequence, paramChar);
    }
    return a(paramCharSequence, i, j + 1, paramChar, new StringBuilder(j + 1 - i), false);
  }
  
  @CheckReturnValue
  public String trimFrom(CharSequence paramCharSequence)
  {
    int j = paramCharSequence.length();
    int i = 0;
    while ((i < j) && (matches(paramCharSequence.charAt(i)))) {
      i += 1;
    }
    j -= 1;
    while ((j > i) && (matches(paramCharSequence.charAt(j)))) {
      j -= 1;
    }
    return paramCharSequence.subSequence(i, j + 1).toString();
  }
  
  @CheckReturnValue
  public String trimLeadingFrom(CharSequence paramCharSequence)
  {
    int j = paramCharSequence.length();
    int i = 0;
    while (i < j)
    {
      if (!matches(paramCharSequence.charAt(i))) {
        return paramCharSequence.subSequence(i, j).toString();
      }
      i += 1;
    }
    return "";
  }
  
  @CheckReturnValue
  public String trimTrailingFrom(CharSequence paramCharSequence)
  {
    int i = paramCharSequence.length() - 1;
    while (i >= 0)
    {
      if (!matches(paramCharSequence.charAt(i))) {
        return paramCharSequence.subSequence(0, i + 1).toString();
      }
      i -= 1;
    }
    return "";
  }
  
  static final class a
    extends CharMatcher
  {
    final CharMatcher c;
    final CharMatcher d;
    
    a(CharMatcher paramCharMatcher1, CharMatcher paramCharMatcher2)
    {
      this(paramCharMatcher1, paramCharMatcher2, str1.length() + 19 + str2.length() + "CharMatcher.and(" + str1 + ", " + str2 + ")");
    }
    
    private a(CharMatcher paramCharMatcher1, CharMatcher paramCharMatcher2, String paramString)
    {
      super();
      this.c = ((CharMatcher)Preconditions.checkNotNull(paramCharMatcher1));
      this.d = ((CharMatcher)Preconditions.checkNotNull(paramCharMatcher2));
    }
    
    final CharMatcher a(String paramString)
    {
      return new a(this.c, this.d, paramString);
    }
    
    @GwtIncompatible("java.util.BitSet")
    final void a(BitSet paramBitSet)
    {
      BitSet localBitSet1 = new BitSet();
      this.c.a(localBitSet1);
      BitSet localBitSet2 = new BitSet();
      this.d.a(localBitSet2);
      localBitSet1.and(localBitSet2);
      paramBitSet.or(localBitSet1);
    }
    
    public final boolean matches(char paramChar)
    {
      return (this.c.matches(paramChar)) && (this.d.matches(paramChar));
    }
  }
  
  @GwtIncompatible("java.util.BitSet")
  static final class b
    extends CharMatcher.c
  {
    private final BitSet c;
    
    private b(BitSet paramBitSet, String paramString)
    {
      super();
      if (paramBitSet.length() + 64 < paramBitSet.size()) {
        paramBitSet = (BitSet)paramBitSet.clone();
      }
      for (;;)
      {
        this.c = paramBitSet;
        return;
      }
    }
    
    final void a(BitSet paramBitSet)
    {
      paramBitSet.or(this.c);
    }
    
    public final boolean matches(char paramChar)
    {
      return this.c.get(paramChar);
    }
  }
  
  public static abstract class c
    extends CharMatcher
  {
    protected c(String paramString)
    {
      super();
    }
    
    public CharMatcher negate()
    {
      return new CharMatcher.d(this);
    }
    
    public final CharMatcher precomputed()
    {
      return this;
    }
  }
  
  static final class d
    extends CharMatcher.e
  {
    d(CharMatcher paramCharMatcher)
    {
      super();
    }
    
    d(String paramString, CharMatcher paramCharMatcher)
    {
      super(paramCharMatcher);
    }
    
    final CharMatcher a(String paramString)
    {
      return new d(paramString, this.c);
    }
    
    public final CharMatcher precomputed()
    {
      return this;
    }
  }
  
  static class e
    extends CharMatcher
  {
    final CharMatcher c;
    
    e(CharMatcher paramCharMatcher)
    {
      this(str.length() + 9 + str + ".negate()", paramCharMatcher);
    }
    
    e(String paramString, CharMatcher paramCharMatcher)
    {
      super();
      this.c = paramCharMatcher;
    }
    
    CharMatcher a(String paramString)
    {
      return new e(paramString, this.c);
    }
    
    @GwtIncompatible("java.util.BitSet")
    final void a(BitSet paramBitSet)
    {
      BitSet localBitSet = new BitSet();
      this.c.a(localBitSet);
      localBitSet.flip(0, 65536);
      paramBitSet.or(localBitSet);
    }
    
    public int countIn(CharSequence paramCharSequence)
    {
      return paramCharSequence.length() - this.c.countIn(paramCharSequence);
    }
    
    public boolean matches(char paramChar)
    {
      return !this.c.matches(paramChar);
    }
    
    public boolean matchesAllOf(CharSequence paramCharSequence)
    {
      return this.c.matchesNoneOf(paramCharSequence);
    }
    
    public boolean matchesNoneOf(CharSequence paramCharSequence)
    {
      return this.c.matchesAllOf(paramCharSequence);
    }
    
    public CharMatcher negate()
    {
      return this.c;
    }
  }
  
  static final class f
    extends CharMatcher
  {
    final CharMatcher c;
    final CharMatcher d;
    
    f(CharMatcher paramCharMatcher1, CharMatcher paramCharMatcher2)
    {
      this(paramCharMatcher1, paramCharMatcher2, str1.length() + 18 + str2.length() + "CharMatcher.or(" + str1 + ", " + str2 + ")");
    }
    
    private f(CharMatcher paramCharMatcher1, CharMatcher paramCharMatcher2, String paramString)
    {
      super();
      this.c = ((CharMatcher)Preconditions.checkNotNull(paramCharMatcher1));
      this.d = ((CharMatcher)Preconditions.checkNotNull(paramCharMatcher2));
    }
    
    final CharMatcher a(String paramString)
    {
      return new f(this.c, this.d, paramString);
    }
    
    @GwtIncompatible("java.util.BitSet")
    final void a(BitSet paramBitSet)
    {
      this.c.a(paramBitSet);
      this.d.a(paramBitSet);
    }
    
    public final boolean matches(char paramChar)
    {
      return (this.c.matches(paramChar)) || (this.d.matches(paramChar));
    }
  }
  
  static final class g
    extends CharMatcher
  {
    private final char[] c;
    private final char[] d;
    
    g(String paramString, char[] paramArrayOfChar1, char[] paramArrayOfChar2)
    {
      super();
      this.c = paramArrayOfChar1;
      this.d = paramArrayOfChar2;
      int i;
      if (paramArrayOfChar1.length == paramArrayOfChar2.length)
      {
        bool = true;
        Preconditions.checkArgument(bool);
        i = 0;
        label33:
        if (i >= paramArrayOfChar1.length) {
          return;
        }
        if (paramArrayOfChar1[i] > paramArrayOfChar2[i]) {
          break label104;
        }
        bool = true;
        label54:
        Preconditions.checkArgument(bool);
        if (i + 1 < paramArrayOfChar1.length) {
          if (paramArrayOfChar2[i] >= paramArrayOfChar1[(i + 1)]) {
            break label110;
          }
        }
      }
      label104:
      label110:
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool);
        i += 1;
        break label33;
        bool = false;
        break;
        bool = false;
        break label54;
      }
    }
    
    public final boolean matches(char paramChar)
    {
      int i = Arrays.binarySearch(this.c, paramChar);
      if (i >= 0) {}
      do
      {
        return true;
        i = (i ^ 0xFFFFFFFF) - 1;
      } while ((i >= 0) && (paramChar <= this.d[i]));
      return false;
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/com/google/common/base/CharMatcher.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */