Initial commit

sources/com/google/common/base/Absent.java

@@ -0,0 +1,81 @@
+package com.google.common.base;
+
+import java.util.Collections;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+final class Absent<T> extends Optional<T> {
+    static final Absent<Object> a = new Absent<>();
+
+    private Absent() {
+    }
+
+    static <T> Optional<T> a() {
+        return a;
+    }
+
+    private Object readResolve() {
+        return a;
+    }
+
+    @Override // com.google.common.base.Optional
+    public Set<T> asSet() {
+        return Collections.emptySet();
+    }
+
+    @Override // com.google.common.base.Optional
+    public boolean equals(Object obj) {
+        return obj == this;
+    }
+
+    @Override // com.google.common.base.Optional
+    public T get() {
+        throw new IllegalStateException("Optional.get() cannot be called on an absent value");
+    }
+
+    @Override // com.google.common.base.Optional
+    public int hashCode() {
+        return 2040732332;
+    }
+
+    @Override // com.google.common.base.Optional
+    public boolean isPresent() {
+        return false;
+    }
+
+    @Override // com.google.common.base.Optional
+    public T or(T t) {
+        Preconditions.a(t, "use Optional.orNull() instead of Optional.or(null)");
+        return t;
+    }
+
+    @Override // com.google.common.base.Optional
+    public T orNull() {
+        return null;
+    }
+
+    @Override // com.google.common.base.Optional
+    public String toString() {
+        return "Optional.absent()";
+    }
+
+    @Override // com.google.common.base.Optional
+    public <V> Optional<V> transform(Function<? super T, V> function) {
+        Preconditions.a(function);
+        return Optional.absent();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // com.google.common.base.Optional
+    public Optional<T> or(Optional<? extends T> optional) {
+        Preconditions.a(optional);
+        return optional;
+    }
+
+    @Override // com.google.common.base.Optional
+    public T or(Supplier<? extends T> supplier) {
+        T t = supplier.get();
+        Preconditions.a(t, "use Optional.orNull() instead of a Supplier that returns null");
+        return t;
+    }
+}

sources/com/google/common/base/AbstractIterator.java

@@ -0,0 +1,82 @@
+package com.google.common.base;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/* loaded from: classes.dex */
+abstract class AbstractIterator<T> implements Iterator<T> {
+    private State a = State.NOT_READY;
+    private T b;
+
+    /* renamed from: com.google.common.base.AbstractIterator$1, reason: invalid class name */
+    static /* synthetic */ class AnonymousClass1 {
+        static final /* synthetic */ int[] a = new int[State.values().length];
+
+        static {
+            try {
+                a[State.READY.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                a[State.DONE.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+        }
+    }
+
+    private enum State {
+        READY,
+        NOT_READY,
+        DONE,
+        FAILED
+    }
+
+    protected AbstractIterator() {
+    }
+
+    private boolean c() {
+        this.a = State.FAILED;
+        this.b = a();
+        if (this.a == State.DONE) {
+            return false;
+        }
+        this.a = State.READY;
+        return true;
+    }
+
+    protected abstract T a();
+
+    protected final T b() {
+        this.a = State.DONE;
+        return null;
+    }
+
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        Preconditions.b(this.a != State.FAILED);
+        int i = AnonymousClass1.a[this.a.ordinal()];
+        if (i == 1) {
+            return true;
+        }
+        if (i != 2) {
+            return c();
+        }
+        return false;
+    }
+
+    @Override // java.util.Iterator
+    public final T next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        this.a = State.NOT_READY;
+        T t = this.b;
+        this.b = null;
+        return t;
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        throw new UnsupportedOperationException();
+    }
+}

sources/com/google/common/base/Ascii.java

@@ -0,0 +1,56 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+public final class Ascii {
+    public static String a(String str) {
+        int length = str.length();
+        int i = 0;
+        while (i < length) {
+            if (b(str.charAt(i))) {
+                char[] charArray = str.toCharArray();
+                while (i < length) {
+                    char c = charArray[i];
+                    if (b(c)) {
+                        charArray[i] = (char) (c ^ ' ');
+                    }
+                    i++;
+                }
+                return String.valueOf(charArray);
+            }
+            i++;
+        }
+        return str;
+    }
+
+    public static boolean a(char c) {
+        return c >= 'a' && c <= 'z';
+    }
+
+    public static String b(String str) {
+        int length = str.length();
+        int i = 0;
+        while (i < length) {
+            if (a(str.charAt(i))) {
+                char[] charArray = str.toCharArray();
+                while (i < length) {
+                    char c = charArray[i];
+                    if (a(c)) {
+                        charArray[i] = (char) (c & '_');
+                    }
+                    i++;
+                }
+                return String.valueOf(charArray);
+            }
+            i++;
+        }
+        return str;
+    }
+
+    public static boolean b(char c) {
+        return c >= 'A' && c <= 'Z';
+    }
+
+    public static char c(char c) {
+        return a(c) ? (char) (c & '_') : c;
+    }
+}

sources/com/google/common/base/CaseFormat.java

@@ -0,0 +1,174 @@
+package com.google.common.base;
+
+import java.io.Serializable;
+
+/* JADX WARN: Enum visitor error
+jadx.core.utils.exceptions.JadxRuntimeException: Init of enum field 'LOWER_UNDERSCORE' uses external variables
+	at jadx.core.dex.visitors.EnumVisitor.createEnumFieldByConstructor(EnumVisitor.java:451)
+	at jadx.core.dex.visitors.EnumVisitor.processEnumFieldByField(EnumVisitor.java:372)
+	at jadx.core.dex.visitors.EnumVisitor.processEnumFieldByWrappedInsn(EnumVisitor.java:337)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromFilledArray(EnumVisitor.java:322)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromInsn(EnumVisitor.java:262)
+	at jadx.core.dex.visitors.EnumVisitor.convertToEnum(EnumVisitor.java:151)
+	at jadx.core.dex.visitors.EnumVisitor.visit(EnumVisitor.java:100)
+ */
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* loaded from: classes.dex */
+public abstract class CaseFormat {
+    private static final /* synthetic */ CaseFormat[] $VALUES;
+    public static final CaseFormat LOWER_CAMEL;
+    public static final CaseFormat LOWER_HYPHEN = new CaseFormat("LOWER_HYPHEN", 0, CharMatcher.c('-'), "-") { // from class: com.google.common.base.CaseFormat.1
+        @Override // com.google.common.base.CaseFormat
+        String convert(CaseFormat caseFormat, String str) {
+            return caseFormat == CaseFormat.LOWER_UNDERSCORE ? str.replace('-', '_') : caseFormat == CaseFormat.UPPER_UNDERSCORE ? Ascii.b(str.replace('-', '_')) : super.convert(caseFormat, str);
+        }
+
+        @Override // com.google.common.base.CaseFormat
+        String normalizeWord(String str) {
+            return Ascii.a(str);
+        }
+    };
+    public static final CaseFormat LOWER_UNDERSCORE;
+    public static final CaseFormat UPPER_CAMEL;
+    public static final CaseFormat UPPER_UNDERSCORE;
+    private final CharMatcher wordBoundary;
+    private final String wordSeparator;
+
+    private static final class StringConverter extends Converter<String, String> implements Serializable {
+        private final CaseFormat b;
+        private final CaseFormat c;
+
+        StringConverter(CaseFormat caseFormat, CaseFormat caseFormat2) {
+            Preconditions.a(caseFormat);
+            this.b = caseFormat;
+            Preconditions.a(caseFormat2);
+            this.c = caseFormat2;
+        }
+
+        /* JADX INFO: Access modifiers changed from: protected */
+        @Override // com.google.common.base.Converter
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public String c(String str) {
+            return this.b.to(this.c, str);
+        }
+
+        @Override // com.google.common.base.Function
+        public boolean equals(Object obj) {
+            if (!(obj instanceof StringConverter)) {
+                return false;
+            }
+            StringConverter stringConverter = (StringConverter) obj;
+            return this.b.equals(stringConverter.b) && this.c.equals(stringConverter.c);
+        }
+
+        public int hashCode() {
+            return this.b.hashCode() ^ this.c.hashCode();
+        }
+
+        public String toString() {
+            return this.b + ".converterTo(" + this.c + ")";
+        }
+    }
+
+    static {
+        String str = "_";
+        LOWER_UNDERSCORE = new CaseFormat("LOWER_UNDERSCORE", 1, CharMatcher.c('_'), str) { // from class: com.google.common.base.CaseFormat.2
+            @Override // com.google.common.base.CaseFormat
+            String convert(CaseFormat caseFormat, String str2) {
+                return caseFormat == CaseFormat.LOWER_HYPHEN ? str2.replace('_', '-') : caseFormat == CaseFormat.UPPER_UNDERSCORE ? Ascii.b(str2) : super.convert(caseFormat, str2);
+            }
+
+            @Override // com.google.common.base.CaseFormat
+            String normalizeWord(String str2) {
+                return Ascii.a(str2);
+            }
+        };
+        String str2 = "";
+        LOWER_CAMEL = new CaseFormat("LOWER_CAMEL", 2, CharMatcher.a('A', 'Z'), str2) { // from class: com.google.common.base.CaseFormat.3
+            @Override // com.google.common.base.CaseFormat
+            String normalizeWord(String str3) {
+                return CaseFormat.firstCharOnlyToUpper(str3);
+            }
+        };
+        UPPER_CAMEL = new CaseFormat("UPPER_CAMEL", 3, CharMatcher.a('A', 'Z'), str2) { // from class: com.google.common.base.CaseFormat.4
+            @Override // com.google.common.base.CaseFormat
+            String normalizeWord(String str3) {
+                return CaseFormat.firstCharOnlyToUpper(str3);
+            }
+        };
+        UPPER_UNDERSCORE = new CaseFormat("UPPER_UNDERSCORE", 4, CharMatcher.c('_'), str) { // from class: com.google.common.base.CaseFormat.5
+            @Override // com.google.common.base.CaseFormat
+            String convert(CaseFormat caseFormat, String str3) {
+                return caseFormat == CaseFormat.LOWER_HYPHEN ? Ascii.a(str3.replace('_', '-')) : caseFormat == CaseFormat.LOWER_UNDERSCORE ? Ascii.a(str3) : super.convert(caseFormat, str3);
+            }
+
+            @Override // com.google.common.base.CaseFormat
+            String normalizeWord(String str3) {
+                return Ascii.b(str3);
+            }
+        };
+        $VALUES = new CaseFormat[]{LOWER_HYPHEN, LOWER_UNDERSCORE, LOWER_CAMEL, UPPER_CAMEL, UPPER_UNDERSCORE};
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static String firstCharOnlyToUpper(String str) {
+        if (str.isEmpty()) {
+            return str;
+        }
+        return Ascii.c(str.charAt(0)) + Ascii.a(str.substring(1));
+    }
+
+    private String normalizeFirstWord(String str) {
+        return this == LOWER_CAMEL ? Ascii.a(str) : normalizeWord(str);
+    }
+
+    public static CaseFormat valueOf(String str) {
+        return (CaseFormat) Enum.valueOf(CaseFormat.class, str);
+    }
+
+    public static CaseFormat[] values() {
+        return (CaseFormat[]) $VALUES.clone();
+    }
+
+    String convert(CaseFormat caseFormat, String str) {
+        int i = 0;
+        StringBuilder sb = null;
+        int i2 = -1;
+        while (true) {
+            i2 = this.wordBoundary.a(str, i2 + 1);
+            if (i2 == -1) {
+                break;
+            }
+            if (i == 0) {
+                sb = new StringBuilder(str.length() + (this.wordSeparator.length() * 4));
+                sb.append(caseFormat.normalizeFirstWord(str.substring(i, i2)));
+            } else {
+                sb.append(caseFormat.normalizeWord(str.substring(i, i2)));
+            }
+            sb.append(caseFormat.wordSeparator);
+            i = this.wordSeparator.length() + i2;
+        }
+        if (i == 0) {
+            return caseFormat.normalizeFirstWord(str);
+        }
+        sb.append(caseFormat.normalizeWord(str.substring(i)));
+        return sb.toString();
+    }
+
+    public Converter<String, String> converterTo(CaseFormat caseFormat) {
+        return new StringConverter(this, caseFormat);
+    }
+
+    abstract String normalizeWord(String str);
+
+    public final String to(CaseFormat caseFormat, String str) {
+        Preconditions.a(caseFormat);
+        Preconditions.a(str);
+        return caseFormat == this ? str : convert(caseFormat, str);
+    }
+
+    private CaseFormat(String str, int i, CharMatcher charMatcher, String str2) {
+        this.wordBoundary = charMatcher;
+        this.wordSeparator = str2;
+    }
+}

sources/com/google/common/base/CharMatcher.java

@@ -0,0 +1,490 @@
+package com.google.common.base;
+
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+public abstract class CharMatcher implements Predicate<Character> {
+
+    private static final class Any extends NamedFastMatcher {
+        static final Any b = new Any();
+
+        private Any() {
+            super("CharMatcher.any()");
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public int a(CharSequence charSequence, int i) {
+            int length = charSequence.length();
+            Preconditions.b(i, length);
+            if (i == length) {
+                return -1;
+            }
+            return i;
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return true;
+        }
+    }
+
+    private static final class Ascii extends NamedFastMatcher {
+        static final Ascii b = new Ascii();
+
+        Ascii() {
+            super("CharMatcher.ascii()");
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return c <= 127;
+        }
+    }
+
+    private static final class BreakingWhitespace extends CharMatcher {
+        static final CharMatcher a = new BreakingWhitespace();
+
+        private BreakingWhitespace() {
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            if (c != ' ' && c != 133 && c != 5760) {
+                if (c == 8199) {
+                    return false;
+                }
+                if (c != 8287 && c != 12288 && c != 8232 && c != 8233) {
+                    switch (c) {
+                        case '\t':
+                        case '\n':
+                        case 11:
+                        case '\f':
+                        case '\r':
+                            break;
+                        default:
+                            return c >= 8192 && c <= 8202;
+                    }
+                }
+            }
+            return true;
+        }
+
+        @Override // com.google.common.base.Predicate
+        @Deprecated
+        public /* bridge */ /* synthetic */ boolean apply(Character ch) {
+            return super.a(ch);
+        }
+
+        public String toString() {
+            return "CharMatcher.breakingWhitespace()";
+        }
+    }
+
+    private static final class Digit extends RangesMatcher {
+        static final Digit d = new Digit();
+
+        private Digit() {
+            super("CharMatcher.digit()", p(), o());
+        }
+
+        private static char[] o() {
+            char[] cArr = new char[31];
+            for (int i = 0; i < 31; i++) {
+                cArr[i] = (char) ("0٠۰߀०০੦૦୦௦౦೦൦๐໐༠၀႐០᠐᥆᧐᭐᮰᱀᱐꘠꣐꤀꩐０".charAt(i) + '\t');
+            }
+            return cArr;
+        }
+
+        private static char[] p() {
+            return "0٠۰߀०০੦૦୦௦౦೦൦๐໐༠၀႐០᠐᥆᧐᭐᮰᱀᱐꘠꣐꤀꩐０".toCharArray();
+        }
+    }
+
+    static abstract class FastMatcher extends CharMatcher {
+        FastMatcher() {
+        }
+
+        @Override // com.google.common.base.Predicate
+        @Deprecated
+        public /* bridge */ /* synthetic */ boolean apply(Character ch) {
+            return super.a(ch);
+        }
+    }
+
+    private static final class InRange extends FastMatcher {
+        private final char a;
+        private final char b;
+
+        InRange(char c, char c2) {
+            Preconditions.a(c2 >= c);
+            this.a = c;
+            this.b = c2;
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return this.a <= c && c <= this.b;
+        }
+
+        public String toString() {
+            return "CharMatcher.inRange('" + CharMatcher.d(this.a) + "', '" + CharMatcher.d(this.b) + "')";
+        }
+    }
+
+    private static final class Invisible extends RangesMatcher {
+        static final Invisible d = new Invisible();
+
+        private Invisible() {
+            super("CharMatcher.invisible()", "\u0000\u007f\u00ad\u0600\u061c\u06dd\u070f\u1680\u180e\u2000\u2028\u205f\u2066\u2067\u2068\u2069\u206a\u3000\ud800\ufeff\ufff9\ufffa".toCharArray(), "  \u00ad\u0604\u061c\u06dd\u070f\u1680\u180e\u200f \u2064\u2066\u2067\u2068\u2069\u206f\u3000\uf8ff\ufeff\ufff9\ufffb".toCharArray());
+        }
+    }
+
+    private static final class Is extends FastMatcher {
+        private final char a;
+
+        Is(char c) {
+            this.a = c;
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return c == this.a;
+        }
+
+        public String toString() {
+            return "CharMatcher.is('" + CharMatcher.d(this.a) + "')";
+        }
+    }
+
+    private static final class JavaDigit extends CharMatcher {
+        static final JavaDigit a = new JavaDigit();
+
+        private JavaDigit() {
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return Character.isDigit(c);
+        }
+
+        @Override // com.google.common.base.Predicate
+        @Deprecated
+        public /* bridge */ /* synthetic */ boolean apply(Character ch) {
+            return super.a(ch);
+        }
+
+        public String toString() {
+            return "CharMatcher.javaDigit()";
+        }
+    }
+
+    private static final class JavaIsoControl extends NamedFastMatcher {
+        static final JavaIsoControl b = new JavaIsoControl();
+
+        private JavaIsoControl() {
+            super("CharMatcher.javaIsoControl()");
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return c <= 31 || (c >= 127 && c <= 159);
+        }
+    }
+
+    private static final class JavaLetter extends CharMatcher {
+        static final JavaLetter a = new JavaLetter();
+
+        private JavaLetter() {
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return Character.isLetter(c);
+        }
+
+        @Override // com.google.common.base.Predicate
+        @Deprecated
+        public /* bridge */ /* synthetic */ boolean apply(Character ch) {
+            return super.a(ch);
+        }
+
+        public String toString() {
+            return "CharMatcher.javaLetter()";
+        }
+    }
+
+    private static final class JavaLetterOrDigit extends CharMatcher {
+        static final JavaLetterOrDigit a = new JavaLetterOrDigit();
+
+        private JavaLetterOrDigit() {
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return Character.isLetterOrDigit(c);
+        }
+
+        @Override // com.google.common.base.Predicate
+        @Deprecated
+        public /* bridge */ /* synthetic */ boolean apply(Character ch) {
+            return super.a(ch);
+        }
+
+        public String toString() {
+            return "CharMatcher.javaLetterOrDigit()";
+        }
+    }
+
+    private static final class JavaLowerCase extends CharMatcher {
+        static final JavaLowerCase a = new JavaLowerCase();
+
+        private JavaLowerCase() {
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return Character.isLowerCase(c);
+        }
+
+        @Override // com.google.common.base.Predicate
+        @Deprecated
+        public /* bridge */ /* synthetic */ boolean apply(Character ch) {
+            return super.a(ch);
+        }
+
+        public String toString() {
+            return "CharMatcher.javaLowerCase()";
+        }
+    }
+
+    private static final class JavaUpperCase extends CharMatcher {
+        static final JavaUpperCase a = new JavaUpperCase();
+
+        private JavaUpperCase() {
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return Character.isUpperCase(c);
+        }
+
+        @Override // com.google.common.base.Predicate
+        @Deprecated
+        public /* bridge */ /* synthetic */ boolean apply(Character ch) {
+            return super.a(ch);
+        }
+
+        public String toString() {
+            return "CharMatcher.javaUpperCase()";
+        }
+    }
+
+    static abstract class NamedFastMatcher extends FastMatcher {
+        private final String a;
+
+        NamedFastMatcher(String str) {
+            Preconditions.a(str);
+            this.a = str;
+        }
+
+        public final String toString() {
+            return this.a;
+        }
+    }
+
+    private static final class None extends NamedFastMatcher {
+        static final None b = new None();
+
+        private None() {
+            super("CharMatcher.none()");
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public int a(CharSequence charSequence, int i) {
+            Preconditions.b(i, charSequence.length());
+            return -1;
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            return false;
+        }
+    }
+
+    private static class RangesMatcher extends CharMatcher {
+        private final String a;
+        private final char[] b;
+        private final char[] c;
+
+        RangesMatcher(String str, char[] cArr, char[] cArr2) {
+            this.a = str;
+            this.b = cArr;
+            this.c = cArr2;
+            Preconditions.a(cArr.length == cArr2.length);
+            int i = 0;
+            while (i < cArr.length) {
+                Preconditions.a(cArr[i] <= cArr2[i]);
+                int i2 = i + 1;
+                if (i2 < cArr.length) {
+                    Preconditions.a(cArr2[i] < cArr[i2]);
+                }
+                i = i2;
+            }
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c) {
+            int binarySearch = Arrays.binarySearch(this.b, c);
+            if (binarySearch >= 0) {
+                return true;
+            }
+            int i = (~binarySearch) - 1;
+            return i >= 0 && c <= this.c[i];
+        }
+
+        @Override // com.google.common.base.Predicate
+        @Deprecated
+        public /* bridge */ /* synthetic */ boolean apply(Character ch) {
+            return super.a(ch);
+        }
+
+        public String toString() {
+            return this.a;
+        }
+    }
+
+    private static final class SingleWidth extends RangesMatcher {
+        static final SingleWidth d = new SingleWidth();
+
+        private SingleWidth() {
+            super("CharMatcher.singleWidth()", "\u0000־א׳\u0600ݐ\u0e00Ḁ℀ﭐﹰ｡".toCharArray(), "ӹ־ת״ۿݿ\u0e7f₯℺﷿\ufeffￜ".toCharArray());
+        }
+    }
+
+    static final class Whitespace extends NamedFastMatcher {
+        static final int b = Integer.numberOfLeadingZeros(31);
+        static final Whitespace c = new Whitespace();
+
+        Whitespace() {
+            super("CharMatcher.whitespace()");
+        }
+
+        @Override // com.google.common.base.CharMatcher
+        public boolean a(char c2) {
+            return "\u2002\u3000\r\u0085\u200a\u2005\u2000\u3000\u2029\u000b\u3000\u2008\u2003\u205f\u3000\u1680\t \u2006\u2001  \f\u2009\u3000\u2004\u3000\u3000\u2028\n \u3000".charAt((48906 * c2) >>> b) == c2;
+        }
+    }
+
+    static {
+        n();
+        c();
+        b();
+        d();
+        f();
+        h();
+        i();
+        k();
+        j();
+        g();
+        e();
+        m();
+        a();
+        l();
+    }
+
+    protected CharMatcher() {
+    }
+
+    public static CharMatcher a() {
+        return Any.b;
+    }
+
+    public static CharMatcher c() {
+        return BreakingWhitespace.a;
+    }
+
+    public static CharMatcher d() {
+        return Digit.d;
+    }
+
+    public static CharMatcher e() {
+        return Invisible.d;
+    }
+
+    public static CharMatcher f() {
+        return JavaDigit.a;
+    }
+
+    public static CharMatcher g() {
+        return JavaIsoControl.b;
+    }
+
+    public static CharMatcher h() {
+        return JavaLetter.a;
+    }
+
+    public static CharMatcher i() {
+        return JavaLetterOrDigit.a;
+    }
+
+    public static CharMatcher j() {
+        return JavaLowerCase.a;
+    }
+
+    public static CharMatcher k() {
+        return JavaUpperCase.a;
+    }
+
+    public static CharMatcher l() {
+        return None.b;
+    }
+
+    public static CharMatcher m() {
+        return SingleWidth.d;
+    }
+
+    public static CharMatcher n() {
+        return Whitespace.c;
+    }
+
+    public abstract boolean a(char c);
+
+    public static CharMatcher a(char c, char c2) {
+        return new InRange(c, c2);
+    }
+
+    public static CharMatcher b() {
+        return Ascii.b;
+    }
+
+    public static CharMatcher c(char c) {
+        return new Is(c);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static String d(char c) {
+        char[] cArr = {'\\', 'u', 0, 0, 0, 0};
+        for (int i = 0; i < 4; i++) {
+            cArr[5 - i] = "0123456789ABCDEF".charAt(c & 15);
+            c = (char) (c >> 4);
+        }
+        return String.copyValueOf(cArr);
+    }
+
+    public int a(CharSequence charSequence, int i) {
+        int length = charSequence.length();
+        Preconditions.b(i, length);
+        while (i < length) {
+            if (a(charSequence.charAt(i))) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    @Deprecated
+    public boolean a(Character ch) {
+        return a(ch.charValue());
+    }
+}

sources/com/google/common/base/Converter.java

@@ -0,0 +1,38 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+public abstract class Converter<A, B> implements Function<A, B> {
+    private final boolean a;
+
+    protected Converter() {
+        this(true);
+    }
+
+    public final B a(A a) {
+        return b(a);
+    }
+
+    @Override // com.google.common.base.Function
+    @Deprecated
+    public final B apply(A a) {
+        return a(a);
+    }
+
+    B b(A a) {
+        if (!this.a) {
+            return c(a);
+        }
+        if (a == null) {
+            return null;
+        }
+        B c = c(a);
+        Preconditions.a(c);
+        return c;
+    }
+
+    protected abstract B c(A a);
+
+    Converter(boolean z) {
+        this.a = z;
+    }
+}

sources/com/google/common/base/Equivalence.java

@@ -0,0 +1,119 @@
+package com.google.common.base;
+
+import java.io.Serializable;
+
+/* loaded from: classes.dex */
+public abstract class Equivalence<T> {
+
+    static final class Equals extends Equivalence<Object> implements Serializable {
+        static final Equals a = new Equals();
+
+        Equals() {
+        }
+
+        private Object readResolve() {
+            return a;
+        }
+
+        @Override // com.google.common.base.Equivalence
+        protected boolean a(Object obj, Object obj2) {
+            return obj.equals(obj2);
+        }
+
+        @Override // com.google.common.base.Equivalence
+        protected int a(Object obj) {
+            return obj.hashCode();
+        }
+    }
+
+    static final class Identity extends Equivalence<Object> implements Serializable {
+        static final Identity a = new Identity();
+
+        Identity() {
+        }
+
+        private Object readResolve() {
+            return a;
+        }
+
+        @Override // com.google.common.base.Equivalence
+        protected int a(Object obj) {
+            return System.identityHashCode(obj);
+        }
+
+        @Override // com.google.common.base.Equivalence
+        protected boolean a(Object obj, Object obj2) {
+            return false;
+        }
+    }
+
+    public static final class Wrapper<T> implements Serializable {
+        private static final long serialVersionUID = 0;
+        private final Equivalence<? super T> equivalence;
+        private final T reference;
+
+        public boolean equals(Object obj) {
+            if (obj == this) {
+                return true;
+            }
+            if (!(obj instanceof Wrapper)) {
+                return false;
+            }
+            Wrapper wrapper = (Wrapper) obj;
+            if (this.equivalence.equals(wrapper.equivalence)) {
+                return this.equivalence.b(this.reference, wrapper.reference);
+            }
+            return false;
+        }
+
+        public T get() {
+            return this.reference;
+        }
+
+        public int hashCode() {
+            return this.equivalence.b(this.reference);
+        }
+
+        public String toString() {
+            return this.equivalence + ".wrap(" + this.reference + ")";
+        }
+
+        private Wrapper(Equivalence<? super T> equivalence, T t) {
+            Preconditions.a(equivalence);
+            this.equivalence = equivalence;
+            this.reference = t;
+        }
+    }
+
+    protected Equivalence() {
+    }
+
+    public static Equivalence<Object> a() {
+        return Equals.a;
+    }
+
+    protected abstract int a(T t);
+
+    protected abstract boolean a(T t, T t2);
+
+    public final boolean b(T t, T t2) {
+        if (t == t2) {
+            return true;
+        }
+        if (t == null || t2 == null) {
+            return false;
+        }
+        return a(t, t2);
+    }
+
+    public final int b(T t) {
+        if (t == null) {
+            return 0;
+        }
+        return a(t);
+    }
+
+    public static Equivalence<Object> b() {
+        return Identity.a;
+    }
+}

sources/com/google/common/base/ExtraObjectsMethodsForWeb.java

@@ -0,0 +1,5 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+abstract class ExtraObjectsMethodsForWeb {
+}

sources/com/google/common/base/Function.java

@@ -0,0 +1,8 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+public interface Function<F, T> {
+    T apply(F f);
+
+    boolean equals(Object obj);
+}

sources/com/google/common/base/Joiner.java

@@ -0,0 +1,82 @@
+package com.google.common.base;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class Joiner {
+    private final String a;
+
+    public static Joiner a(char c) {
+        return new Joiner(String.valueOf(c));
+    }
+
+    public static Joiner b(String str) {
+        return new Joiner(str);
+    }
+
+    private Joiner(String str) {
+        Preconditions.a(str);
+        this.a = str;
+    }
+
+    public <A extends Appendable> A a(A a, Iterator<?> it) throws IOException {
+        Preconditions.a(a);
+        if (it.hasNext()) {
+            a.append(a(it.next()));
+            while (it.hasNext()) {
+                a.append(this.a);
+                a.append(a(it.next()));
+            }
+        }
+        return a;
+    }
+
+    private Joiner(Joiner joiner) {
+        this.a = joiner.a;
+    }
+
+    public final StringBuilder a(StringBuilder sb, Iterator<?> it) {
+        try {
+            a((Joiner) sb, it);
+            return sb;
+        } catch (IOException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    public final String a(Iterable<?> iterable) {
+        return a(iterable.iterator());
+    }
+
+    public final String a(Iterator<?> it) {
+        StringBuilder sb = new StringBuilder();
+        a(sb, it);
+        return sb.toString();
+    }
+
+    public final String a(Object[] objArr) {
+        return a((Iterable<?>) Arrays.asList(objArr));
+    }
+
+    public Joiner a(final String str) {
+        Preconditions.a(str);
+        return new Joiner(this) { // from class: com.google.common.base.Joiner.1
+            @Override // com.google.common.base.Joiner
+            CharSequence a(Object obj) {
+                return obj == null ? str : Joiner.this.a(obj);
+            }
+
+            @Override // com.google.common.base.Joiner
+            public Joiner a(String str2) {
+                throw new UnsupportedOperationException("already specified useForNull");
+            }
+        };
+    }
+
+    CharSequence a(Object obj) {
+        Preconditions.a(obj);
+        return obj instanceof CharSequence ? (CharSequence) obj : obj.toString();
+    }
+}

sources/com/google/common/base/MoreObjects.java

@@ -0,0 +1,116 @@
+package com.google.common.base;
+
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+public final class MoreObjects {
+
+    public static final class ToStringHelper {
+        private final String a;
+        private final ValueHolder b;
+        private ValueHolder c;
+        private boolean d;
+
+        private static final class ValueHolder {
+            String a;
+            Object b;
+            ValueHolder c;
+
+            private ValueHolder() {
+            }
+        }
+
+        private ToStringHelper b(Object obj) {
+            a().b = obj;
+            return this;
+        }
+
+        public ToStringHelper a(String str, Object obj) {
+            b(str, obj);
+            return this;
+        }
+
+        public String toString() {
+            boolean z = this.d;
+            StringBuilder sb = new StringBuilder(32);
+            sb.append(this.a);
+            sb.append('{');
+            String str = "";
+            for (ValueHolder valueHolder = this.b.c; valueHolder != null; valueHolder = valueHolder.c) {
+                Object obj = valueHolder.b;
+                if (!z || obj != null) {
+                    sb.append(str);
+                    String str2 = valueHolder.a;
+                    if (str2 != null) {
+                        sb.append(str2);
+                        sb.append('=');
+                    }
+                    if (obj == null || !obj.getClass().isArray()) {
+                        sb.append(obj);
+                    } else {
+                        String deepToString = Arrays.deepToString(new Object[]{obj});
+                        sb.append((CharSequence) deepToString, 1, deepToString.length() - 1);
+                    }
+                    str = ", ";
+                }
+            }
+            sb.append('}');
+            return sb.toString();
+        }
+
+        private ToStringHelper(String str) {
+            this.b = new ValueHolder();
+            this.c = this.b;
+            this.d = false;
+            Preconditions.a(str);
+            this.a = str;
+        }
+
+        public ToStringHelper a(String str, double d) {
+            b(str, String.valueOf(d));
+            return this;
+        }
+
+        private ToStringHelper b(String str, Object obj) {
+            ValueHolder a = a();
+            a.b = obj;
+            Preconditions.a(str);
+            a.a = str;
+            return this;
+        }
+
+        public ToStringHelper a(String str, int i) {
+            b(str, String.valueOf(i));
+            return this;
+        }
+
+        public ToStringHelper a(String str, long j) {
+            b(str, String.valueOf(j));
+            return this;
+        }
+
+        public ToStringHelper a(Object obj) {
+            b(obj);
+            return this;
+        }
+
+        private ValueHolder a() {
+            ValueHolder valueHolder = new ValueHolder();
+            this.c.c = valueHolder;
+            this.c = valueHolder;
+            return valueHolder;
+        }
+    }
+
+    public static <T> T a(T t, T t2) {
+        if (t != null) {
+            return t;
+        }
+        Preconditions.a(t2);
+        return t2;
+    }
+
+    public static ToStringHelper a(Object obj) {
+        return new ToStringHelper(obj.getClass().getSimpleName());
+    }
+}

sources/com/google/common/base/Objects.java

@@ -0,0 +1,14 @@
+package com.google.common.base;
+
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+public final class Objects extends ExtraObjectsMethodsForWeb {
+    public static boolean a(Object obj, Object obj2) {
+        return obj == obj2 || (obj != null && obj.equals(obj2));
+    }
+
+    public static int a(Object... objArr) {
+        return Arrays.hashCode(objArr);
+    }
+}

sources/com/google/common/base/Optional.java

@@ -0,0 +1,77 @@
+package com.google.common.base;
+
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+public abstract class Optional<T> implements Serializable {
+    private static final long serialVersionUID = 0;
+
+    Optional() {
+    }
+
+    public static <T> Optional<T> absent() {
+        return Absent.a();
+    }
+
+    public static <T> Optional<T> fromNullable(T t) {
+        return t == null ? absent() : new Present(t);
+    }
+
+    public static <T> Optional<T> of(T t) {
+        Preconditions.a(t);
+        return new Present(t);
+    }
+
+    public static <T> Iterable<T> presentInstances(final Iterable<? extends Optional<? extends T>> iterable) {
+        Preconditions.a(iterable);
+        return new Iterable<T>() { // from class: com.google.common.base.Optional.1
+            @Override // java.lang.Iterable
+            public Iterator<T> iterator() {
+                return new AbstractIterator<T>() { // from class: com.google.common.base.Optional.1.1
+                    private final Iterator<? extends Optional<? extends T>> c;
+
+                    {
+                        Iterator<? extends Optional<? extends T>> it = iterable.iterator();
+                        Preconditions.a(it);
+                        this.c = it;
+                    }
+
+                    @Override // com.google.common.base.AbstractIterator
+                    protected T a() {
+                        while (this.c.hasNext()) {
+                            Optional<? extends T> next = this.c.next();
+                            if (next.isPresent()) {
+                                return next.get();
+                            }
+                        }
+                        return b();
+                    }
+                };
+            }
+        };
+    }
+
+    public abstract Set<T> asSet();
+
+    public abstract boolean equals(Object obj);
+
+    public abstract T get();
+
+    public abstract int hashCode();
+
+    public abstract boolean isPresent();
+
+    public abstract Optional<T> or(Optional<? extends T> optional);
+
+    public abstract T or(Supplier<? extends T> supplier);
+
+    public abstract T or(T t);
+
+    public abstract T orNull();
+
+    public abstract String toString();
+
+    public abstract <V> Optional<V> transform(Function<? super T, V> function);
+}

sources/com/google/common/base/PatternCompiler.java

@@ -0,0 +1,5 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+interface PatternCompiler {
+}

sources/com/google/common/base/Platform.java

@@ -0,0 +1,28 @@
+package com.google.common.base;
+
+import java.util.logging.Logger;
+
+/* loaded from: classes.dex */
+final class Platform {
+
+    private static final class JdkPatternCompiler implements PatternCompiler {
+        private JdkPatternCompiler() {
+        }
+    }
+
+    static {
+        Logger.getLogger(Platform.class.getName());
+        a();
+    }
+
+    private Platform() {
+    }
+
+    static boolean a(String str) {
+        return str == null || str.isEmpty();
+    }
+
+    private static PatternCompiler a() {
+        return new JdkPatternCompiler();
+    }
+}

sources/com/google/common/base/Preconditions.java

@@ -0,0 +1,179 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+public final class Preconditions {
+    public static void a(boolean z) {
+        if (!z) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static void b(boolean z) {
+        if (!z) {
+            throw new IllegalStateException();
+        }
+    }
+
+    public static int c(int i, int i2, String str) {
+        if (i < 0 || i >= i2) {
+            throw new IndexOutOfBoundsException(a(i, i2, str));
+        }
+        return i;
+    }
+
+    public static int d(int i, int i2, String str) {
+        if (i < 0 || i > i2) {
+            throw new IndexOutOfBoundsException(b(i, i2, str));
+        }
+        return i;
+    }
+
+    public static void a(boolean z, Object obj) {
+        if (!z) {
+            throw new IllegalArgumentException(String.valueOf(obj));
+        }
+    }
+
+    public static void b(boolean z, Object obj) {
+        if (!z) {
+            throw new IllegalStateException(String.valueOf(obj));
+        }
+    }
+
+    public static void a(boolean z, String str, int i) {
+        if (!z) {
+            throw new IllegalArgumentException(a(str, Integer.valueOf(i)));
+        }
+    }
+
+    public static void b(boolean z, String str, int i) {
+        if (!z) {
+            throw new IllegalStateException(a(str, Integer.valueOf(i)));
+        }
+    }
+
+    public static void a(boolean z, String str, long j) {
+        if (!z) {
+            throw new IllegalArgumentException(a(str, Long.valueOf(j)));
+        }
+    }
+
+    public static void b(boolean z, String str, Object obj) {
+        if (!z) {
+            throw new IllegalStateException(a(str, obj));
+        }
+    }
+
+    public static void a(boolean z, String str, Object obj) {
+        if (!z) {
+            throw new IllegalArgumentException(a(str, obj));
+        }
+    }
+
+    public static int b(int i, int i2) {
+        d(i, i2, "index");
+        return i;
+    }
+
+    public static void a(boolean z, String str, int i, int i2) {
+        if (!z) {
+            throw new IllegalArgumentException(a(str, Integer.valueOf(i), Integer.valueOf(i2)));
+        }
+    }
+
+    private static String b(int i, int i2, String str) {
+        if (i < 0) {
+            return a("%s (%s) must not be negative", str, Integer.valueOf(i));
+        }
+        if (i2 >= 0) {
+            return a("%s (%s) must not be greater than size (%s)", str, Integer.valueOf(i), Integer.valueOf(i2));
+        }
+        throw new IllegalArgumentException("negative size: " + i2);
+    }
+
+    public static void a(boolean z, String str, long j, long j2) {
+        if (!z) {
+            throw new IllegalArgumentException(a(str, Long.valueOf(j), Long.valueOf(j2)));
+        }
+    }
+
+    public static void a(boolean z, String str, Object obj, Object obj2) {
+        if (!z) {
+            throw new IllegalArgumentException(a(str, obj, obj2));
+        }
+    }
+
+    public static <T> T a(T t) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException();
+    }
+
+    public static void b(int i, int i2, int i3) {
+        if (i < 0 || i2 < i || i2 > i3) {
+            throw new IndexOutOfBoundsException(a(i, i2, i3));
+        }
+    }
+
+    public static <T> T a(T t, Object obj) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(String.valueOf(obj));
+    }
+
+    public static <T> T a(T t, String str, Object obj, Object obj2) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(a(str, obj, obj2));
+    }
+
+    public static int a(int i, int i2) {
+        c(i, i2, "index");
+        return i;
+    }
+
+    private static String a(int i, int i2, String str) {
+        if (i < 0) {
+            return a("%s (%s) must not be negative", str, Integer.valueOf(i));
+        }
+        if (i2 >= 0) {
+            return a("%s (%s) must be less than size (%s)", str, Integer.valueOf(i), Integer.valueOf(i2));
+        }
+        throw new IllegalArgumentException("negative size: " + i2);
+    }
+
+    private static String a(int i, int i2, int i3) {
+        if (i < 0 || i > i3) {
+            return b(i, i3, "start index");
+        }
+        return (i2 < 0 || i2 > i3) ? b(i2, i3, "end index") : a("end index (%s) must not be less than start index (%s)", Integer.valueOf(i2), Integer.valueOf(i));
+    }
+
+    static String a(String str, Object... objArr) {
+        int indexOf;
+        String valueOf = String.valueOf(str);
+        StringBuilder sb = new StringBuilder(valueOf.length() + (objArr.length * 16));
+        int i = 0;
+        int i2 = 0;
+        while (i < objArr.length && (indexOf = valueOf.indexOf("%s", i2)) != -1) {
+            sb.append((CharSequence) valueOf, i2, indexOf);
+            sb.append(objArr[i]);
+            i2 = indexOf + 2;
+            i++;
+        }
+        sb.append((CharSequence) valueOf, i2, valueOf.length());
+        if (i < objArr.length) {
+            sb.append(" [");
+            sb.append(objArr[i]);
+            for (int i3 = i + 1; i3 < objArr.length; i3++) {
+                sb.append(", ");
+                sb.append(objArr[i3]);
+            }
+            sb.append(']');
+        }
+        return sb.toString();
+    }
+}

sources/com/google/common/base/Predicate.java

@@ -0,0 +1,8 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+public interface Predicate<T> {
+    boolean apply(T t);
+
+    boolean equals(Object obj);
+}

sources/com/google/common/base/Predicates.java

@@ -0,0 +1,218 @@
+package com.google.common.base;
+
+import java.io.Serializable;
+import java.util.Collection;
+
+/* loaded from: classes.dex */
+public final class Predicates {
+
+    private static class CompositionPredicate<A, B> implements Predicate<A>, Serializable {
+        final Predicate<B> a;
+        final Function<A, ? extends B> b;
+
+        @Override // com.google.common.base.Predicate
+        public boolean apply(A a) {
+            return this.a.apply(this.b.apply(a));
+        }
+
+        @Override // com.google.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (!(obj instanceof CompositionPredicate)) {
+                return false;
+            }
+            CompositionPredicate compositionPredicate = (CompositionPredicate) obj;
+            return this.b.equals(compositionPredicate.b) && this.a.equals(compositionPredicate.a);
+        }
+
+        public int hashCode() {
+            return this.b.hashCode() ^ this.a.hashCode();
+        }
+
+        public String toString() {
+            return this.a + "(" + this.b + ")";
+        }
+
+        private CompositionPredicate(Predicate<B> predicate, Function<A, ? extends B> function) {
+            Preconditions.a(predicate);
+            this.a = predicate;
+            Preconditions.a(function);
+            this.b = function;
+        }
+    }
+
+    private static class InPredicate<T> implements Predicate<T>, Serializable {
+        private final Collection<?> a;
+
+        @Override // com.google.common.base.Predicate
+        public boolean apply(T t) {
+            try {
+                return this.a.contains(t);
+            } catch (ClassCastException | NullPointerException unused) {
+                return false;
+            }
+        }
+
+        @Override // com.google.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (obj instanceof InPredicate) {
+                return this.a.equals(((InPredicate) obj).a);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return this.a.hashCode();
+        }
+
+        public String toString() {
+            return "Predicates.in(" + this.a + ")";
+        }
+
+        private InPredicate(Collection<?> collection) {
+            Preconditions.a(collection);
+            this.a = collection;
+        }
+    }
+
+    private static class IsEqualToPredicate<T> implements Predicate<T>, Serializable {
+        private final T a;
+
+        @Override // com.google.common.base.Predicate
+        public boolean apply(T t) {
+            return this.a.equals(t);
+        }
+
+        @Override // com.google.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (obj instanceof IsEqualToPredicate) {
+                return this.a.equals(((IsEqualToPredicate) obj).a);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return this.a.hashCode();
+        }
+
+        public String toString() {
+            return "Predicates.equalTo(" + this.a + ")";
+        }
+
+        private IsEqualToPredicate(T t) {
+            this.a = t;
+        }
+    }
+
+    private static class NotPredicate<T> implements Predicate<T>, Serializable {
+        final Predicate<T> a;
+
+        NotPredicate(Predicate<T> predicate) {
+            Preconditions.a(predicate);
+            this.a = predicate;
+        }
+
+        @Override // com.google.common.base.Predicate
+        public boolean apply(T t) {
+            return !this.a.apply(t);
+        }
+
+        @Override // com.google.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (obj instanceof NotPredicate) {
+                return this.a.equals(((NotPredicate) obj).a);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return ~this.a.hashCode();
+        }
+
+        public String toString() {
+            return "Predicates.not(" + this.a + ")";
+        }
+    }
+
+    enum ObjectPredicate implements Predicate<Object> {
+        ALWAYS_TRUE { // from class: com.google.common.base.Predicates.ObjectPredicate.1
+            @Override // com.google.common.base.Predicate
+            public boolean apply(Object obj) {
+                return true;
+            }
+
+            @Override // java.lang.Enum
+            public String toString() {
+                return "Predicates.alwaysTrue()";
+            }
+        },
+        ALWAYS_FALSE { // from class: com.google.common.base.Predicates.ObjectPredicate.2
+            @Override // com.google.common.base.Predicate
+            public boolean apply(Object obj) {
+                return false;
+            }
+
+            @Override // java.lang.Enum
+            public String toString() {
+                return "Predicates.alwaysFalse()";
+            }
+        },
+        IS_NULL { // from class: com.google.common.base.Predicates.ObjectPredicate.3
+            @Override // com.google.common.base.Predicate
+            public boolean apply(Object obj) {
+                return obj == null;
+            }
+
+            @Override // java.lang.Enum
+            public String toString() {
+                return "Predicates.isNull()";
+            }
+        },
+        NOT_NULL { // from class: com.google.common.base.Predicates.ObjectPredicate.4
+            @Override // com.google.common.base.Predicate
+            public boolean apply(Object obj) {
+                return obj != null;
+            }
+
+            @Override // java.lang.Enum
+            public String toString() {
+                return "Predicates.notNull()";
+            }
+        };
+
+        <T> Predicate<T> c() {
+            return this;
+        }
+    }
+
+    static {
+        Joiner.a(',');
+    }
+
+    public static <T> Predicate<T> a() {
+        ObjectPredicate objectPredicate = ObjectPredicate.ALWAYS_TRUE;
+        objectPredicate.c();
+        return objectPredicate;
+    }
+
+    public static <T> Predicate<T> b() {
+        ObjectPredicate objectPredicate = ObjectPredicate.IS_NULL;
+        objectPredicate.c();
+        return objectPredicate;
+    }
+
+    public static <T> Predicate<T> a(Predicate<T> predicate) {
+        return new NotPredicate(predicate);
+    }
+
+    public static <T> Predicate<T> a(T t) {
+        return t == null ? b() : new IsEqualToPredicate(t);
+    }
+
+    public static <T> Predicate<T> a(Collection<? extends T> collection) {
+        return new InPredicate(collection);
+    }
+
+    public static <A, B> Predicate<A> a(Predicate<B> predicate, Function<A, ? extends B> function) {
+        return new CompositionPredicate(predicate, function);
+    }
+}

sources/com/google/common/base/Present.java

@@ -0,0 +1,76 @@
+package com.google.common.base;
+
+import java.util.Collections;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+final class Present<T> extends Optional<T> {
+    private final T a;
+
+    Present(T t) {
+        this.a = t;
+    }
+
+    @Override // com.google.common.base.Optional
+    public Set<T> asSet() {
+        return Collections.singleton(this.a);
+    }
+
+    @Override // com.google.common.base.Optional
+    public boolean equals(Object obj) {
+        if (obj instanceof Present) {
+            return this.a.equals(((Present) obj).a);
+        }
+        return false;
+    }
+
+    @Override // com.google.common.base.Optional
+    public T get() {
+        return this.a;
+    }
+
+    @Override // com.google.common.base.Optional
+    public int hashCode() {
+        return this.a.hashCode() + 1502476572;
+    }
+
+    @Override // com.google.common.base.Optional
+    public boolean isPresent() {
+        return true;
+    }
+
+    @Override // com.google.common.base.Optional
+    public T or(T t) {
+        Preconditions.a(t, "use Optional.orNull() instead of Optional.or(null)");
+        return this.a;
+    }
+
+    @Override // com.google.common.base.Optional
+    public T orNull() {
+        return this.a;
+    }
+
+    @Override // com.google.common.base.Optional
+    public String toString() {
+        return "Optional.of(" + this.a + ")";
+    }
+
+    @Override // com.google.common.base.Optional
+    public <V> Optional<V> transform(Function<? super T, V> function) {
+        V apply = function.apply(this.a);
+        Preconditions.a(apply, "the Function passed to Optional.transform() must not return null.");
+        return new Present(apply);
+    }
+
+    @Override // com.google.common.base.Optional
+    public Optional<T> or(Optional<? extends T> optional) {
+        Preconditions.a(optional);
+        return this;
+    }
+
+    @Override // com.google.common.base.Optional
+    public T or(Supplier<? extends T> supplier) {
+        Preconditions.a(supplier);
+        return this.a;
+    }
+}

sources/com/google/common/base/StandardSystemProperty.java

@@ -0,0 +1,52 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+public enum StandardSystemProperty {
+    JAVA_VERSION("java.version"),
+    JAVA_VENDOR("java.vendor"),
+    JAVA_VENDOR_URL("java.vendor.url"),
+    JAVA_HOME("java.home"),
+    JAVA_VM_SPECIFICATION_VERSION("java.vm.specification.version"),
+    JAVA_VM_SPECIFICATION_VENDOR("java.vm.specification.vendor"),
+    JAVA_VM_SPECIFICATION_NAME("java.vm.specification.name"),
+    JAVA_VM_VERSION("java.vm.version"),
+    JAVA_VM_VENDOR("java.vm.vendor"),
+    JAVA_VM_NAME("java.vm.name"),
+    JAVA_SPECIFICATION_VERSION("java.specification.version"),
+    JAVA_SPECIFICATION_VENDOR("java.specification.vendor"),
+    JAVA_SPECIFICATION_NAME("java.specification.name"),
+    JAVA_CLASS_VERSION("java.class.version"),
+    JAVA_CLASS_PATH("java.class.path"),
+    JAVA_LIBRARY_PATH("java.library.path"),
+    JAVA_IO_TMPDIR("java.io.tmpdir"),
+    JAVA_COMPILER("java.compiler"),
+    JAVA_EXT_DIRS("java.ext.dirs"),
+    OS_NAME("os.name"),
+    OS_ARCH("os.arch"),
+    OS_VERSION("os.version"),
+    FILE_SEPARATOR("file.separator"),
+    PATH_SEPARATOR("path.separator"),
+    LINE_SEPARATOR("line.separator"),
+    USER_NAME("user.name"),
+    USER_HOME("user.home"),
+    USER_DIR("user.dir");
+
+    private final String key;
+
+    StandardSystemProperty(String str) {
+        this.key = str;
+    }
+
+    public String key() {
+        return this.key;
+    }
+
+    @Override // java.lang.Enum
+    public String toString() {
+        return key() + "=" + value();
+    }
+
+    public String value() {
+        return System.getProperty(this.key);
+    }
+}

sources/com/google/common/base/Strings.java

@@ -0,0 +1,8 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+public final class Strings {
+    public static boolean a(String str) {
+        return Platform.a(str);
+    }
+}

sources/com/google/common/base/Supplier.java

@@ -0,0 +1,6 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+public interface Supplier<T> {
+    T get();
+}

sources/com/google/common/base/VerifyException.java

@@ -0,0 +1,19 @@
+package com.google.common.base;
+
+/* loaded from: classes.dex */
+public class VerifyException extends RuntimeException {
+    public VerifyException() {
+    }
+
+    public VerifyException(String str) {
+        super(str);
+    }
+
+    public VerifyException(Throwable th) {
+        super(th);
+    }
+
+    public VerifyException(String str, Throwable th) {
+        super(str, th);
+    }
+}