Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/applovin/exoplayer2/common/base/Ascii.java

@@ -0,0 +1,172 @@
+package com.applovin.exoplayer2.common.base;
+
+/* loaded from: classes.dex */
+public final class Ascii {
+    public static final byte ACK = 6;
+    public static final byte BEL = 7;
+    public static final byte BS = 8;
+    public static final byte CAN = 24;
+    private static final char CASE_MASK = ' ';
+    public static final byte CR = 13;
+    public static final byte DC1 = 17;
+    public static final byte DC2 = 18;
+    public static final byte DC3 = 19;
+    public static final byte DC4 = 20;
+    public static final byte DEL = Byte.MAX_VALUE;
+    public static final byte DLE = 16;
+    public static final byte EM = 25;
+    public static final byte ENQ = 5;
+    public static final byte EOT = 4;
+    public static final byte ESC = 27;
+    public static final byte ETB = 23;
+    public static final byte ETX = 3;
+    public static final byte FF = 12;
+    public static final byte FS = 28;
+    public static final byte GS = 29;
+    public static final byte HT = 9;
+    public static final byte LF = 10;
+    public static final char MAX = 127;
+    public static final char MIN = 0;
+    public static final byte NAK = 21;
+    public static final byte NL = 10;
+    public static final byte NUL = 0;
+    public static final byte RS = 30;
+    public static final byte SI = 15;
+    public static final byte SO = 14;
+    public static final byte SOH = 1;
+    public static final byte SP = 32;
+    public static final byte SPACE = 32;
+    public static final byte STX = 2;
+    public static final byte SUB = 26;
+    public static final byte SYN = 22;
+    public static final byte US = 31;
+    public static final byte VT = 11;
+    public static final byte XOFF = 19;
+    public static final byte XON = 17;
+
+    private Ascii() {
+    }
+
+    public static boolean equalsIgnoreCase(CharSequence charSequence, CharSequence charSequence2) {
+        int alphaIndex;
+        int length = charSequence.length();
+        if (charSequence == charSequence2) {
+            return true;
+        }
+        if (length != charSequence2.length()) {
+            return false;
+        }
+        for (int i = 0; i < length; i++) {
+            char charAt = charSequence.charAt(i);
+            char charAt2 = charSequence2.charAt(i);
+            if (charAt != charAt2 && ((alphaIndex = getAlphaIndex(charAt)) >= 26 || alphaIndex != getAlphaIndex(charAt2))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static int getAlphaIndex(char c) {
+        return (char) ((c | CASE_MASK) - 97);
+    }
+
+    public static boolean isLowerCase(char c) {
+        return c >= 'a' && c <= 'z';
+    }
+
+    public static boolean isUpperCase(char c) {
+        return c >= 'A' && c <= 'Z';
+    }
+
+    public static String toLowerCase(String str) {
+        int length = str.length();
+        int i = 0;
+        while (i < length) {
+            if (isUpperCase(str.charAt(i))) {
+                char[] charArray = str.toCharArray();
+                while (i < length) {
+                    char c = charArray[i];
+                    if (isUpperCase(c)) {
+                        charArray[i] = (char) (c ^ CASE_MASK);
+                    }
+                    i++;
+                }
+                return String.valueOf(charArray);
+            }
+            i++;
+        }
+        return str;
+    }
+
+    public static String toUpperCase(String str) {
+        int length = str.length();
+        int i = 0;
+        while (i < length) {
+            if (isLowerCase(str.charAt(i))) {
+                char[] charArray = str.toCharArray();
+                while (i < length) {
+                    char c = charArray[i];
+                    if (isLowerCase(c)) {
+                        charArray[i] = (char) (c ^ CASE_MASK);
+                    }
+                    i++;
+                }
+                return String.valueOf(charArray);
+            }
+            i++;
+        }
+        return str;
+    }
+
+    public static String truncate(CharSequence charSequence, int i, String str) {
+        Preconditions.checkNotNull(charSequence);
+        int length = i - str.length();
+        Preconditions.checkArgument(length >= 0, "maxLength (%s) must be >= length of the truncation indicator (%s)", i, str.length());
+        int length2 = charSequence.length();
+        String str2 = charSequence;
+        if (length2 <= i) {
+            String charSequence2 = charSequence.toString();
+            int length3 = charSequence2.length();
+            str2 = charSequence2;
+            if (length3 <= i) {
+                return charSequence2;
+            }
+        }
+        StringBuilder sb = new StringBuilder(i);
+        sb.append((CharSequence) str2, 0, length);
+        sb.append(str);
+        return sb.toString();
+    }
+
+    public static String toLowerCase(CharSequence charSequence) {
+        if (charSequence instanceof String) {
+            return toLowerCase((String) charSequence);
+        }
+        int length = charSequence.length();
+        char[] cArr = new char[length];
+        for (int i = 0; i < length; i++) {
+            cArr[i] = toLowerCase(charSequence.charAt(i));
+        }
+        return String.valueOf(cArr);
+    }
+
+    public static String toUpperCase(CharSequence charSequence) {
+        if (charSequence instanceof String) {
+            return toUpperCase((String) charSequence);
+        }
+        int length = charSequence.length();
+        char[] cArr = new char[length];
+        for (int i = 0; i < length; i++) {
+            cArr[i] = toUpperCase(charSequence.charAt(i));
+        }
+        return String.valueOf(cArr);
+    }
+
+    public static char toLowerCase(char c) {
+        return isUpperCase(c) ? (char) (c ^ CASE_MASK) : c;
+    }
+
+    public static char toUpperCase(char c) {
+        return isLowerCase(c) ? (char) (c ^ CASE_MASK) : c;
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Charsets.java

@@ -0,0 +1,16 @@
+package com.applovin.exoplayer2.common.base;
+
+import java.nio.charset.Charset;
+
+/* loaded from: classes.dex */
+public final class Charsets {
+    public static final Charset US_ASCII = Charset.forName("US-ASCII");
+    public static final Charset ISO_8859_1 = Charset.forName("ISO-8859-1");
+    public static final Charset UTF_8 = Charset.forName("UTF-8");
+    public static final Charset UTF_16BE = Charset.forName("UTF-16BE");
+    public static final Charset UTF_16LE = Charset.forName("UTF-16LE");
+    public static final Charset UTF_16 = Charset.forName("UTF-16");
+
+    private Charsets() {
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Converter.java

@@ -0,0 +1,304 @@
+package com.applovin.exoplayer2.common.base;
+
+import java.io.Serializable;
+import java.util.Iterator;
+import org.checkerframework.checker.nullness.compatqual.MonotonicNonNullDecl;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+/* loaded from: classes.dex */
+public abstract class Converter<A, B> implements Function<A, B> {
+    private final boolean handleNullAutomatically;
+
+    @MonotonicNonNullDecl
+    private transient Converter<B, A> reverse;
+
+    public class a implements Iterable {
+        final /* synthetic */ Iterable a;
+
+        /* renamed from: com.applovin.exoplayer2.common.base.Converter$a$a, reason: collision with other inner class name */
+        public class C0007a implements Iterator {
+            private final Iterator a;
+
+            public C0007a() {
+                this.a = a.this.a.iterator();
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                return this.a.hasNext();
+            }
+
+            /* JADX WARN: Multi-variable type inference failed */
+            @Override // java.util.Iterator
+            public Object next() {
+                return Converter.this.convert(this.a.next());
+            }
+
+            @Override // java.util.Iterator
+            public void remove() {
+                this.a.remove();
+            }
+        }
+
+        public a(Iterable iterable) {
+            this.a = iterable;
+        }
+
+        @Override // java.lang.Iterable
+        public Iterator iterator() {
+            return new C0007a();
+        }
+    }
+
+    public static final class b extends Converter implements Serializable {
+        final Converter a;
+        final Converter b;
+
+        public b(Converter converter, Converter converter2) {
+            this.a = converter;
+            this.b = converter2;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object correctedDoBackward(Object obj) {
+            return this.a.correctedDoBackward(this.b.correctedDoBackward(obj));
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object correctedDoForward(Object obj) {
+            return this.b.correctedDoForward(this.a.correctedDoForward(obj));
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object doBackward(Object obj) {
+            throw new AssertionError();
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object doForward(Object obj) {
+            throw new AssertionError();
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter, com.applovin.exoplayer2.common.base.Function
+        public boolean equals(Object obj) {
+            if (!(obj instanceof b)) {
+                return false;
+            }
+            b bVar = (b) obj;
+            return this.a.equals(bVar.a) && this.b.equals(bVar.b);
+        }
+
+        public int hashCode() {
+            return (this.a.hashCode() * 31) + this.b.hashCode();
+        }
+
+        public String toString() {
+            return this.a + ".andThen(" + this.b + ")";
+        }
+    }
+
+    public static final class c extends Converter implements Serializable {
+        private final Function a;
+        private final Function b;
+
+        public /* synthetic */ c(Function function, Function function2, a aVar) {
+            this(function, function2);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object doBackward(Object obj) {
+            return this.b.apply(obj);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object doForward(Object obj) {
+            return this.a.apply(obj);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter, com.applovin.exoplayer2.common.base.Function
+        public boolean equals(Object obj) {
+            if (!(obj instanceof c)) {
+                return false;
+            }
+            c cVar = (c) obj;
+            return this.a.equals(cVar.a) && this.b.equals(cVar.b);
+        }
+
+        public int hashCode() {
+            return (this.a.hashCode() * 31) + this.b.hashCode();
+        }
+
+        public String toString() {
+            return "Converter.from(" + this.a + ", " + this.b + ")";
+        }
+
+        private c(Function function, Function function2) {
+            this.a = (Function) Preconditions.checkNotNull(function);
+            this.b = (Function) Preconditions.checkNotNull(function2);
+        }
+    }
+
+    public static final class d extends Converter implements Serializable {
+        static final d a = new d();
+
+        private d() {
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Converter doAndThen(Converter converter) {
+            return (Converter) Preconditions.checkNotNull(converter, "otherConverter");
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object doBackward(Object obj) {
+            return obj;
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object doForward(Object obj) {
+            return obj;
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public d reverse() {
+            return this;
+        }
+
+        public String toString() {
+            return "Converter.identity()";
+        }
+    }
+
+    public static final class e extends Converter implements Serializable {
+        final Converter a;
+
+        public e(Converter converter) {
+            this.a = converter;
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object correctedDoBackward(Object obj) {
+            return this.a.correctedDoForward(obj);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object correctedDoForward(Object obj) {
+            return this.a.correctedDoBackward(obj);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object doBackward(Object obj) {
+            throw new AssertionError();
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Object doForward(Object obj) {
+            throw new AssertionError();
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter, com.applovin.exoplayer2.common.base.Function
+        public boolean equals(Object obj) {
+            if (obj instanceof e) {
+                return this.a.equals(((e) obj).a);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return ~this.a.hashCode();
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Converter
+        public Converter reverse() {
+            return this.a;
+        }
+
+        public String toString() {
+            return this.a + ".reverse()";
+        }
+    }
+
+    public Converter() {
+        this(true);
+    }
+
+    public static <A, B> Converter<A, B> from(Function<? super A, ? extends B> function, Function<? super B, ? extends A> function2) {
+        return new c(function, function2, null);
+    }
+
+    public static <T> Converter<T, T> identity() {
+        return d.a;
+    }
+
+    public final <C> Converter<A, C> andThen(Converter<B, C> converter) {
+        return doAndThen(converter);
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Function
+    @NullableDecl
+    @Deprecated
+    public final B apply(@NullableDecl A a2) {
+        return convert(a2);
+    }
+
+    @NullableDecl
+    public final B convert(@NullableDecl A a2) {
+        return correctedDoForward(a2);
+    }
+
+    public Iterable<B> convertAll(Iterable<? extends A> iterable) {
+        Preconditions.checkNotNull(iterable, "fromIterable");
+        return new a(iterable);
+    }
+
+    public <C> Converter<A, C> doAndThen(Converter<B, C> converter) {
+        return new b(this, (Converter) Preconditions.checkNotNull(converter));
+    }
+
+    public abstract A doBackward(B b2);
+
+    public abstract B doForward(A a2);
+
+    @Override // com.applovin.exoplayer2.common.base.Function
+    public boolean equals(@NullableDecl Object obj) {
+        return super.equals(obj);
+    }
+
+    public Converter(boolean z) {
+        this.handleNullAutomatically = z;
+    }
+
+    public Converter<B, A> reverse() {
+        Converter<B, A> converter = this.reverse;
+        if (converter != null) {
+            return converter;
+        }
+        e eVar = new e(this);
+        this.reverse = eVar;
+        return eVar;
+    }
+
+    @NullableDecl
+    public A correctedDoBackward(@NullableDecl B b2) {
+        if (!this.handleNullAutomatically) {
+            return doBackward(b2);
+        }
+        if (b2 == null) {
+            return null;
+        }
+        return (A) Preconditions.checkNotNull(doBackward(b2));
+    }
+
+    @NullableDecl
+    public B correctedDoForward(@NullableDecl A a2) {
+        if (!this.handleNullAutomatically) {
+            return doForward(a2);
+        }
+        if (a2 == null) {
+            return null;
+        }
+        return (B) Preconditions.checkNotNull(doForward(a2));
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Equivalence.java

@@ -0,0 +1,149 @@
+package com.applovin.exoplayer2.common.base;
+
+import java.io.Serializable;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+/* loaded from: classes.dex */
+public abstract class Equivalence<T> {
+
+    public static final class Wrapper<T> implements Serializable {
+        private static final long serialVersionUID = 0;
+        private final Equivalence<? super T> equivalence;
+
+        @NullableDecl
+        private final T reference;
+
+        public boolean equals(@NullableDecl 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.equivalent(this.reference, wrapper.reference);
+            }
+            return false;
+        }
+
+        @NullableDecl
+        public T get() {
+            return this.reference;
+        }
+
+        public int hashCode() {
+            return this.equivalence.hash(this.reference);
+        }
+
+        public String toString() {
+            return this.equivalence + ".wrap(" + this.reference + ")";
+        }
+
+        private Wrapper(Equivalence<? super T> equivalence, @NullableDecl T t) {
+            this.equivalence = (Equivalence) Preconditions.checkNotNull(equivalence);
+            this.reference = t;
+        }
+    }
+
+    public static final class b extends Equivalence implements Serializable {
+        static final b a = new b();
+
+        @Override // com.applovin.exoplayer2.common.base.Equivalence
+        public boolean doEquivalent(Object obj, Object obj2) {
+            return obj.equals(obj2);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Equivalence
+        public int doHash(Object obj) {
+            return obj.hashCode();
+        }
+    }
+
+    public static final class c implements Predicate, Serializable {
+        private final Equivalence a;
+        private final Object b;
+
+        public c(Equivalence equivalence, Object obj) {
+            this.a = (Equivalence) Preconditions.checkNotNull(equivalence);
+            this.b = obj;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean apply(Object obj) {
+            return this.a.equivalent(obj, this.b);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof c)) {
+                return false;
+            }
+            c cVar = (c) obj;
+            return this.a.equals(cVar.a) && Objects.equal(this.b, cVar.b);
+        }
+
+        public int hashCode() {
+            return Objects.hashCode(this.a, this.b);
+        }
+
+        public String toString() {
+            return this.a + ".equivalentTo(" + this.b + ")";
+        }
+    }
+
+    public static final class d extends Equivalence implements Serializable {
+        static final d a = new d();
+
+        @Override // com.applovin.exoplayer2.common.base.Equivalence
+        public boolean doEquivalent(Object obj, Object obj2) {
+            return false;
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Equivalence
+        public int doHash(Object obj) {
+            return System.identityHashCode(obj);
+        }
+    }
+
+    public static Equivalence<Object> equals() {
+        return b.a;
+    }
+
+    public static Equivalence<Object> identity() {
+        return d.a;
+    }
+
+    public abstract boolean doEquivalent(T t, T t2);
+
+    public abstract int doHash(T t);
+
+    public final boolean equivalent(@NullableDecl T t, @NullableDecl T t2) {
+        if (t == t2) {
+            return true;
+        }
+        if (t == null || t2 == null) {
+            return false;
+        }
+        return doEquivalent(t, t2);
+    }
+
+    public final Predicate<T> equivalentTo(@NullableDecl T t) {
+        return new c(this, t);
+    }
+
+    public final int hash(@NullableDecl T t) {
+        if (t == null) {
+            return 0;
+        }
+        return doHash(t);
+    }
+
+    public final <S extends T> Wrapper<S> wrap(@NullableDecl S s) {
+        return new Wrapper<>(s);
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Function.java

@@ -0,0 +1,11 @@
+package com.applovin.exoplayer2.common.base;
+
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+/* loaded from: classes.dex */
+public interface Function<F, T> {
+    @NullableDecl
+    T apply(@NullableDecl F f);
+
+    boolean equals(@NullableDecl Object obj);
+}

decompiled/sources/com/applovin/exoplayer2/common/base/MoreObjects.java

@@ -0,0 +1,166 @@
+package com.applovin.exoplayer2.common.base;
+
+import com.ironsource.nb;
+import java.util.Arrays;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+/* loaded from: classes.dex */
+public final class MoreObjects {
+
+    public static final class ToStringHelper {
+        private final String className;
+        private final a holderHead;
+        private a holderTail;
+        private boolean omitNullValues;
+
+        public static final class a {
+            String a;
+            Object b;
+            a c;
+
+            private a() {
+            }
+        }
+
+        private a addHolder() {
+            a aVar = new a();
+            this.holderTail.c = aVar;
+            this.holderTail = aVar;
+            return aVar;
+        }
+
+        public ToStringHelper add(String str, @NullableDecl Object obj) {
+            return addHolder(str, obj);
+        }
+
+        public ToStringHelper addValue(@NullableDecl Object obj) {
+            return addHolder(obj);
+        }
+
+        public ToStringHelper omitNullValues() {
+            this.omitNullValues = true;
+            return this;
+        }
+
+        private ToStringHelper(String str) {
+            a aVar = new a();
+            this.holderHead = aVar;
+            this.holderTail = aVar;
+            this.omitNullValues = false;
+            this.className = (String) Preconditions.checkNotNull(str);
+        }
+
+        public ToStringHelper add(String str, boolean z) {
+            return addHolder(str, String.valueOf(z));
+        }
+
+        public ToStringHelper addValue(boolean z) {
+            return addHolder(String.valueOf(z));
+        }
+
+        private ToStringHelper addHolder(@NullableDecl Object obj) {
+            addHolder().b = obj;
+            return this;
+        }
+
+        public ToStringHelper add(String str, char c) {
+            return addHolder(str, String.valueOf(c));
+        }
+
+        public ToStringHelper addValue(char c) {
+            return addHolder(String.valueOf(c));
+        }
+
+        public String toString() {
+            boolean z = this.omitNullValues;
+            StringBuilder sb = new StringBuilder(32);
+            sb.append(this.className);
+            sb.append('{');
+            String str = "";
+            for (a aVar = this.holderHead.c; aVar != null; aVar = aVar.c) {
+                Object obj = aVar.b;
+                if (!z || obj != null) {
+                    sb.append(str);
+                    String str2 = aVar.a;
+                    if (str2 != null) {
+                        sb.append(str2);
+                        sb.append(nb.T);
+                    }
+                    if (obj != null && obj.getClass().isArray()) {
+                        String deepToString = Arrays.deepToString(new Object[]{obj});
+                        sb.append((CharSequence) deepToString, 1, deepToString.length() - 1);
+                    } else {
+                        sb.append(obj);
+                    }
+                    str = ", ";
+                }
+            }
+            sb.append('}');
+            return sb.toString();
+        }
+
+        public ToStringHelper add(String str, double d) {
+            return addHolder(str, String.valueOf(d));
+        }
+
+        public ToStringHelper addValue(double d) {
+            return addHolder(String.valueOf(d));
+        }
+
+        private ToStringHelper addHolder(String str, @NullableDecl Object obj) {
+            a addHolder = addHolder();
+            addHolder.b = obj;
+            addHolder.a = (String) Preconditions.checkNotNull(str);
+            return this;
+        }
+
+        public ToStringHelper add(String str, float f) {
+            return addHolder(str, String.valueOf(f));
+        }
+
+        public ToStringHelper addValue(float f) {
+            return addHolder(String.valueOf(f));
+        }
+
+        public ToStringHelper add(String str, int i) {
+            return addHolder(str, String.valueOf(i));
+        }
+
+        public ToStringHelper addValue(int i) {
+            return addHolder(String.valueOf(i));
+        }
+
+        public ToStringHelper add(String str, long j) {
+            return addHolder(str, String.valueOf(j));
+        }
+
+        public ToStringHelper addValue(long j) {
+            return addHolder(String.valueOf(j));
+        }
+    }
+
+    private MoreObjects() {
+    }
+
+    public static <T> T firstNonNull(@NullableDecl T t, @NullableDecl T t2) {
+        if (t != null) {
+            return t;
+        }
+        if (t2 != null) {
+            return t2;
+        }
+        throw new NullPointerException("Both parameters are null");
+    }
+
+    public static ToStringHelper toStringHelper(Object obj) {
+        return new ToStringHelper(obj.getClass().getSimpleName());
+    }
+
+    public static ToStringHelper toStringHelper(Class<?> cls) {
+        return new ToStringHelper(cls.getSimpleName());
+    }
+
+    public static ToStringHelper toStringHelper(String str) {
+        return new ToStringHelper(str);
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Objects.java

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

decompiled/sources/com/applovin/exoplayer2/common/base/Optional.java

@@ -0,0 +1,84 @@
+package com.applovin.exoplayer2.common.base;
+
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.Set;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+/* loaded from: classes.dex */
+public abstract class Optional<T> implements Serializable {
+    private static final long serialVersionUID = 0;
+
+    public class a implements Iterable {
+        final /* synthetic */ Iterable a;
+
+        /* renamed from: com.applovin.exoplayer2.common.base.Optional$a$a, reason: collision with other inner class name */
+        public class C0008a extends b {
+            private final Iterator c;
+
+            public C0008a() {
+                this.c = (Iterator) Preconditions.checkNotNull(a.this.a.iterator());
+            }
+
+            @Override // com.applovin.exoplayer2.common.base.b
+            public Object a() {
+                while (this.c.hasNext()) {
+                    Optional optional = (Optional) this.c.next();
+                    if (optional.isPresent()) {
+                        return optional.get();
+                    }
+                }
+                return b();
+            }
+        }
+
+        public a(Iterable iterable) {
+            this.a = iterable;
+        }
+
+        @Override // java.lang.Iterable
+        public Iterator iterator() {
+            return new C0008a();
+        }
+    }
+
+    public static <T> Optional<T> absent() {
+        return com.applovin.exoplayer2.common.base.a.a();
+    }
+
+    public static <T> Optional<T> fromNullable(@NullableDecl T t) {
+        return t == null ? absent() : new d(t);
+    }
+
+    public static <T> Optional<T> of(T t) {
+        return new d(Preconditions.checkNotNull(t));
+    }
+
+    public static <T> Iterable<T> presentInstances(Iterable<? extends Optional<? extends T>> iterable) {
+        Preconditions.checkNotNull(iterable);
+        return new a(iterable);
+    }
+
+    public abstract Set<T> asSet();
+
+    public abstract boolean equals(@NullableDecl 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);
+
+    @NullableDecl
+    public abstract T orNull();
+
+    public abstract String toString();
+
+    public abstract <V> Optional<V> transform(Function<? super T, V> function);
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Preconditions.java

@@ -0,0 +1,560 @@
+package com.applovin.exoplayer2.common.base;
+
+import org.checkerframework.checker.nullness.compatqual.NonNullDecl;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+/* loaded from: classes.dex */
+public final class Preconditions {
+    private Preconditions() {
+    }
+
+    private static String badElementIndex(int i, int i2, @NullableDecl String str) {
+        if (i < 0) {
+            return Strings.lenientFormat("%s (%s) must not be negative", str, Integer.valueOf(i));
+        }
+        if (i2 >= 0) {
+            return Strings.lenientFormat("%s (%s) must be less than size (%s)", str, Integer.valueOf(i), Integer.valueOf(i2));
+        }
+        throw new IllegalArgumentException("negative size: " + i2);
+    }
+
+    private static String badPositionIndex(int i, int i2, @NullableDecl String str) {
+        if (i < 0) {
+            return Strings.lenientFormat("%s (%s) must not be negative", str, Integer.valueOf(i));
+        }
+        if (i2 >= 0) {
+            return Strings.lenientFormat("%s (%s) must not be greater than size (%s)", str, Integer.valueOf(i), Integer.valueOf(i2));
+        }
+        throw new IllegalArgumentException("negative size: " + i2);
+    }
+
+    private static String badPositionIndexes(int i, int i2, int i3) {
+        return (i < 0 || i > i3) ? badPositionIndex(i, i3, "start index") : (i2 < 0 || i2 > i3) ? badPositionIndex(i2, i3, "end index") : Strings.lenientFormat("end index (%s) must not be less than start index (%s)", Integer.valueOf(i2), Integer.valueOf(i));
+    }
+
+    public static void checkArgument(boolean z) {
+        if (!z) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static int checkElementIndex(int i, int i2) {
+        return checkElementIndex(i, i2, "index");
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t) {
+        t.getClass();
+        return t;
+    }
+
+    public static int checkPositionIndex(int i, int i2) {
+        return checkPositionIndex(i, i2, "index");
+    }
+
+    public static void checkPositionIndexes(int i, int i2, int i3) {
+        if (i < 0 || i2 < i || i2 > i3) {
+            throw new IndexOutOfBoundsException(badPositionIndexes(i, i2, i3));
+        }
+    }
+
+    public static void checkState(boolean z) {
+        if (!z) {
+            throw new IllegalStateException();
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl Object obj) {
+        if (!z) {
+            throw new IllegalArgumentException(String.valueOf(obj));
+        }
+    }
+
+    public static int checkElementIndex(int i, int i2, @NullableDecl String str) {
+        if (i < 0 || i >= i2) {
+            throw new IndexOutOfBoundsException(badElementIndex(i, i2, str));
+        }
+        return i;
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl Object obj) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(String.valueOf(obj));
+    }
+
+    public static int checkPositionIndex(int i, int i2, @NullableDecl String str) {
+        if (i < 0 || i > i2) {
+            throw new IndexOutOfBoundsException(badPositionIndex(i, i2, str));
+        }
+        return i;
+    }
+
+    public static void checkState(boolean z, @NullableDecl Object obj) {
+        if (!z) {
+            throw new IllegalStateException(String.valueOf(obj));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, @NullableDecl Object... objArr) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, objArr));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, @NullableDecl Object... objArr) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, objArr));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, @NullableDecl Object... objArr) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, objArr));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, char c) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Character.valueOf(c)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, char c) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Character.valueOf(c)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, char c) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Character.valueOf(c)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, int i) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Integer.valueOf(i)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, int i) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Integer.valueOf(i)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, int i) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Integer.valueOf(i)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, long j) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Long.valueOf(j)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, long j) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Long.valueOf(j)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, long j) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Long.valueOf(j)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, @NullableDecl Object obj) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, obj));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, @NullableDecl Object obj) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, obj));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, @NullableDecl Object obj) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, obj));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, char c, char c2) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Character.valueOf(c), Character.valueOf(c2)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, char c, char c2) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Character.valueOf(c), Character.valueOf(c2)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, char c, char c2) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Character.valueOf(c), Character.valueOf(c2)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, char c, int i) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Character.valueOf(c), Integer.valueOf(i)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, char c, int i) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Character.valueOf(c), Integer.valueOf(i)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, char c, int i) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Character.valueOf(c), Integer.valueOf(i)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, char c, long j) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Character.valueOf(c), Long.valueOf(j)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, char c, long j) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Character.valueOf(c), Long.valueOf(j)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, char c, long j) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Character.valueOf(c), Long.valueOf(j)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, char c, @NullableDecl Object obj) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Character.valueOf(c), obj));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, char c, @NullableDecl Object obj) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Character.valueOf(c), obj));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, char c, @NullableDecl Object obj) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Character.valueOf(c), obj));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, int i, char c) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Integer.valueOf(i), Character.valueOf(c)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, int i, char c) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Integer.valueOf(i), Character.valueOf(c)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, int i, char c) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Integer.valueOf(i), Character.valueOf(c)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, int i, int i2) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Integer.valueOf(i), Integer.valueOf(i2)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, int i, int i2) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Integer.valueOf(i), Integer.valueOf(i2)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, int i, int i2) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Integer.valueOf(i), Integer.valueOf(i2)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, int i, long j) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Integer.valueOf(i), Long.valueOf(j)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, int i, long j) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Integer.valueOf(i), Long.valueOf(j)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, int i, long j) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Integer.valueOf(i), Long.valueOf(j)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, int i, @NullableDecl Object obj) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Integer.valueOf(i), obj));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, int i, @NullableDecl Object obj) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Integer.valueOf(i), obj));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, int i, @NullableDecl Object obj) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Integer.valueOf(i), obj));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, long j, char c) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Long.valueOf(j), Character.valueOf(c)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, long j, char c) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Long.valueOf(j), Character.valueOf(c)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, long j, char c) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Long.valueOf(j), Character.valueOf(c)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, long j, int i) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Long.valueOf(j), Integer.valueOf(i)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, long j, int i) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Long.valueOf(j), Integer.valueOf(i)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, long j, int i) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Long.valueOf(j), Integer.valueOf(i)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, long j, long j2) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Long.valueOf(j), Long.valueOf(j2)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, long j, long j2) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Long.valueOf(j), Long.valueOf(j2)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, long j, long j2) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Long.valueOf(j), Long.valueOf(j2)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, long j, @NullableDecl Object obj) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Long.valueOf(j), obj));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, long j, @NullableDecl Object obj) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, Long.valueOf(j), obj));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, long j, @NullableDecl Object obj) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, Long.valueOf(j), obj));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, @NullableDecl Object obj, char c) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, obj, Character.valueOf(c)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, @NullableDecl Object obj, char c) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, obj, Character.valueOf(c)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, @NullableDecl Object obj, char c) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, obj, Character.valueOf(c)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, @NullableDecl Object obj, int i) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, obj, Integer.valueOf(i)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, @NullableDecl Object obj, int i) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, obj, Integer.valueOf(i)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, @NullableDecl Object obj, int i) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, obj, Integer.valueOf(i)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, @NullableDecl Object obj, long j) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, obj, Long.valueOf(j)));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, @NullableDecl Object obj, long j) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, obj, Long.valueOf(j)));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, @NullableDecl Object obj, long j) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, obj, Long.valueOf(j)));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, @NullableDecl Object obj, @NullableDecl Object obj2) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, obj, obj2));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, @NullableDecl Object obj, @NullableDecl Object obj2) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, obj, obj2));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, @NullableDecl Object obj, @NullableDecl Object obj2) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, obj, obj2));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, @NullableDecl Object obj, @NullableDecl Object obj2, @NullableDecl Object obj3) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, obj, obj2, obj3));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, @NullableDecl Object obj, @NullableDecl Object obj2, @NullableDecl Object obj3) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, obj, obj2, obj3));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, @NullableDecl Object obj, @NullableDecl Object obj2, @NullableDecl Object obj3) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, obj, obj2, obj3));
+        }
+    }
+
+    public static void checkArgument(boolean z, @NullableDecl String str, @NullableDecl Object obj, @NullableDecl Object obj2, @NullableDecl Object obj3, @NullableDecl Object obj4) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, obj, obj2, obj3, obj4));
+        }
+    }
+
+    @NonNullDecl
+    public static <T> T checkNotNull(@NonNullDecl T t, @NullableDecl String str, @NullableDecl Object obj, @NullableDecl Object obj2, @NullableDecl Object obj3, @NullableDecl Object obj4) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(Strings.lenientFormat(str, obj, obj2, obj3, obj4));
+    }
+
+    public static void checkState(boolean z, @NullableDecl String str, @NullableDecl Object obj, @NullableDecl Object obj2, @NullableDecl Object obj3, @NullableDecl Object obj4) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, obj, obj2, obj3, obj4));
+        }
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Predicate.java

@@ -0,0 +1,10 @@
+package com.applovin.exoplayer2.common.base;
+
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+/* loaded from: classes.dex */
+public interface Predicate<T> {
+    boolean apply(@NullableDecl T t);
+
+    boolean equals(@NullableDecl Object obj);
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Predicates.java

@@ -0,0 +1,452 @@
+package com.applovin.exoplayer2.common.base;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+/* loaded from: classes.dex */
+public final class Predicates {
+
+    public static class b implements Predicate, Serializable {
+        private final List a;
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean apply(Object obj) {
+            for (int i = 0; i < this.a.size(); i++) {
+                if (!((Predicate) this.a.get(i)).apply(obj)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (obj instanceof b) {
+                return this.a.equals(((b) obj).a);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return this.a.hashCode() + 306654252;
+        }
+
+        public String toString() {
+            return Predicates.toStringHelper("and", this.a);
+        }
+
+        private b(List list) {
+            this.a = list;
+        }
+    }
+
+    public static class c implements Predicate, Serializable {
+        final Predicate a;
+        final Function b;
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean apply(Object obj) {
+            return this.a.apply(this.b.apply(obj));
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (!(obj instanceof c)) {
+                return false;
+            }
+            c cVar = (c) obj;
+            return this.b.equals(cVar.b) && this.a.equals(cVar.a);
+        }
+
+        public int hashCode() {
+            return this.b.hashCode() ^ this.a.hashCode();
+        }
+
+        public String toString() {
+            return this.a + "(" + this.b + ")";
+        }
+
+        private c(Predicate predicate, Function function) {
+            this.a = (Predicate) Preconditions.checkNotNull(predicate);
+            this.b = (Function) Preconditions.checkNotNull(function);
+        }
+    }
+
+    public static class d implements Predicate, Serializable {
+        private final Collection a;
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean apply(Object obj) {
+            try {
+                return this.a.contains(obj);
+            } catch (ClassCastException | NullPointerException unused) {
+                return false;
+            }
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (obj instanceof d) {
+                return this.a.equals(((d) obj).a);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return this.a.hashCode();
+        }
+
+        public String toString() {
+            return "Predicates.in(" + this.a + ")";
+        }
+
+        private d(Collection collection) {
+            this.a = (Collection) Preconditions.checkNotNull(collection);
+        }
+    }
+
+    public static class e implements Predicate, Serializable {
+        private final Class a;
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean apply(Object obj) {
+            return this.a.isInstance(obj);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean equals(Object obj) {
+            return (obj instanceof e) && this.a == ((e) obj).a;
+        }
+
+        public int hashCode() {
+            return this.a.hashCode();
+        }
+
+        public String toString() {
+            return "Predicates.instanceOf(" + this.a.getName() + ")";
+        }
+
+        private e(Class cls) {
+            this.a = (Class) Preconditions.checkNotNull(cls);
+        }
+    }
+
+    public static class f implements Predicate, Serializable {
+        private final Object a;
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean apply(Object obj) {
+            return this.a.equals(obj);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (obj instanceof f) {
+                return this.a.equals(((f) obj).a);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return this.a.hashCode();
+        }
+
+        public String toString() {
+            return "Predicates.equalTo(" + this.a + ")";
+        }
+
+        private f(Object obj) {
+            this.a = obj;
+        }
+    }
+
+    public static class g implements Predicate, Serializable {
+        final Predicate a;
+
+        public g(Predicate predicate) {
+            this.a = (Predicate) Preconditions.checkNotNull(predicate);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean apply(Object obj) {
+            return !this.a.apply(obj);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (obj instanceof g) {
+                return this.a.equals(((g) obj).a);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return ~this.a.hashCode();
+        }
+
+        public String toString() {
+            return "Predicates.not(" + this.a + ")";
+        }
+    }
+
+    /* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+    /* JADX WARN: Unknown enum class pattern. Please report as an issue! */
+    public static abstract class h implements Predicate {
+        public static final h a = new a("ALWAYS_TRUE", 0);
+        public static final h b = new b("ALWAYS_FALSE", 1);
+        public static final h c = new c("IS_NULL", 2);
+        public static final h d = new d("NOT_NULL", 3);
+        private static final /* synthetic */ h[] f = a();
+
+        public enum a extends h {
+            public a(String str, int i) {
+                super(str, i);
+            }
+
+            @Override // com.applovin.exoplayer2.common.base.Predicate
+            public boolean apply(Object obj) {
+                return true;
+            }
+
+            @Override // java.lang.Enum
+            public String toString() {
+                return "Predicates.alwaysTrue()";
+            }
+        }
+
+        public enum b extends h {
+            public b(String str, int i) {
+                super(str, i);
+            }
+
+            @Override // com.applovin.exoplayer2.common.base.Predicate
+            public boolean apply(Object obj) {
+                return false;
+            }
+
+            @Override // java.lang.Enum
+            public String toString() {
+                return "Predicates.alwaysFalse()";
+            }
+        }
+
+        public enum c extends h {
+            public c(String str, int i) {
+                super(str, i);
+            }
+
+            @Override // com.applovin.exoplayer2.common.base.Predicate
+            public boolean apply(Object obj) {
+                return obj == null;
+            }
+
+            @Override // java.lang.Enum
+            public String toString() {
+                return "Predicates.isNull()";
+            }
+        }
+
+        public enum d extends h {
+            public d(String str, int i) {
+                super(str, i);
+            }
+
+            @Override // com.applovin.exoplayer2.common.base.Predicate
+            public boolean apply(Object obj) {
+                return obj != null;
+            }
+
+            @Override // java.lang.Enum
+            public String toString() {
+                return "Predicates.notNull()";
+            }
+        }
+
+        private h(String str, int i) {
+        }
+
+        private static /* synthetic */ h[] a() {
+            return new h[]{a, b, c, d};
+        }
+
+        public static h valueOf(String str) {
+            return (h) Enum.valueOf(h.class, str);
+        }
+
+        public static h[] values() {
+            return (h[]) f.clone();
+        }
+
+        public Predicate b() {
+            return this;
+        }
+    }
+
+    public static class i implements Predicate, Serializable {
+        private final List a;
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean apply(Object obj) {
+            for (int i = 0; i < this.a.size(); i++) {
+                if (((Predicate) this.a.get(i)).apply(obj)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean equals(Object obj) {
+            if (obj instanceof i) {
+                return this.a.equals(((i) obj).a);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return this.a.hashCode() + 87855567;
+        }
+
+        public String toString() {
+            return Predicates.toStringHelper("or", this.a);
+        }
+
+        private i(List list) {
+            this.a = list;
+        }
+    }
+
+    public static class j implements Predicate, Serializable {
+        private final Class a;
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean equals(Object obj) {
+            return (obj instanceof j) && this.a == ((j) obj).a;
+        }
+
+        public int hashCode() {
+            return this.a.hashCode();
+        }
+
+        public String toString() {
+            return "Predicates.subtypeOf(" + this.a.getName() + ")";
+        }
+
+        private j(Class cls) {
+            this.a = (Class) Preconditions.checkNotNull(cls);
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Predicate
+        public boolean apply(Class cls) {
+            return this.a.isAssignableFrom(cls);
+        }
+    }
+
+    private Predicates() {
+    }
+
+    public static <T> Predicate<T> alwaysFalse() {
+        return h.b.b();
+    }
+
+    public static <T> Predicate<T> alwaysTrue() {
+        return h.a.b();
+    }
+
+    public static <T> Predicate<T> and(Iterable<? extends Predicate<? super T>> iterable) {
+        return new b(defensiveCopy(iterable));
+    }
+
+    private static <T> List<Predicate<? super T>> asList(Predicate<? super T> predicate, Predicate<? super T> predicate2) {
+        return Arrays.asList(predicate, predicate2);
+    }
+
+    public static <A, B> Predicate<A> compose(Predicate<B> predicate, Function<A, ? extends B> function) {
+        return new c(predicate, function);
+    }
+
+    private static <T> List<T> defensiveCopy(T... tArr) {
+        return defensiveCopy(Arrays.asList(tArr));
+    }
+
+    public static <T> Predicate<T> equalTo(@NullableDecl T t) {
+        return t == null ? isNull() : new f(t);
+    }
+
+    public static <T> Predicate<T> in(Collection<? extends T> collection) {
+        return new d(collection);
+    }
+
+    public static Predicate<Object> instanceOf(Class<?> cls) {
+        return new e(cls);
+    }
+
+    public static <T> Predicate<T> isNull() {
+        return h.c.b();
+    }
+
+    public static <T> Predicate<T> not(Predicate<T> predicate) {
+        return new g(predicate);
+    }
+
+    public static <T> Predicate<T> notNull() {
+        return h.d.b();
+    }
+
+    public static <T> Predicate<T> or(Iterable<? extends Predicate<? super T>> iterable) {
+        return new i(defensiveCopy(iterable));
+    }
+
+    public static Predicate<Class<?>> subtypeOf(Class<?> cls) {
+        return new j(cls);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static String toStringHelper(String str, Iterable<?> iterable) {
+        StringBuilder sb = new StringBuilder("Predicates.");
+        sb.append(str);
+        sb.append('(');
+        boolean z = true;
+        for (Object obj : iterable) {
+            if (!z) {
+                sb.append(',');
+            }
+            sb.append(obj);
+            z = false;
+        }
+        sb.append(')');
+        return sb.toString();
+    }
+
+    @SafeVarargs
+    public static <T> Predicate<T> and(Predicate<? super T>... predicateArr) {
+        return new b(defensiveCopy(predicateArr));
+    }
+
+    public static <T> List<T> defensiveCopy(Iterable<T> iterable) {
+        ArrayList arrayList = new ArrayList();
+        Iterator<T> it = iterable.iterator();
+        while (it.hasNext()) {
+            arrayList.add(Preconditions.checkNotNull(it.next()));
+        }
+        return arrayList;
+    }
+
+    @SafeVarargs
+    public static <T> Predicate<T> or(Predicate<? super T>... predicateArr) {
+        return new i(defensiveCopy(predicateArr));
+    }
+
+    public static <T> Predicate<T> and(Predicate<? super T> predicate, Predicate<? super T> predicate2) {
+        return new b(asList((Predicate) Preconditions.checkNotNull(predicate), (Predicate) Preconditions.checkNotNull(predicate2)));
+    }
+
+    public static <T> Predicate<T> or(Predicate<? super T> predicate, Predicate<? super T> predicate2) {
+        return new i(asList((Predicate) Preconditions.checkNotNull(predicate), (Predicate) Preconditions.checkNotNull(predicate2)));
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Splitter.java

@@ -0,0 +1,287 @@
+package com.applovin.exoplayer2.common.base;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class Splitter {
+    private final int limit;
+    private final boolean omitEmptyStrings;
+    private final e strategy;
+    private final CharMatcher trimmer;
+
+    public class a implements e {
+        final /* synthetic */ CharMatcher a;
+
+        /* renamed from: com.applovin.exoplayer2.common.base.Splitter$a$a, reason: collision with other inner class name */
+        public class C0009a extends d {
+            public C0009a(Splitter splitter, CharSequence charSequence) {
+                super(splitter, charSequence);
+            }
+
+            @Override // com.applovin.exoplayer2.common.base.Splitter.d
+            public int a(int i) {
+                return i + 1;
+            }
+
+            @Override // com.applovin.exoplayer2.common.base.Splitter.d
+            public int b(int i) {
+                return a.this.a.indexIn(this.c, i);
+            }
+        }
+
+        public a(CharMatcher charMatcher) {
+            this.a = charMatcher;
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Splitter.e
+        /* renamed from: b, reason: merged with bridge method [inline-methods] */
+        public d a(Splitter splitter, CharSequence charSequence) {
+            return new C0009a(splitter, charSequence);
+        }
+    }
+
+    public class b implements e {
+        final /* synthetic */ String a;
+
+        public class a extends d {
+            public a(Splitter splitter, CharSequence charSequence) {
+                super(splitter, charSequence);
+            }
+
+            @Override // com.applovin.exoplayer2.common.base.Splitter.d
+            public int a(int i) {
+                return i + b.this.a.length();
+            }
+
+            /* JADX WARN: Code restructure failed: missing block: B:9:0x0026, code lost:
+            
+                r6 = r6 + 1;
+             */
+            @Override // com.applovin.exoplayer2.common.base.Splitter.d
+            /*
+                Code decompiled incorrectly, please refer to instructions dump.
+                To view partially-correct add '--show-bad-code' argument
+            */
+            public int b(int r6) {
+                /*
+                    r5 = this;
+                    com.applovin.exoplayer2.common.base.Splitter$b r0 = com.applovin.exoplayer2.common.base.Splitter.b.this
+                    java.lang.String r0 = r0.a
+                    int r0 = r0.length()
+                    java.lang.CharSequence r1 = r5.c
+                    int r1 = r1.length()
+                    int r1 = r1 - r0
+                Lf:
+                    if (r6 > r1) goto L2d
+                    r2 = 0
+                L12:
+                    if (r2 >= r0) goto L2c
+                    java.lang.CharSequence r3 = r5.c
+                    int r4 = r2 + r6
+                    char r3 = r3.charAt(r4)
+                    com.applovin.exoplayer2.common.base.Splitter$b r4 = com.applovin.exoplayer2.common.base.Splitter.b.this
+                    java.lang.String r4 = r4.a
+                    char r4 = r4.charAt(r2)
+                    if (r3 == r4) goto L29
+                    int r6 = r6 + 1
+                    goto Lf
+                L29:
+                    int r2 = r2 + 1
+                    goto L12
+                L2c:
+                    return r6
+                L2d:
+                    r6 = -1
+                    return r6
+                */
+                throw new UnsupportedOperationException("Method not decompiled: com.applovin.exoplayer2.common.base.Splitter.b.a.b(int):int");
+            }
+        }
+
+        public b(String str) {
+            this.a = str;
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Splitter.e
+        /* renamed from: b, reason: merged with bridge method [inline-methods] */
+        public d a(Splitter splitter, CharSequence charSequence) {
+            return new a(splitter, charSequence);
+        }
+    }
+
+    public class c implements e {
+        final /* synthetic */ int a;
+
+        public class a extends d {
+            public a(Splitter splitter, CharSequence charSequence) {
+                super(splitter, charSequence);
+            }
+
+            @Override // com.applovin.exoplayer2.common.base.Splitter.d
+            public int a(int i) {
+                return i;
+            }
+
+            @Override // com.applovin.exoplayer2.common.base.Splitter.d
+            public int b(int i) {
+                int i2 = i + c.this.a;
+                if (i2 < this.c.length()) {
+                    return i2;
+                }
+                return -1;
+            }
+        }
+
+        public c(int i) {
+            this.a = i;
+        }
+
+        @Override // com.applovin.exoplayer2.common.base.Splitter.e
+        /* renamed from: b, reason: merged with bridge method [inline-methods] */
+        public d a(Splitter splitter, CharSequence charSequence) {
+            return new a(splitter, charSequence);
+        }
+    }
+
+    public interface e {
+        Iterator a(Splitter splitter, CharSequence charSequence);
+    }
+
+    private Splitter(e eVar) {
+        this(eVar, false, CharMatcher.none(), Integer.MAX_VALUE);
+    }
+
+    public static Splitter fixedLength(int i) {
+        Preconditions.checkArgument(i > 0, "The length may not be less than 1");
+        return new Splitter(new c(i));
+    }
+
+    public static Splitter on(char c2) {
+        return on(CharMatcher.is(c2));
+    }
+
+    private Iterator<String> splittingIterator(CharSequence charSequence) {
+        return this.strategy.a(this, charSequence);
+    }
+
+    public Splitter limit(int i) {
+        Preconditions.checkArgument(i > 0, "must be greater than zero: %s", i);
+        return new Splitter(this.strategy, this.omitEmptyStrings, this.trimmer, i);
+    }
+
+    public Splitter omitEmptyStrings() {
+        return new Splitter(this.strategy, true, this.trimmer, this.limit);
+    }
+
+    public List<String> splitToList(CharSequence charSequence) {
+        Preconditions.checkNotNull(charSequence);
+        Iterator<String> splittingIterator = splittingIterator(charSequence);
+        ArrayList arrayList = new ArrayList();
+        while (splittingIterator.hasNext()) {
+            arrayList.add(splittingIterator.next());
+        }
+        return Collections.unmodifiableList(arrayList);
+    }
+
+    public Splitter trimResults() {
+        return trimResults(CharMatcher.whitespace());
+    }
+
+    private Splitter(e eVar, boolean z, CharMatcher charMatcher, int i) {
+        this.strategy = eVar;
+        this.omitEmptyStrings = z;
+        this.trimmer = charMatcher;
+        this.limit = i;
+    }
+
+    public static Splitter on(CharMatcher charMatcher) {
+        Preconditions.checkNotNull(charMatcher);
+        return new Splitter(new a(charMatcher));
+    }
+
+    public Splitter trimResults(CharMatcher charMatcher) {
+        Preconditions.checkNotNull(charMatcher);
+        return new Splitter(this.strategy, this.omitEmptyStrings, charMatcher, this.limit);
+    }
+
+    public static abstract class d extends com.applovin.exoplayer2.common.base.b {
+        final CharSequence c;
+        final CharMatcher d;
+        final boolean f;
+        int g = 0;
+        int h;
+
+        public d(Splitter splitter, CharSequence charSequence) {
+            this.d = splitter.trimmer;
+            this.f = splitter.omitEmptyStrings;
+            this.h = splitter.limit;
+            this.c = charSequence;
+        }
+
+        public abstract int a(int i);
+
+        public abstract int b(int i);
+
+        @Override // com.applovin.exoplayer2.common.base.b
+        /* renamed from: d, reason: merged with bridge method [inline-methods] */
+        public String a() {
+            int b;
+            int i = this.g;
+            while (true) {
+                int i2 = this.g;
+                if (i2 != -1) {
+                    b = b(i2);
+                    if (b == -1) {
+                        b = this.c.length();
+                        this.g = -1;
+                    } else {
+                        this.g = a(b);
+                    }
+                    int i3 = this.g;
+                    if (i3 == i) {
+                        int i4 = i3 + 1;
+                        this.g = i4;
+                        if (i4 > this.c.length()) {
+                            this.g = -1;
+                        }
+                    } else {
+                        while (i < b && this.d.matches(this.c.charAt(i))) {
+                            i++;
+                        }
+                        while (b > i && this.d.matches(this.c.charAt(b - 1))) {
+                            b--;
+                        }
+                        if (!this.f || i != b) {
+                            break;
+                        }
+                        i = this.g;
+                    }
+                } else {
+                    return (String) b();
+                }
+            }
+            int i5 = this.h;
+            if (i5 == 1) {
+                b = this.c.length();
+                this.g = -1;
+                while (b > i && this.d.matches(this.c.charAt(b - 1))) {
+                    b--;
+                }
+            } else {
+                this.h = i5 - 1;
+            }
+            return this.c.subSequence(i, b).toString();
+        }
+    }
+
+    public static Splitter on(String str) {
+        Preconditions.checkArgument(str.length() != 0, "The separator may not be the empty string.");
+        if (str.length() == 1) {
+            return on(str.charAt(0));
+        }
+        return new Splitter(new b(str));
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Strings.java

@@ -0,0 +1,137 @@
+package com.applovin.exoplayer2.common.base;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+
+/* loaded from: classes.dex */
+public final class Strings {
+    private Strings() {
+    }
+
+    public static String commonPrefix(CharSequence charSequence, CharSequence charSequence2) {
+        Preconditions.checkNotNull(charSequence);
+        Preconditions.checkNotNull(charSequence2);
+        int min = Math.min(charSequence.length(), charSequence2.length());
+        int i = 0;
+        while (i < min && charSequence.charAt(i) == charSequence2.charAt(i)) {
+            i++;
+        }
+        int i2 = i - 1;
+        if (validSurrogatePairAt(charSequence, i2) || validSurrogatePairAt(charSequence2, i2)) {
+            i--;
+        }
+        return charSequence.subSequence(0, i).toString();
+    }
+
+    public static String commonSuffix(CharSequence charSequence, CharSequence charSequence2) {
+        Preconditions.checkNotNull(charSequence);
+        Preconditions.checkNotNull(charSequence2);
+        int min = Math.min(charSequence.length(), charSequence2.length());
+        int i = 0;
+        while (i < min && charSequence.charAt((charSequence.length() - i) - 1) == charSequence2.charAt((charSequence2.length() - i) - 1)) {
+            i++;
+        }
+        if (validSurrogatePairAt(charSequence, (charSequence.length() - i) - 1) || validSurrogatePairAt(charSequence2, (charSequence2.length() - i) - 1)) {
+            i--;
+        }
+        return charSequence.subSequence(charSequence.length() - i, charSequence.length()).toString();
+    }
+
+    public static String lenientFormat(@NullableDecl String str, @NullableDecl Object... objArr) {
+        int indexOf;
+        String valueOf = String.valueOf(str);
+        int i = 0;
+        if (objArr == null) {
+            objArr = new Object[]{"(Object[])null"};
+        } else {
+            for (int i2 = 0; i2 < objArr.length; i2++) {
+                objArr[i2] = lenientToString(objArr[i2]);
+            }
+        }
+        StringBuilder sb = new StringBuilder(valueOf.length() + (objArr.length * 16));
+        int i3 = 0;
+        while (i < objArr.length && (indexOf = valueOf.indexOf("%s", i3)) != -1) {
+            sb.append((CharSequence) valueOf, i3, indexOf);
+            sb.append(objArr[i]);
+            i3 = indexOf + 2;
+            i++;
+        }
+        sb.append((CharSequence) valueOf, i3, valueOf.length());
+        if (i < objArr.length) {
+            sb.append(" [");
+            sb.append(objArr[i]);
+            for (int i4 = i + 1; i4 < objArr.length; i4++) {
+                sb.append(", ");
+                sb.append(objArr[i4]);
+            }
+            sb.append(']');
+        }
+        return sb.toString();
+    }
+
+    private static String lenientToString(@NullableDecl Object obj) {
+        try {
+            return String.valueOf(obj);
+        } catch (Exception e) {
+            String str = obj.getClass().getName() + '@' + Integer.toHexString(System.identityHashCode(obj));
+            Logger.getLogger("com.applovin.exoplayer2.common.base.Strings").log(Level.WARNING, "Exception during lenientFormat for " + str, (Throwable) e);
+            return "<" + str + " threw " + e.getClass().getName() + ">";
+        }
+    }
+
+    public static String padEnd(String str, int i, char c) {
+        Preconditions.checkNotNull(str);
+        if (str.length() >= i) {
+            return str;
+        }
+        StringBuilder sb = new StringBuilder(i);
+        sb.append(str);
+        for (int length = str.length(); length < i; length++) {
+            sb.append(c);
+        }
+        return sb.toString();
+    }
+
+    public static String padStart(String str, int i, char c) {
+        Preconditions.checkNotNull(str);
+        if (str.length() >= i) {
+            return str;
+        }
+        StringBuilder sb = new StringBuilder(i);
+        for (int length = str.length(); length < i; length++) {
+            sb.append(c);
+        }
+        sb.append(str);
+        return sb.toString();
+    }
+
+    public static String repeat(String str, int i) {
+        Preconditions.checkNotNull(str);
+        if (i <= 1) {
+            Preconditions.checkArgument(i >= 0, "invalid count: %s", i);
+            return i == 0 ? "" : str;
+        }
+        int length = str.length();
+        long j = length * i;
+        int i2 = (int) j;
+        if (i2 != j) {
+            throw new ArrayIndexOutOfBoundsException("Required array size too large: " + j);
+        }
+        char[] cArr = new char[i2];
+        str.getChars(0, length, cArr, 0);
+        while (true) {
+            int i3 = i2 - length;
+            if (length >= i3) {
+                System.arraycopy(cArr, 0, cArr, length, i3);
+                return new String(cArr);
+            }
+            System.arraycopy(cArr, 0, cArr, length, length);
+            length <<= 1;
+        }
+    }
+
+    public static boolean validSurrogatePairAt(CharSequence charSequence, int i) {
+        return i >= 0 && i <= charSequence.length() + (-2) && Character.isHighSurrogate(charSequence.charAt(i)) && Character.isLowSurrogate(charSequence.charAt(i + 1));
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/Supplier.java

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

decompiled/sources/com/applovin/exoplayer2/common/base/Throwables.java

@@ -0,0 +1,213 @@
+package com.applovin.exoplayer2.common.base;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class Throwables {
+    private static final String JAVA_LANG_ACCESS_CLASSNAME = "sun.misc.JavaLangAccess";
+    static final String SHARED_SECRETS_CLASSNAME = "sun.misc.SharedSecrets";
+    private static final Method getStackTraceDepthMethod;
+    private static final Method getStackTraceElementMethod;
+    private static final Object jla;
+
+    public class a extends AbstractList {
+        final /* synthetic */ Throwable a;
+
+        public a(Throwable th) {
+            this.a = th;
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+        public int size() {
+            return ((Integer) Throwables.invokeAccessibleNonThrowingMethod(Throwables.getStackTraceDepthMethod, Throwables.jla, this.a)).intValue();
+        }
+
+        @Override // java.util.AbstractList, java.util.List
+        public StackTraceElement get(int i) {
+            return (StackTraceElement) Throwables.invokeAccessibleNonThrowingMethod(Throwables.getStackTraceElementMethod, Throwables.jla, this.a, Integer.valueOf(i));
+        }
+    }
+
+    static {
+        Object jla2 = getJLA();
+        jla = jla2;
+        getStackTraceElementMethod = jla2 == null ? null : getGetMethod();
+        getStackTraceDepthMethod = jla2 != null ? getSizeMethod() : null;
+    }
+
+    private Throwables() {
+    }
+
+    public static List<Throwable> getCausalChain(Throwable th) {
+        Preconditions.checkNotNull(th);
+        ArrayList arrayList = new ArrayList(4);
+        arrayList.add(th);
+        boolean z = false;
+        Throwable th2 = th;
+        while (true) {
+            th = th.getCause();
+            if (th == null) {
+                return Collections.unmodifiableList(arrayList);
+            }
+            arrayList.add(th);
+            if (th == th2) {
+                throw new IllegalArgumentException("Loop in causal chain detected.", th);
+            }
+            if (z) {
+                th2 = th2.getCause();
+            }
+            z = !z;
+        }
+    }
+
+    public static <X extends Throwable> X getCauseAs(Throwable th, Class<X> cls) {
+        try {
+            return cls.cast(th.getCause());
+        } catch (ClassCastException e) {
+            e.initCause(th);
+            throw e;
+        }
+    }
+
+    private static Method getGetMethod() {
+        return getJlaMethod("getStackTraceElement", Throwable.class, Integer.TYPE);
+    }
+
+    private static Object getJLA() {
+        try {
+            return Class.forName(SHARED_SECRETS_CLASSNAME, false, null).getMethod("getJavaLangAccess", new Class[0]).invoke(null, new Object[0]);
+        } catch (ThreadDeath e) {
+            throw e;
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    private static Method getJlaMethod(String str, Class<?>... clsArr) throws ThreadDeath {
+        try {
+            return Class.forName(JAVA_LANG_ACCESS_CLASSNAME, false, null).getMethod(str, clsArr);
+        } catch (ThreadDeath e) {
+            throw e;
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    public static Throwable getRootCause(Throwable th) {
+        boolean z = false;
+        Throwable th2 = th;
+        while (true) {
+            Throwable cause = th.getCause();
+            if (cause == null) {
+                return th;
+            }
+            if (cause == th2) {
+                throw new IllegalArgumentException("Loop in causal chain detected.", cause);
+            }
+            if (z) {
+                th2 = th2.getCause();
+            }
+            z = !z;
+            th = cause;
+        }
+    }
+
+    private static Method getSizeMethod() {
+        try {
+            Method jlaMethod = getJlaMethod("getStackTraceDepth", Throwable.class);
+            if (jlaMethod == null) {
+                return null;
+            }
+            jlaMethod.invoke(getJLA(), new Throwable());
+            return jlaMethod;
+        } catch (IllegalAccessException | UnsupportedOperationException | InvocationTargetException unused) {
+            return null;
+        }
+    }
+
+    public static String getStackTraceAsString(Throwable th) {
+        StringWriter stringWriter = new StringWriter();
+        th.printStackTrace(new PrintWriter(stringWriter));
+        return stringWriter.toString();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static Object invokeAccessibleNonThrowingMethod(Method method, Object obj, Object... objArr) {
+        try {
+            return method.invoke(obj, objArr);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        } catch (InvocationTargetException e2) {
+            throw propagate(e2.getCause());
+        }
+    }
+
+    private static List<StackTraceElement> jlaStackTrace(Throwable th) {
+        Preconditions.checkNotNull(th);
+        return new a(th);
+    }
+
+    public static List<StackTraceElement> lazyStackTrace(Throwable th) {
+        return lazyStackTraceIsLazy() ? jlaStackTrace(th) : Collections.unmodifiableList(Arrays.asList(th.getStackTrace()));
+    }
+
+    public static boolean lazyStackTraceIsLazy() {
+        return (getStackTraceElementMethod == null || getStackTraceDepthMethod == null) ? false : true;
+    }
+
+    @Deprecated
+    public static RuntimeException propagate(Throwable th) {
+        throwIfUnchecked(th);
+        throw new RuntimeException(th);
+    }
+
+    @Deprecated
+    public static <X extends Throwable> void propagateIfInstanceOf(Throwable th, Class<X> cls) throws Throwable {
+        if (th != null) {
+            throwIfInstanceOf(th, cls);
+        }
+    }
+
+    @Deprecated
+    public static void propagateIfPossible(Throwable th) {
+        if (th != null) {
+            throwIfUnchecked(th);
+        }
+    }
+
+    public static <X extends Throwable> void throwIfInstanceOf(Throwable th, Class<X> cls) throws Throwable {
+        Preconditions.checkNotNull(th);
+        if (cls.isInstance(th)) {
+            throw cls.cast(th);
+        }
+    }
+
+    public static void throwIfUnchecked(Throwable th) {
+        Preconditions.checkNotNull(th);
+        if (th instanceof RuntimeException) {
+            throw ((RuntimeException) th);
+        }
+        if (th instanceof Error) {
+            throw ((Error) th);
+        }
+    }
+
+    public static <X extends Throwable> void propagateIfPossible(Throwable th, Class<X> cls) throws Throwable {
+        propagateIfInstanceOf(th, cls);
+        propagateIfPossible(th);
+    }
+
+    public static <X1 extends Throwable, X2 extends Throwable> void propagateIfPossible(Throwable th, Class<X1> cls, Class<X2> cls2) throws Throwable, Throwable {
+        Preconditions.checkNotNull(cls2);
+        propagateIfInstanceOf(th, cls);
+        propagateIfPossible(th, cls2);
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/a.java

@@ -0,0 +1,72 @@
+package com.applovin.exoplayer2.common.base;
+
+import java.util.Collections;
+import java.util.Set;
+
+/* loaded from: classes.dex */
+final class a extends Optional {
+    static final a a = new a();
+
+    private a() {
+    }
+
+    public static Optional a() {
+        return a;
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public Set asSet() {
+        return Collections.emptySet();
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public boolean equals(Object obj) {
+        return obj == this;
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public Object get() {
+        throw new IllegalStateException("Optional.get() cannot be called on an absent value");
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public int hashCode() {
+        return 2040732332;
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public boolean isPresent() {
+        return false;
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public Object or(Object obj) {
+        return Preconditions.checkNotNull(obj, "use Optional.orNull() instead of Optional.or(null)");
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public Object orNull() {
+        return null;
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public String toString() {
+        return "Optional.absent()";
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public Optional transform(Function function) {
+        Preconditions.checkNotNull(function);
+        return Optional.absent();
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public Optional or(Optional optional) {
+        return (Optional) Preconditions.checkNotNull(optional);
+    }
+
+    @Override // com.applovin.exoplayer2.common.base.Optional
+    public Object or(Supplier supplier) {
+        return Preconditions.checkNotNull(supplier.get(), "use Optional.orNull() instead of a Supplier that returns null");
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/b.java

@@ -0,0 +1,81 @@
+package com.applovin.exoplayer2.common.base;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/* loaded from: classes.dex */
+abstract class b implements Iterator {
+    private EnumC0010b a = EnumC0010b.NOT_READY;
+    private Object b;
+
+    public static /* synthetic */ class a {
+        static final /* synthetic */ int[] a;
+
+        static {
+            int[] iArr = new int[EnumC0010b.values().length];
+            a = iArr;
+            try {
+                iArr[EnumC0010b.READY.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                a[EnumC0010b.DONE.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+        }
+    }
+
+    /* renamed from: com.applovin.exoplayer2.common.base.b$b, reason: collision with other inner class name */
+    public enum EnumC0010b {
+        READY,
+        NOT_READY,
+        DONE,
+        FAILED
+    }
+
+    private boolean c() {
+        this.a = EnumC0010b.FAILED;
+        this.b = a();
+        if (this.a == EnumC0010b.DONE) {
+            return false;
+        }
+        this.a = EnumC0010b.READY;
+        return true;
+    }
+
+    public abstract Object a();
+
+    public final Object b() {
+        this.a = EnumC0010b.DONE;
+        return null;
+    }
+
+    @Override // java.util.Iterator
+    public final boolean hasNext() {
+        Preconditions.checkState(this.a != EnumC0010b.FAILED);
+        int i = a.a[this.a.ordinal()];
+        if (i == 1) {
+            return true;
+        }
+        if (i != 2) {
+            return c();
+        }
+        return false;
+    }
+
+    @Override // java.util.Iterator
+    public final Object next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        this.a = EnumC0010b.NOT_READY;
+        Object obj = this.b;
+        this.b = null;
+        return obj;
+    }
+
+    @Override // java.util.Iterator
+    public final void remove() {
+        throw new UnsupportedOperationException();
+    }
+}

decompiled/sources/com/applovin/exoplayer2/common/base/c.java

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

decompiled/sources/com/applovin/exoplayer2/common/base/d.java

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