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/fyber/inneractive/sdk/protobuf/FieldType.java

@@ -0,0 +1,361 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.util.List;
+
+/* JADX WARN: Enum visitor error
+jadx.core.utils.exceptions.JadxRuntimeException: Init of enum field 'DOUBLE' uses external variables
+	at jadx.core.dex.visitors.EnumVisitor.createEnumFieldByConstructor(EnumVisitor.java:451)
+	at jadx.core.dex.visitors.EnumVisitor.processEnumFieldByField(EnumVisitor.java:372)
+	at jadx.core.dex.visitors.EnumVisitor.processEnumFieldByWrappedInsn(EnumVisitor.java:337)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromFilledArray(EnumVisitor.java:322)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromInsn(EnumVisitor.java:262)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromInvoke(EnumVisitor.java:293)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromInsn(EnumVisitor.java:266)
+	at jadx.core.dex.visitors.EnumVisitor.convertToEnum(EnumVisitor.java:151)
+	at jadx.core.dex.visitors.EnumVisitor.visit(EnumVisitor.java:100)
+ */
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* loaded from: classes2.dex */
+public final class FieldType {
+    private static final /* synthetic */ FieldType[] $VALUES;
+    public static final FieldType BOOL;
+    public static final FieldType BOOL_LIST;
+    public static final FieldType BOOL_LIST_PACKED;
+    public static final FieldType BYTES;
+    public static final FieldType BYTES_LIST;
+    public static final FieldType DOUBLE;
+    public static final FieldType DOUBLE_LIST;
+    public static final FieldType DOUBLE_LIST_PACKED;
+    private static final Type[] EMPTY_TYPES;
+    public static final FieldType ENUM;
+    public static final FieldType ENUM_LIST;
+    public static final FieldType ENUM_LIST_PACKED;
+    public static final FieldType FIXED32;
+    public static final FieldType FIXED32_LIST;
+    public static final FieldType FIXED32_LIST_PACKED;
+    public static final FieldType FIXED64;
+    public static final FieldType FIXED64_LIST;
+    public static final FieldType FIXED64_LIST_PACKED;
+    public static final FieldType FLOAT;
+    public static final FieldType FLOAT_LIST;
+    public static final FieldType FLOAT_LIST_PACKED;
+    public static final FieldType GROUP;
+    public static final FieldType GROUP_LIST;
+    public static final FieldType INT32;
+    public static final FieldType INT32_LIST;
+    public static final FieldType INT32_LIST_PACKED;
+    public static final FieldType INT64;
+    public static final FieldType INT64_LIST;
+    public static final FieldType INT64_LIST_PACKED;
+    public static final FieldType MAP;
+    public static final FieldType MESSAGE;
+    public static final FieldType MESSAGE_LIST;
+    public static final FieldType SFIXED32;
+    public static final FieldType SFIXED32_LIST;
+    public static final FieldType SFIXED32_LIST_PACKED;
+    public static final FieldType SFIXED64;
+    public static final FieldType SFIXED64_LIST;
+    public static final FieldType SFIXED64_LIST_PACKED;
+    public static final FieldType SINT32;
+    public static final FieldType SINT32_LIST;
+    public static final FieldType SINT32_LIST_PACKED;
+    public static final FieldType SINT64;
+    public static final FieldType SINT64_LIST;
+    public static final FieldType SINT64_LIST_PACKED;
+    public static final FieldType STRING;
+    public static final FieldType STRING_LIST;
+    public static final FieldType UINT32;
+    public static final FieldType UINT32_LIST;
+    public static final FieldType UINT32_LIST_PACKED;
+    public static final FieldType UINT64;
+    public static final FieldType UINT64_LIST;
+    public static final FieldType UINT64_LIST_PACKED;
+    private static final FieldType[] VALUES;
+    private final b collection;
+    private final Class<?> elementType;
+    private final int id;
+    private final JavaType javaType;
+    private final boolean primitiveScalar;
+
+    public static /* synthetic */ class a {
+        public static final /* synthetic */ int[] a;
+        public static final /* synthetic */ int[] b;
+
+        static {
+            int[] iArr = new int[JavaType.values().length];
+            b = iArr;
+            try {
+                iArr[JavaType.BYTE_STRING.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                b[JavaType.MESSAGE.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                b[JavaType.STRING.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            int[] iArr2 = new int[b.values().length];
+            a = iArr2;
+            try {
+                iArr2[b.MAP.ordinal()] = 1;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                a[b.VECTOR.ordinal()] = 2;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                a[b.SCALAR.ordinal()] = 3;
+            } catch (NoSuchFieldError unused6) {
+            }
+        }
+    }
+
+    public enum b {
+        SCALAR(false),
+        VECTOR(true),
+        PACKED_VECTOR(true),
+        MAP(false);
+
+        private final boolean isList;
+
+        b(boolean z) {
+            this.isList = z;
+        }
+
+        public final boolean e() {
+            return this.isList;
+        }
+    }
+
+    private static /* synthetic */ FieldType[] $values() {
+        return new FieldType[]{DOUBLE, FLOAT, INT64, UINT64, INT32, FIXED64, FIXED32, BOOL, STRING, MESSAGE, BYTES, UINT32, ENUM, SFIXED32, SFIXED64, SINT32, SINT64, GROUP, DOUBLE_LIST, FLOAT_LIST, INT64_LIST, UINT64_LIST, INT32_LIST, FIXED64_LIST, FIXED32_LIST, BOOL_LIST, STRING_LIST, MESSAGE_LIST, BYTES_LIST, UINT32_LIST, ENUM_LIST, SFIXED32_LIST, SFIXED64_LIST, SINT32_LIST, SINT64_LIST, DOUBLE_LIST_PACKED, FLOAT_LIST_PACKED, INT64_LIST_PACKED, UINT64_LIST_PACKED, INT32_LIST_PACKED, FIXED64_LIST_PACKED, FIXED32_LIST_PACKED, BOOL_LIST_PACKED, UINT32_LIST_PACKED, ENUM_LIST_PACKED, SFIXED32_LIST_PACKED, SFIXED64_LIST_PACKED, SINT32_LIST_PACKED, SINT64_LIST_PACKED, GROUP_LIST, MAP};
+    }
+
+    static {
+        b bVar = b.SCALAR;
+        JavaType javaType = JavaType.DOUBLE;
+        DOUBLE = new FieldType("DOUBLE", 0, 0, bVar, javaType);
+        JavaType javaType2 = JavaType.FLOAT;
+        FLOAT = new FieldType("FLOAT", 1, 1, bVar, javaType2);
+        JavaType javaType3 = JavaType.LONG;
+        INT64 = new FieldType("INT64", 2, 2, bVar, javaType3);
+        UINT64 = new FieldType("UINT64", 3, 3, bVar, javaType3);
+        JavaType javaType4 = JavaType.INT;
+        INT32 = new FieldType("INT32", 4, 4, bVar, javaType4);
+        FIXED64 = new FieldType("FIXED64", 5, 5, bVar, javaType3);
+        FIXED32 = new FieldType("FIXED32", 6, 6, bVar, javaType4);
+        JavaType javaType5 = JavaType.BOOLEAN;
+        BOOL = new FieldType("BOOL", 7, 7, bVar, javaType5);
+        JavaType javaType6 = JavaType.STRING;
+        STRING = new FieldType("STRING", 8, 8, bVar, javaType6);
+        JavaType javaType7 = JavaType.MESSAGE;
+        MESSAGE = new FieldType("MESSAGE", 9, 9, bVar, javaType7);
+        JavaType javaType8 = JavaType.BYTE_STRING;
+        BYTES = new FieldType("BYTES", 10, 10, bVar, javaType8);
+        UINT32 = new FieldType("UINT32", 11, 11, bVar, javaType4);
+        JavaType javaType9 = JavaType.ENUM;
+        ENUM = new FieldType("ENUM", 12, 12, bVar, javaType9);
+        SFIXED32 = new FieldType("SFIXED32", 13, 13, bVar, javaType4);
+        SFIXED64 = new FieldType("SFIXED64", 14, 14, bVar, javaType3);
+        SINT32 = new FieldType("SINT32", 15, 15, bVar, javaType4);
+        SINT64 = new FieldType("SINT64", 16, 16, bVar, javaType3);
+        GROUP = new FieldType("GROUP", 17, 17, bVar, javaType7);
+        b bVar2 = b.VECTOR;
+        DOUBLE_LIST = new FieldType("DOUBLE_LIST", 18, 18, bVar2, javaType);
+        FLOAT_LIST = new FieldType("FLOAT_LIST", 19, 19, bVar2, javaType2);
+        INT64_LIST = new FieldType("INT64_LIST", 20, 20, bVar2, javaType3);
+        UINT64_LIST = new FieldType("UINT64_LIST", 21, 21, bVar2, javaType3);
+        INT32_LIST = new FieldType("INT32_LIST", 22, 22, bVar2, javaType4);
+        FIXED64_LIST = new FieldType("FIXED64_LIST", 23, 23, bVar2, javaType3);
+        FIXED32_LIST = new FieldType("FIXED32_LIST", 24, 24, bVar2, javaType4);
+        BOOL_LIST = new FieldType("BOOL_LIST", 25, 25, bVar2, javaType5);
+        STRING_LIST = new FieldType("STRING_LIST", 26, 26, bVar2, javaType6);
+        MESSAGE_LIST = new FieldType("MESSAGE_LIST", 27, 27, bVar2, javaType7);
+        BYTES_LIST = new FieldType("BYTES_LIST", 28, 28, bVar2, javaType8);
+        UINT32_LIST = new FieldType("UINT32_LIST", 29, 29, bVar2, javaType4);
+        ENUM_LIST = new FieldType("ENUM_LIST", 30, 30, bVar2, javaType9);
+        SFIXED32_LIST = new FieldType("SFIXED32_LIST", 31, 31, bVar2, javaType4);
+        SFIXED64_LIST = new FieldType("SFIXED64_LIST", 32, 32, bVar2, javaType3);
+        SINT32_LIST = new FieldType("SINT32_LIST", 33, 33, bVar2, javaType4);
+        SINT64_LIST = new FieldType("SINT64_LIST", 34, 34, bVar2, javaType3);
+        b bVar3 = b.PACKED_VECTOR;
+        DOUBLE_LIST_PACKED = new FieldType("DOUBLE_LIST_PACKED", 35, 35, bVar3, javaType);
+        FLOAT_LIST_PACKED = new FieldType("FLOAT_LIST_PACKED", 36, 36, bVar3, javaType2);
+        INT64_LIST_PACKED = new FieldType("INT64_LIST_PACKED", 37, 37, bVar3, javaType3);
+        UINT64_LIST_PACKED = new FieldType("UINT64_LIST_PACKED", 38, 38, bVar3, javaType3);
+        INT32_LIST_PACKED = new FieldType("INT32_LIST_PACKED", 39, 39, bVar3, javaType4);
+        FIXED64_LIST_PACKED = new FieldType("FIXED64_LIST_PACKED", 40, 40, bVar3, javaType3);
+        FIXED32_LIST_PACKED = new FieldType("FIXED32_LIST_PACKED", 41, 41, bVar3, javaType4);
+        BOOL_LIST_PACKED = new FieldType("BOOL_LIST_PACKED", 42, 42, bVar3, javaType5);
+        UINT32_LIST_PACKED = new FieldType("UINT32_LIST_PACKED", 43, 43, bVar3, javaType4);
+        ENUM_LIST_PACKED = new FieldType("ENUM_LIST_PACKED", 44, 44, bVar3, javaType9);
+        SFIXED32_LIST_PACKED = new FieldType("SFIXED32_LIST_PACKED", 45, 45, bVar3, javaType4);
+        SFIXED64_LIST_PACKED = new FieldType("SFIXED64_LIST_PACKED", 46, 46, bVar3, javaType3);
+        SINT32_LIST_PACKED = new FieldType("SINT32_LIST_PACKED", 47, 47, bVar3, javaType4);
+        SINT64_LIST_PACKED = new FieldType("SINT64_LIST_PACKED", 48, 48, bVar3, javaType3);
+        GROUP_LIST = new FieldType("GROUP_LIST", 49, 49, bVar2, javaType7);
+        MAP = new FieldType("MAP", 50, 50, b.MAP, JavaType.VOID);
+        $VALUES = $values();
+        EMPTY_TYPES = new Type[0];
+        FieldType[] values = values();
+        VALUES = new FieldType[values.length];
+        for (FieldType fieldType : values) {
+            VALUES[fieldType.id] = fieldType;
+        }
+    }
+
+    private FieldType(String str, int i, int i2, b bVar, JavaType javaType) {
+        int i3;
+        this.id = i2;
+        this.collection = bVar;
+        this.javaType = javaType;
+        int i4 = a.a[bVar.ordinal()];
+        if (i4 == 1) {
+            this.elementType = javaType.getBoxedType();
+        } else if (i4 != 2) {
+            this.elementType = null;
+        } else {
+            this.elementType = javaType.getBoxedType();
+        }
+        this.primitiveScalar = (bVar != b.SCALAR || (i3 = a.b[javaType.ordinal()]) == 1 || i3 == 2 || i3 == 3) ? false : true;
+    }
+
+    public static FieldType forId(int i) {
+        if (i < 0) {
+            return null;
+        }
+        FieldType[] fieldTypeArr = VALUES;
+        if (i >= fieldTypeArr.length) {
+            return null;
+        }
+        return fieldTypeArr[i];
+    }
+
+    private static Type getGenericSuperList(Class<?> cls) {
+        for (Type type : cls.getGenericInterfaces()) {
+            if ((type instanceof ParameterizedType) && List.class.isAssignableFrom((Class) ((ParameterizedType) type).getRawType())) {
+                return type;
+            }
+        }
+        Type genericSuperclass = cls.getGenericSuperclass();
+        if ((genericSuperclass instanceof ParameterizedType) && List.class.isAssignableFrom((Class) ((ParameterizedType) genericSuperclass).getRawType())) {
+            return genericSuperclass;
+        }
+        return null;
+    }
+
+    private boolean isValidForList(Field field) {
+        Class<?> type = field.getType();
+        if (!this.javaType.getType().isAssignableFrom(type)) {
+            return false;
+        }
+        Type[] typeArr = EMPTY_TYPES;
+        if (field.getGenericType() instanceof ParameterizedType) {
+            typeArr = ((ParameterizedType) field.getGenericType()).getActualTypeArguments();
+        }
+        Type listParameter = getListParameter(type, typeArr);
+        if (listParameter instanceof Class) {
+            return this.elementType.isAssignableFrom((Class) listParameter);
+        }
+        return true;
+    }
+
+    public static FieldType valueOf(String str) {
+        return (FieldType) Enum.valueOf(FieldType.class, str);
+    }
+
+    public static FieldType[] values() {
+        return (FieldType[]) $VALUES.clone();
+    }
+
+    public JavaType getJavaType() {
+        return this.javaType;
+    }
+
+    public int id() {
+        return this.id;
+    }
+
+    public boolean isList() {
+        return this.collection.e();
+    }
+
+    public boolean isMap() {
+        return this.collection == b.MAP;
+    }
+
+    public boolean isPacked() {
+        return b.PACKED_VECTOR.equals(this.collection);
+    }
+
+    public boolean isPrimitiveScalar() {
+        return this.primitiveScalar;
+    }
+
+    public boolean isScalar() {
+        return this.collection == b.SCALAR;
+    }
+
+    public boolean isValidForField(Field field) {
+        return b.VECTOR.equals(this.collection) ? isValidForList(field) : this.javaType.getType().isAssignableFrom(field.getType());
+    }
+
+    private static Type getListParameter(Class<?> cls, Type[] typeArr) {
+        while (true) {
+            int i = 0;
+            if (cls != List.class) {
+                Type genericSuperList = getGenericSuperList(cls);
+                if (genericSuperList instanceof ParameterizedType) {
+                    ParameterizedType parameterizedType = (ParameterizedType) genericSuperList;
+                    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+                    for (int i2 = 0; i2 < actualTypeArguments.length; i2++) {
+                        Type type = actualTypeArguments[i2];
+                        if (type instanceof TypeVariable) {
+                            TypeVariable<Class<?>>[] typeParameters = cls.getTypeParameters();
+                            if (typeArr.length == typeParameters.length) {
+                                for (int i3 = 0; i3 < typeParameters.length; i3++) {
+                                    if (type == typeParameters[i3]) {
+                                        actualTypeArguments[i2] = typeArr[i3];
+                                    }
+                                }
+                                throw new RuntimeException("Unable to find replacement for " + type);
+                            }
+                            throw new RuntimeException("Type array mismatch");
+                        }
+                    }
+                    cls = (Class) parameterizedType.getRawType();
+                    typeArr = actualTypeArguments;
+                } else {
+                    typeArr = EMPTY_TYPES;
+                    Class<?>[] interfaces = cls.getInterfaces();
+                    int length = interfaces.length;
+                    while (true) {
+                        if (i < length) {
+                            Class<?> cls2 = interfaces[i];
+                            if (List.class.isAssignableFrom(cls2)) {
+                                cls = cls2;
+                                break;
+                            }
+                            i++;
+                        } else {
+                            cls = cls.getSuperclass();
+                            break;
+                        }
+                    }
+                }
+            } else {
+                if (typeArr.length == 1) {
+                    return typeArr[0];
+                }
+                throw new RuntimeException("Unable to identify parameter type for List<T>");
+            }
+        }
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/JavaType.java

@@ -0,0 +1,80 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* JADX WARN: Enum visitor error
+jadx.core.utils.exceptions.JadxRuntimeException: Init of enum field 'INT' uses external variables
+	at jadx.core.dex.visitors.EnumVisitor.createEnumFieldByConstructor(EnumVisitor.java:451)
+	at jadx.core.dex.visitors.EnumVisitor.processEnumFieldByField(EnumVisitor.java:372)
+	at jadx.core.dex.visitors.EnumVisitor.processEnumFieldByWrappedInsn(EnumVisitor.java:337)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromFilledArray(EnumVisitor.java:322)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromInsn(EnumVisitor.java:262)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromInvoke(EnumVisitor.java:293)
+	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromInsn(EnumVisitor.java:266)
+	at jadx.core.dex.visitors.EnumVisitor.convertToEnum(EnumVisitor.java:151)
+	at jadx.core.dex.visitors.EnumVisitor.visit(EnumVisitor.java:100)
+ */
+/* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+/* loaded from: classes2.dex */
+public final class JavaType {
+    private static final /* synthetic */ JavaType[] $VALUES;
+    public static final JavaType BOOLEAN;
+    public static final JavaType BYTE_STRING;
+    public static final JavaType DOUBLE;
+    public static final JavaType ENUM;
+    public static final JavaType FLOAT;
+    public static final JavaType INT;
+    public static final JavaType LONG;
+    public static final JavaType MESSAGE;
+    public static final JavaType STRING;
+    public static final JavaType VOID = new JavaType("VOID", 0, Void.class, Void.class, null);
+    private final Class<?> boxedType;
+    private final Object defaultDefault;
+    private final Class<?> type;
+
+    private static /* synthetic */ JavaType[] $values() {
+        return new JavaType[]{VOID, INT, LONG, FLOAT, DOUBLE, BOOLEAN, STRING, BYTE_STRING, ENUM, MESSAGE};
+    }
+
+    static {
+        Class cls = Integer.TYPE;
+        INT = new JavaType("INT", 1, cls, Integer.class, 0);
+        LONG = new JavaType("LONG", 2, Long.TYPE, Long.class, 0L);
+        FLOAT = new JavaType("FLOAT", 3, Float.TYPE, Float.class, Float.valueOf(0.0f));
+        DOUBLE = new JavaType("DOUBLE", 4, Double.TYPE, Double.class, Double.valueOf(0.0d));
+        BOOLEAN = new JavaType("BOOLEAN", 5, Boolean.TYPE, Boolean.class, Boolean.FALSE);
+        STRING = new JavaType("STRING", 6, String.class, String.class, "");
+        BYTE_STRING = new JavaType("BYTE_STRING", 7, i.class, i.class, i.b);
+        ENUM = new JavaType("ENUM", 8, cls, Integer.class, null);
+        MESSAGE = new JavaType("MESSAGE", 9, Object.class, Object.class, null);
+        $VALUES = $values();
+    }
+
+    private JavaType(String str, int i, Class cls, Class cls2, Object obj) {
+        this.type = cls;
+        this.boxedType = cls2;
+        this.defaultDefault = obj;
+    }
+
+    public static JavaType valueOf(String str) {
+        return (JavaType) Enum.valueOf(JavaType.class, str);
+    }
+
+    public static JavaType[] values() {
+        return (JavaType[]) $VALUES.clone();
+    }
+
+    public Class<?> getBoxedType() {
+        return this.boxedType;
+    }
+
+    public Object getDefaultDefault() {
+        return this.defaultDefault;
+    }
+
+    public Class<?> getType() {
+        return this.type;
+    }
+
+    public boolean isValidType(Class<?> cls) {
+        return this.type.isAssignableFrom(cls);
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/StringValue.java

@@ -0,0 +1,198 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes2.dex */
+public final class StringValue extends GeneratedMessageLite<StringValue, b> implements p0 {
+    private static final StringValue DEFAULT_INSTANCE;
+    private static volatile w0<StringValue> PARSER = null;
+    public static final int VALUE_FIELD_NUMBER = 1;
+    private String value_ = "";
+
+    public static /* synthetic */ class a {
+        public static final /* synthetic */ int[] a;
+
+        static {
+            int[] iArr = new int[GeneratedMessageLite.f.values().length];
+            a = iArr;
+            try {
+                iArr[GeneratedMessageLite.f.NEW_MUTABLE_INSTANCE.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                a[GeneratedMessageLite.f.NEW_BUILDER.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                a[GeneratedMessageLite.f.BUILD_MESSAGE_INFO.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                a[GeneratedMessageLite.f.GET_DEFAULT_INSTANCE.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                a[GeneratedMessageLite.f.GET_PARSER.ordinal()] = 5;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                a[GeneratedMessageLite.f.GET_MEMOIZED_IS_INITIALIZED.ordinal()] = 6;
+            } catch (NoSuchFieldError unused6) {
+            }
+            try {
+                a[GeneratedMessageLite.f.SET_MEMOIZED_IS_INITIALIZED.ordinal()] = 7;
+            } catch (NoSuchFieldError unused7) {
+            }
+        }
+    }
+
+    public static final class b extends GeneratedMessageLite.b<StringValue, b> implements p0 {
+        public b() {
+            super(StringValue.DEFAULT_INSTANCE);
+        }
+    }
+
+    static {
+        StringValue stringValue = new StringValue();
+        DEFAULT_INSTANCE = stringValue;
+        GeneratedMessageLite.registerDefaultInstance(StringValue.class, stringValue);
+    }
+
+    private StringValue() {
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void clearValue() {
+        this.value_ = getDefaultInstance().getValue();
+    }
+
+    public static StringValue getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+    }
+
+    public static b newBuilder() {
+        return DEFAULT_INSTANCE.createBuilder();
+    }
+
+    public static StringValue of(String str) {
+        b newBuilder = newBuilder();
+        newBuilder.c();
+        ((StringValue) newBuilder.b).setValue(str);
+        return newBuilder.a();
+    }
+
+    public static StringValue parseDelimitedFrom(InputStream inputStream) throws IOException {
+        return (StringValue) GeneratedMessageLite.parseDelimitedFrom(DEFAULT_INSTANCE, inputStream);
+    }
+
+    public static StringValue parseFrom(ByteBuffer byteBuffer) throws z {
+        return (StringValue) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, byteBuffer);
+    }
+
+    public static w0<StringValue> parser() {
+        return DEFAULT_INSTANCE.getParserForType();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void setValue(String str) {
+        str.getClass();
+        this.value_ = str;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void setValueBytes(i iVar) {
+        iVar.getClass();
+        com.fyber.inneractive.sdk.protobuf.a.checkByteStringIsUtf8(iVar);
+        this.value_ = iVar.i();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite
+    public final Object dynamicMethod(GeneratedMessageLite.f fVar, Object obj, Object obj2) {
+        switch (a.a[fVar.ordinal()]) {
+            case 1:
+                return new StringValue();
+            case 2:
+                return new b();
+            case 3:
+                return GeneratedMessageLite.newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0001\u0000\u0000\u0001\u0001\u0001\u0000\u0000\u0000\u0001Ȉ", new Object[]{"value_"});
+            case 4:
+                return DEFAULT_INSTANCE;
+            case 5:
+                w0<StringValue> w0Var = PARSER;
+                if (w0Var == null) {
+                    synchronized (StringValue.class) {
+                        try {
+                            w0Var = PARSER;
+                            if (w0Var == null) {
+                                w0Var = new GeneratedMessageLite.c<>(DEFAULT_INSTANCE);
+                                PARSER = w0Var;
+                            }
+                        } finally {
+                        }
+                    }
+                }
+                return w0Var;
+            case 6:
+                return (byte) 1;
+            case 7:
+                return null;
+            default:
+                throw new UnsupportedOperationException();
+        }
+    }
+
+    public String getValue() {
+        return this.value_;
+    }
+
+    public i getValueBytes() {
+        return i.a(this.value_);
+    }
+
+    public static b newBuilder(StringValue stringValue) {
+        return DEFAULT_INSTANCE.createBuilder(stringValue);
+    }
+
+    public static StringValue parseDelimitedFrom(InputStream inputStream, q qVar) throws IOException {
+        return (StringValue) GeneratedMessageLite.parseDelimitedFrom(DEFAULT_INSTANCE, inputStream, qVar);
+    }
+
+    public static StringValue parseFrom(ByteBuffer byteBuffer, q qVar) throws z {
+        return (StringValue) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, byteBuffer, qVar);
+    }
+
+    public static StringValue parseFrom(i iVar) throws z {
+        return (StringValue) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, iVar);
+    }
+
+    public static StringValue parseFrom(i iVar, q qVar) throws z {
+        return (StringValue) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, iVar, qVar);
+    }
+
+    public static StringValue parseFrom(byte[] bArr) throws z {
+        return (StringValue) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, bArr);
+    }
+
+    public static StringValue parseFrom(byte[] bArr, q qVar) throws z {
+        return (StringValue) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, bArr, qVar);
+    }
+
+    public static StringValue parseFrom(InputStream inputStream) throws IOException {
+        return (StringValue) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, inputStream);
+    }
+
+    public static StringValue parseFrom(InputStream inputStream, q qVar) throws IOException {
+        return (StringValue) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, inputStream, qVar);
+    }
+
+    public static StringValue parseFrom(j jVar) throws IOException {
+        return (StringValue) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, jVar);
+    }
+
+    public static StringValue parseFrom(j jVar, q qVar) throws IOException {
+        return (StringValue) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, jVar, qVar);
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/UInt32Value.java

@@ -0,0 +1,186 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes2.dex */
+public final class UInt32Value extends GeneratedMessageLite<UInt32Value, b> implements p0 {
+    private static final UInt32Value DEFAULT_INSTANCE;
+    private static volatile w0<UInt32Value> PARSER = null;
+    public static final int VALUE_FIELD_NUMBER = 1;
+    private int value_;
+
+    public static /* synthetic */ class a {
+        public static final /* synthetic */ int[] a;
+
+        static {
+            int[] iArr = new int[GeneratedMessageLite.f.values().length];
+            a = iArr;
+            try {
+                iArr[GeneratedMessageLite.f.NEW_MUTABLE_INSTANCE.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                a[GeneratedMessageLite.f.NEW_BUILDER.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                a[GeneratedMessageLite.f.BUILD_MESSAGE_INFO.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                a[GeneratedMessageLite.f.GET_DEFAULT_INSTANCE.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                a[GeneratedMessageLite.f.GET_PARSER.ordinal()] = 5;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                a[GeneratedMessageLite.f.GET_MEMOIZED_IS_INITIALIZED.ordinal()] = 6;
+            } catch (NoSuchFieldError unused6) {
+            }
+            try {
+                a[GeneratedMessageLite.f.SET_MEMOIZED_IS_INITIALIZED.ordinal()] = 7;
+            } catch (NoSuchFieldError unused7) {
+            }
+        }
+    }
+
+    public static final class b extends GeneratedMessageLite.b<UInt32Value, b> implements p0 {
+        public b() {
+            super(UInt32Value.DEFAULT_INSTANCE);
+        }
+    }
+
+    static {
+        UInt32Value uInt32Value = new UInt32Value();
+        DEFAULT_INSTANCE = uInt32Value;
+        GeneratedMessageLite.registerDefaultInstance(UInt32Value.class, uInt32Value);
+    }
+
+    private UInt32Value() {
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void clearValue() {
+        this.value_ = 0;
+    }
+
+    public static UInt32Value getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+    }
+
+    public static b newBuilder() {
+        return DEFAULT_INSTANCE.createBuilder();
+    }
+
+    public static UInt32Value of(int i) {
+        b newBuilder = newBuilder();
+        newBuilder.c();
+        ((UInt32Value) newBuilder.b).setValue(i);
+        return newBuilder.a();
+    }
+
+    public static UInt32Value parseDelimitedFrom(InputStream inputStream) throws IOException {
+        return (UInt32Value) GeneratedMessageLite.parseDelimitedFrom(DEFAULT_INSTANCE, inputStream);
+    }
+
+    public static UInt32Value parseFrom(ByteBuffer byteBuffer) throws z {
+        return (UInt32Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, byteBuffer);
+    }
+
+    public static w0<UInt32Value> parser() {
+        return DEFAULT_INSTANCE.getParserForType();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void setValue(int i) {
+        this.value_ = i;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite
+    public final Object dynamicMethod(GeneratedMessageLite.f fVar, Object obj, Object obj2) {
+        switch (a.a[fVar.ordinal()]) {
+            case 1:
+                return new UInt32Value();
+            case 2:
+                return new b();
+            case 3:
+                return GeneratedMessageLite.newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0001\u0000\u0000\u0001\u0001\u0001\u0000\u0000\u0000\u0001\u000b", new Object[]{"value_"});
+            case 4:
+                return DEFAULT_INSTANCE;
+            case 5:
+                w0<UInt32Value> w0Var = PARSER;
+                if (w0Var == null) {
+                    synchronized (UInt32Value.class) {
+                        try {
+                            w0Var = PARSER;
+                            if (w0Var == null) {
+                                w0Var = new GeneratedMessageLite.c<>(DEFAULT_INSTANCE);
+                                PARSER = w0Var;
+                            }
+                        } finally {
+                        }
+                    }
+                }
+                return w0Var;
+            case 6:
+                return (byte) 1;
+            case 7:
+                return null;
+            default:
+                throw new UnsupportedOperationException();
+        }
+    }
+
+    public int getValue() {
+        return this.value_;
+    }
+
+    public static b newBuilder(UInt32Value uInt32Value) {
+        return DEFAULT_INSTANCE.createBuilder(uInt32Value);
+    }
+
+    public static UInt32Value parseDelimitedFrom(InputStream inputStream, q qVar) throws IOException {
+        return (UInt32Value) GeneratedMessageLite.parseDelimitedFrom(DEFAULT_INSTANCE, inputStream, qVar);
+    }
+
+    public static UInt32Value parseFrom(ByteBuffer byteBuffer, q qVar) throws z {
+        return (UInt32Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, byteBuffer, qVar);
+    }
+
+    public static UInt32Value parseFrom(i iVar) throws z {
+        return (UInt32Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, iVar);
+    }
+
+    public static UInt32Value parseFrom(i iVar, q qVar) throws z {
+        return (UInt32Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, iVar, qVar);
+    }
+
+    public static UInt32Value parseFrom(byte[] bArr) throws z {
+        return (UInt32Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, bArr);
+    }
+
+    public static UInt32Value parseFrom(byte[] bArr, q qVar) throws z {
+        return (UInt32Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, bArr, qVar);
+    }
+
+    public static UInt32Value parseFrom(InputStream inputStream) throws IOException {
+        return (UInt32Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, inputStream);
+    }
+
+    public static UInt32Value parseFrom(InputStream inputStream, q qVar) throws IOException {
+        return (UInt32Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, inputStream, qVar);
+    }
+
+    public static UInt32Value parseFrom(j jVar) throws IOException {
+        return (UInt32Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, jVar);
+    }
+
+    public static UInt32Value parseFrom(j jVar, q qVar) throws IOException {
+        return (UInt32Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, jVar, qVar);
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/UInt64Value.java

@@ -0,0 +1,186 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes2.dex */
+public final class UInt64Value extends GeneratedMessageLite<UInt64Value, b> implements p0 {
+    private static final UInt64Value DEFAULT_INSTANCE;
+    private static volatile w0<UInt64Value> PARSER = null;
+    public static final int VALUE_FIELD_NUMBER = 1;
+    private long value_;
+
+    public static /* synthetic */ class a {
+        public static final /* synthetic */ int[] a;
+
+        static {
+            int[] iArr = new int[GeneratedMessageLite.f.values().length];
+            a = iArr;
+            try {
+                iArr[GeneratedMessageLite.f.NEW_MUTABLE_INSTANCE.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                a[GeneratedMessageLite.f.NEW_BUILDER.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                a[GeneratedMessageLite.f.BUILD_MESSAGE_INFO.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                a[GeneratedMessageLite.f.GET_DEFAULT_INSTANCE.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                a[GeneratedMessageLite.f.GET_PARSER.ordinal()] = 5;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                a[GeneratedMessageLite.f.GET_MEMOIZED_IS_INITIALIZED.ordinal()] = 6;
+            } catch (NoSuchFieldError unused6) {
+            }
+            try {
+                a[GeneratedMessageLite.f.SET_MEMOIZED_IS_INITIALIZED.ordinal()] = 7;
+            } catch (NoSuchFieldError unused7) {
+            }
+        }
+    }
+
+    public static final class b extends GeneratedMessageLite.b<UInt64Value, b> implements p0 {
+        public b() {
+            super(UInt64Value.DEFAULT_INSTANCE);
+        }
+    }
+
+    static {
+        UInt64Value uInt64Value = new UInt64Value();
+        DEFAULT_INSTANCE = uInt64Value;
+        GeneratedMessageLite.registerDefaultInstance(UInt64Value.class, uInt64Value);
+    }
+
+    private UInt64Value() {
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void clearValue() {
+        this.value_ = 0L;
+    }
+
+    public static UInt64Value getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+    }
+
+    public static b newBuilder() {
+        return DEFAULT_INSTANCE.createBuilder();
+    }
+
+    public static UInt64Value of(long j) {
+        b newBuilder = newBuilder();
+        newBuilder.c();
+        ((UInt64Value) newBuilder.b).setValue(j);
+        return newBuilder.a();
+    }
+
+    public static UInt64Value parseDelimitedFrom(InputStream inputStream) throws IOException {
+        return (UInt64Value) GeneratedMessageLite.parseDelimitedFrom(DEFAULT_INSTANCE, inputStream);
+    }
+
+    public static UInt64Value parseFrom(ByteBuffer byteBuffer) throws z {
+        return (UInt64Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, byteBuffer);
+    }
+
+    public static w0<UInt64Value> parser() {
+        return DEFAULT_INSTANCE.getParserForType();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void setValue(long j) {
+        this.value_ = j;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite
+    public final Object dynamicMethod(GeneratedMessageLite.f fVar, Object obj, Object obj2) {
+        switch (a.a[fVar.ordinal()]) {
+            case 1:
+                return new UInt64Value();
+            case 2:
+                return new b();
+            case 3:
+                return GeneratedMessageLite.newMessageInfo(DEFAULT_INSTANCE, "\u0000\u0001\u0000\u0000\u0001\u0001\u0001\u0000\u0000\u0000\u0001\u0003", new Object[]{"value_"});
+            case 4:
+                return DEFAULT_INSTANCE;
+            case 5:
+                w0<UInt64Value> w0Var = PARSER;
+                if (w0Var == null) {
+                    synchronized (UInt64Value.class) {
+                        try {
+                            w0Var = PARSER;
+                            if (w0Var == null) {
+                                w0Var = new GeneratedMessageLite.c<>(DEFAULT_INSTANCE);
+                                PARSER = w0Var;
+                            }
+                        } finally {
+                        }
+                    }
+                }
+                return w0Var;
+            case 6:
+                return (byte) 1;
+            case 7:
+                return null;
+            default:
+                throw new UnsupportedOperationException();
+        }
+    }
+
+    public long getValue() {
+        return this.value_;
+    }
+
+    public static b newBuilder(UInt64Value uInt64Value) {
+        return DEFAULT_INSTANCE.createBuilder(uInt64Value);
+    }
+
+    public static UInt64Value parseDelimitedFrom(InputStream inputStream, q qVar) throws IOException {
+        return (UInt64Value) GeneratedMessageLite.parseDelimitedFrom(DEFAULT_INSTANCE, inputStream, qVar);
+    }
+
+    public static UInt64Value parseFrom(ByteBuffer byteBuffer, q qVar) throws z {
+        return (UInt64Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, byteBuffer, qVar);
+    }
+
+    public static UInt64Value parseFrom(i iVar) throws z {
+        return (UInt64Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, iVar);
+    }
+
+    public static UInt64Value parseFrom(i iVar, q qVar) throws z {
+        return (UInt64Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, iVar, qVar);
+    }
+
+    public static UInt64Value parseFrom(byte[] bArr) throws z {
+        return (UInt64Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, bArr);
+    }
+
+    public static UInt64Value parseFrom(byte[] bArr, q qVar) throws z {
+        return (UInt64Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, bArr, qVar);
+    }
+
+    public static UInt64Value parseFrom(InputStream inputStream) throws IOException {
+        return (UInt64Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, inputStream);
+    }
+
+    public static UInt64Value parseFrom(InputStream inputStream, q qVar) throws IOException {
+        return (UInt64Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, inputStream, qVar);
+    }
+
+    public static UInt64Value parseFrom(j jVar) throws IOException {
+        return (UInt64Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, jVar);
+    }
+
+    public static UInt64Value parseFrom(j jVar, q qVar) throws IOException {
+        return (UInt64Value) GeneratedMessageLite.parseFrom(DEFAULT_INSTANCE, jVar, qVar);
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/a.java

@@ -0,0 +1,218 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.a;
+import com.fyber.inneractive.sdk.protobuf.a.AbstractC0103a;
+import com.fyber.inneractive.sdk.protobuf.i;
+import com.fyber.inneractive.sdk.protobuf.l;
+import com.fyber.inneractive.sdk.protobuf.o0;
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.logging.Logger;
+
+/* loaded from: classes2.dex */
+public abstract class a<MessageType extends a<MessageType, BuilderType>, BuilderType extends AbstractC0103a<MessageType, BuilderType>> implements o0 {
+    protected int memoizedHashCode = 0;
+
+    @Deprecated
+    public static <T> void addAll(Iterable<T> iterable, Collection<? super T> collection) {
+        AbstractC0103a.a(iterable, (List) collection);
+    }
+
+    public static void checkByteStringIsUtf8(i iVar) throws IllegalArgumentException {
+        if (!iVar.e()) {
+            throw new IllegalArgumentException("Byte string is not UTF-8.");
+        }
+    }
+
+    private String getSerializingExceptionMessage(String str) {
+        return "Serializing " + getClass().getName() + " to a " + str + " threw an IOException (should never happen).";
+    }
+
+    public int getMemoizedSerializedSize() {
+        throw new UnsupportedOperationException();
+    }
+
+    public int getSerializedSize(d1 d1Var) {
+        int memoizedSerializedSize = getMemoizedSerializedSize();
+        if (memoizedSerializedSize != -1) {
+            return memoizedSerializedSize;
+        }
+        int c = d1Var.c(this);
+        setMemoizedSerializedSize(c);
+        return c;
+    }
+
+    public j1 newUninitializedMessageException() {
+        return new j1();
+    }
+
+    public void setMemoizedSerializedSize(int i) {
+        throw new UnsupportedOperationException();
+    }
+
+    public byte[] toByteArray() {
+        try {
+            int serializedSize = getSerializedSize();
+            byte[] bArr = new byte[serializedSize];
+            Logger logger = l.b;
+            l.b bVar = new l.b(bArr, serializedSize);
+            writeTo(bVar);
+            if (bVar.a() == 0) {
+                return bArr;
+            }
+            throw new IllegalStateException("Did not write as much data as expected.");
+        } catch (IOException e) {
+            throw new RuntimeException(getSerializingExceptionMessage("byte array"), e);
+        }
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.o0
+    public i toByteString() {
+        try {
+            int serializedSize = getSerializedSize();
+            i.h hVar = i.b;
+            byte[] bArr = new byte[serializedSize];
+            Logger logger = l.b;
+            l.b bVar = new l.b(bArr, serializedSize);
+            writeTo(bVar);
+            if (bVar.a() == 0) {
+                return new i.h(bArr);
+            }
+            throw new IllegalStateException("Did not write as much data as expected.");
+        } catch (IOException e) {
+            throw new RuntimeException(getSerializingExceptionMessage("ByteString"), e);
+        }
+    }
+
+    public void writeDelimitedTo(OutputStream outputStream) throws IOException {
+        int serializedSize = getSerializedSize();
+        int e = l.e(serializedSize) + serializedSize;
+        if (e > 4096) {
+            e = 4096;
+        }
+        l.d dVar = new l.d(outputStream, e);
+        dVar.i(serializedSize);
+        writeTo(dVar);
+        if (dVar.f > 0) {
+            dVar.a();
+        }
+    }
+
+    public void writeTo(OutputStream outputStream) throws IOException {
+        int serializedSize = getSerializedSize();
+        Logger logger = l.b;
+        if (serializedSize > 4096) {
+            serializedSize = 4096;
+        }
+        l.d dVar = new l.d(outputStream, serializedSize);
+        writeTo(dVar);
+        if (dVar.f > 0) {
+            dVar.a();
+        }
+    }
+
+    /* renamed from: com.fyber.inneractive.sdk.protobuf.a$a, reason: collision with other inner class name */
+    public static abstract class AbstractC0103a<MessageType extends a<MessageType, BuilderType>, BuilderType extends AbstractC0103a<MessageType, BuilderType>> implements o0.a {
+        public static <T> void a(Iterable<T> iterable, List<? super T> list) {
+            Charset charset = y.a;
+            iterable.getClass();
+            if (iterable instanceof d0) {
+                List<?> c = ((d0) iterable).c();
+                d0 d0Var = (d0) list;
+                int size = list.size();
+                for (Object obj : c) {
+                    if (obj == null) {
+                        String str = "Element at index " + (d0Var.size() - size) + " is null.";
+                        for (int size2 = d0Var.size() - 1; size2 >= size; size2--) {
+                            d0Var.remove(size2);
+                        }
+                        throw new NullPointerException(str);
+                    }
+                    if (obj instanceof i) {
+                        d0Var.a((i) obj);
+                    } else {
+                        d0Var.add((String) obj);
+                    }
+                }
+                return;
+            }
+            if (iterable instanceof x0) {
+                list.addAll((Collection) iterable);
+                return;
+            }
+            if ((list instanceof ArrayList) && (iterable instanceof Collection)) {
+                ((ArrayList) list).ensureCapacity(((Collection) iterable).size() + list.size());
+            }
+            int size3 = list.size();
+            for (T t : iterable) {
+                if (t == null) {
+                    String str2 = "Element at index " + (list.size() - size3) + " is null.";
+                    for (int size4 = list.size() - 1; size4 >= size3; size4--) {
+                        list.remove(size4);
+                    }
+                    throw new NullPointerException(str2);
+                }
+                list.add(t);
+            }
+        }
+
+        /* renamed from: com.fyber.inneractive.sdk.protobuf.a$a$a, reason: collision with other inner class name */
+        public static final class C0104a extends FilterInputStream {
+            public int a;
+
+            public C0104a(int i, InputStream inputStream) {
+                super(inputStream);
+                this.a = i;
+            }
+
+            @Override // java.io.FilterInputStream, java.io.InputStream
+            public final int available() throws IOException {
+                return Math.min(super.available(), this.a);
+            }
+
+            @Override // java.io.FilterInputStream, java.io.InputStream
+            public final long skip(long j) throws IOException {
+                long skip = super.skip(Math.min(j, this.a));
+                if (skip >= 0) {
+                    this.a = (int) (this.a - skip);
+                }
+                return skip;
+            }
+
+            @Override // java.io.FilterInputStream, java.io.InputStream
+            public final int read() throws IOException {
+                if (this.a <= 0) {
+                    return -1;
+                }
+                int read = super.read();
+                if (read >= 0) {
+                    this.a--;
+                }
+                return read;
+            }
+
+            @Override // java.io.FilterInputStream, java.io.InputStream
+            public final int read(byte[] bArr, int i, int i2) throws IOException {
+                int i3 = this.a;
+                if (i3 <= 0) {
+                    return -1;
+                }
+                int read = super.read(bArr, i, Math.min(i2, i3));
+                if (read >= 0) {
+                    this.a -= read;
+                }
+                return read;
+            }
+        }
+    }
+
+    public static <T> void addAll(Iterable<T> iterable, List<? super T> list) {
+        AbstractC0103a.a(iterable, list);
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/a0.java

@@ -0,0 +1,80 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public final class a0 extends b0 {
+
+    public static class a<K> implements Map.Entry<K, Object> {
+        public final Map.Entry<K, a0> a;
+
+        public a(Map.Entry<K, a0> entry) {
+            this.a = entry;
+        }
+
+        @Override // java.util.Map.Entry
+        public final K getKey() {
+            return this.a.getKey();
+        }
+
+        @Override // java.util.Map.Entry
+        public final Object getValue() {
+            a0 value = this.a.getValue();
+            if (value == null) {
+                return null;
+            }
+            return value.a(null);
+        }
+
+        @Override // java.util.Map.Entry
+        public final Object setValue(Object obj) {
+            if (!(obj instanceof o0)) {
+                throw new IllegalArgumentException("LazyField now only used for MessageSet, and the value of MessageSet must be an instance of MessageLite");
+            }
+            a0 value = this.a.getValue();
+            o0 o0Var = value.a;
+            value.b = null;
+            value.a = (o0) obj;
+            return o0Var;
+        }
+    }
+
+    public static class b<K> implements Iterator<Map.Entry<K, Object>> {
+        public final Iterator<Map.Entry<K, Object>> a;
+
+        public b(Iterator<Map.Entry<K, Object>> it) {
+            this.a = it;
+        }
+
+        @Override // java.util.Iterator
+        public final boolean hasNext() {
+            return this.a.hasNext();
+        }
+
+        @Override // java.util.Iterator
+        public final Object next() {
+            Map.Entry<K, Object> next = this.a.next();
+            return next.getValue() instanceof a0 ? new a(next) : next;
+        }
+
+        @Override // java.util.Iterator
+        public final void remove() {
+            this.a.remove();
+        }
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.b0
+    public final boolean equals(Object obj) {
+        return a(null).equals(obj);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.b0
+    public final int hashCode() {
+        return a(null).hashCode();
+    }
+
+    public final String toString() {
+        return a(null).toString();
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/a1.java

@@ -0,0 +1,121 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.RandomAccess;
+
+/* loaded from: classes2.dex */
+public final class a1<E> extends c<E> implements RandomAccess {
+    public static final a1<Object> d;
+    public E[] b;
+    public int c;
+
+    static {
+        a1<Object> a1Var = new a1<>(new Object[0], 0);
+        d = a1Var;
+        a1Var.a = false;
+    }
+
+    public a1(E[] eArr, int i) {
+        this.b = eArr;
+        this.c = i;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean add(E e) {
+        e();
+        int i = this.c;
+        E[] eArr = this.b;
+        if (i == eArr.length) {
+            this.b = (E[]) Arrays.copyOf(eArr, ((i * 3) / 2) + 1);
+        }
+        E[] eArr2 = this.b;
+        int i2 = this.c;
+        this.c = i2 + 1;
+        eArr2[i2] = e;
+        ((AbstractList) this).modCount++;
+        return true;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.List
+    public final E remove(int i) {
+        int i2;
+        e();
+        if (i < 0 || i >= (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        E[] eArr = this.b;
+        E e = eArr[i];
+        if (i < i2 - 1) {
+            System.arraycopy(eArr, i + 1, eArr, i, (i2 - i) - 1);
+        }
+        this.c--;
+        ((AbstractList) this).modCount++;
+        return e;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final E set(int i, E e) {
+        e();
+        if (i < 0 || i >= this.c) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        E[] eArr = this.b;
+        E e2 = eArr[i];
+        eArr[i] = e;
+        ((AbstractList) this).modCount++;
+        return e2;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.c;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final E get(int i) {
+        if (i >= 0 && i < this.c) {
+            return this.b[i];
+        }
+        StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+        a.append(this.c);
+        throw new IndexOutOfBoundsException(a.toString());
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.y.j
+    public final y.j a(int i) {
+        if (i >= this.c) {
+            return new a1(Arrays.copyOf(this.b, i), this.c);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final void add(int i, E e) {
+        int i2;
+        e();
+        if (i >= 0 && i <= (i2 = this.c)) {
+            E[] eArr = this.b;
+            if (i2 < eArr.length) {
+                System.arraycopy(eArr, i, eArr, i + 1, i2 - i);
+            } else {
+                E[] eArr2 = (E[]) new Object[((i2 * 3) / 2) + 1];
+                System.arraycopy(eArr, 0, eArr2, 0, i);
+                System.arraycopy(this.b, i, eArr2, i + 1, this.c - i);
+                this.b = eArr2;
+            }
+            this.b[i] = e;
+            this.c++;
+            ((AbstractList) this).modCount++;
+            return;
+        }
+        StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+        a.append(this.c);
+        throw new IndexOutOfBoundsException(a.toString());
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/b.java

@@ -0,0 +1,10 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.o0;
+
+/* loaded from: classes2.dex */
+public abstract class b<MessageType extends o0> implements w0<MessageType> {
+    static {
+        q.a();
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/b0.java

@@ -0,0 +1,66 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public class b0 {
+    public volatile o0 a;
+    public volatile i b;
+
+    static {
+        q.a();
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof b0)) {
+            return false;
+        }
+        b0 b0Var = (b0) obj;
+        o0 o0Var = this.a;
+        o0 o0Var2 = b0Var.a;
+        return (o0Var == null && o0Var2 == null) ? a().equals(b0Var.a()) : (o0Var == null || o0Var2 == null) ? o0Var != null ? o0Var.equals(b0Var.a(o0Var.getDefaultInstanceForType())) : a(o0Var2.getDefaultInstanceForType()).equals(o0Var2) : o0Var.equals(o0Var2);
+    }
+
+    public int hashCode() {
+        return 1;
+    }
+
+    public final i a() {
+        if (this.b != null) {
+            return this.b;
+        }
+        synchronized (this) {
+            try {
+                if (this.b != null) {
+                    return this.b;
+                }
+                if (this.a == null) {
+                    this.b = i.b;
+                } else {
+                    this.b = this.a.toByteString();
+                }
+                return this.b;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final o0 a(o0 o0Var) {
+        if (this.a == null) {
+            synchronized (this) {
+                if (this.a == null) {
+                    try {
+                        this.a = o0Var;
+                        this.b = i.b;
+                    } catch (z unused) {
+                        this.a = o0Var;
+                        this.b = i.b;
+                    }
+                }
+            }
+        }
+        return this.a;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/b1.java

@@ -0,0 +1,80 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class b1 implements m0 {
+    public final o0 a;
+    public final String b;
+    public final Object[] c;
+    public final int d;
+
+    public b1(o0 o0Var, String str, Object[] objArr) {
+        char charAt;
+        this.a = o0Var;
+        this.b = str;
+        this.c = objArr;
+        try {
+            charAt = str.charAt(0);
+        } catch (StringIndexOutOfBoundsException unused) {
+            char[] charArray = str.toCharArray();
+            String str2 = new String(charArray);
+            try {
+                try {
+                    charAt = str2.charAt(0);
+                    str = str2;
+                } catch (StringIndexOutOfBoundsException unused2) {
+                    char[] cArr = new char[str2.length()];
+                    str2.getChars(0, str2.length(), cArr, 0);
+                    String str3 = new String(cArr);
+                    try {
+                        charAt = str3.charAt(0);
+                        str = str3;
+                    } catch (ArrayIndexOutOfBoundsException | StringIndexOutOfBoundsException e) {
+                        e = e;
+                        str2 = str3;
+                        throw new IllegalStateException(String.format("Failed parsing '%s' with charArray.length of %d", str2, Integer.valueOf(charArray.length)), e);
+                    }
+                }
+            } catch (ArrayIndexOutOfBoundsException e2) {
+                e = e2;
+                throw new IllegalStateException(String.format("Failed parsing '%s' with charArray.length of %d", str2, Integer.valueOf(charArray.length)), e);
+            } catch (StringIndexOutOfBoundsException e3) {
+                e = e3;
+                throw new IllegalStateException(String.format("Failed parsing '%s' with charArray.length of %d", str2, Integer.valueOf(charArray.length)), e);
+            }
+        }
+        if (charAt < 55296) {
+            this.d = charAt;
+            return;
+        }
+        int i = charAt & 8191;
+        int i2 = 13;
+        int i3 = 1;
+        while (true) {
+            int i4 = i3 + 1;
+            char charAt2 = str.charAt(i3);
+            if (charAt2 < 55296) {
+                this.d = i | (charAt2 << i2);
+                return;
+            } else {
+                i |= (charAt2 & 8191) << i2;
+                i2 += 13;
+                i3 = i4;
+            }
+        }
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.m0
+    public final boolean a() {
+        return (this.d & 2) == 2;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.m0
+    public final y0 b() {
+        return (this.d & 1) == 1 ? y0.PROTO2 : y0.PROTO3;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.m0
+    public final o0 c() {
+        return this.a;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/c.java

@@ -0,0 +1,112 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.util.AbstractList;
+import java.util.Collection;
+import java.util.List;
+import java.util.RandomAccess;
+
+/* loaded from: classes2.dex */
+public abstract class c<E> extends AbstractList<E> implements y.j<E> {
+    public boolean a = true;
+
+    @Override // com.fyber.inneractive.sdk.protobuf.y.j
+    public final void a() {
+        this.a = false;
+    }
+
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean add(E e) {
+        e();
+        return super.add(e);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public boolean addAll(Collection<? extends E> collection) {
+        e();
+        return super.addAll(collection);
+    }
+
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public void clear() {
+        e();
+        super.clear();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.y.j
+    public final boolean d() {
+        return this.a;
+    }
+
+    @Override // java.util.AbstractList, java.util.Collection, java.util.List
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof List)) {
+            return false;
+        }
+        if (!(obj instanceof RandomAccess)) {
+            return super.equals(obj);
+        }
+        List list = (List) obj;
+        int size = size();
+        if (size != list.size()) {
+            return false;
+        }
+        for (int i = 0; i < size; i++) {
+            if (!get(i).equals(list.get(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.Collection, java.util.List
+    public int hashCode() {
+        int size = size();
+        int i = 1;
+        for (int i2 = 0; i2 < size; i2++) {
+            i = (i * 31) + get(i2).hashCode();
+        }
+        return i;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public abstract E remove(int i);
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean remove(Object obj) {
+        e();
+        int indexOf = indexOf(obj);
+        if (indexOf == -1) {
+            return false;
+        }
+        remove(indexOf);
+        return true;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean removeAll(Collection<?> collection) {
+        e();
+        return super.removeAll(collection);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean retainAll(Collection<?> collection) {
+        e();
+        return super.retainAll(collection);
+    }
+
+    public final void e() {
+        if (!this.a) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public boolean addAll(int i, Collection<? extends E> collection) {
+        e();
+        return super.addAll(i, collection);
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/c0.java

@@ -0,0 +1,131 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.RandomAccess;
+
+/* loaded from: classes2.dex */
+public final class c0 extends c<String> implements d0, RandomAccess {
+    public final ArrayList b;
+
+    static {
+        new c0(10).a = false;
+    }
+
+    public c0(int i) {
+        this((ArrayList<Object>) new ArrayList(i));
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.y.j
+    public final y.j a(int i) {
+        if (i < this.b.size()) {
+            throw new IllegalArgumentException();
+        }
+        ArrayList arrayList = new ArrayList(i);
+        arrayList.addAll(this.b);
+        return new c0((ArrayList<Object>) arrayList);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final void add(int i, Object obj) {
+        e();
+        this.b.add(i, (String) obj);
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean addAll(Collection<? extends String> collection) {
+        return addAll(this.b.size(), collection);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d0
+    public final List<?> c() {
+        return Collections.unmodifiableList(this.b);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final void clear() {
+        e();
+        this.b.clear();
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object get(int i) {
+        String a;
+        Object obj = this.b.get(i);
+        if (obj instanceof String) {
+            return (String) obj;
+        }
+        if (obj instanceof i) {
+            i iVar = (i) obj;
+            a = iVar.i();
+            if (iVar.e()) {
+                this.b.set(i, a);
+            }
+        } else {
+            byte[] bArr = (byte[]) obj;
+            a = y.a(bArr);
+            if (q1.a.b(bArr, 0, bArr.length)) {
+                this.b.set(i, a);
+            }
+        }
+        return a;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.List
+    public final Object remove(int i) {
+        e();
+        Object remove = this.b.remove(i);
+        ((AbstractList) this).modCount++;
+        return remove instanceof String ? (String) remove : remove instanceof i ? ((i) remove).i() : y.a((byte[]) remove);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object set(int i, Object obj) {
+        e();
+        Object obj2 = this.b.set(i, (String) obj);
+        return obj2 instanceof String ? (String) obj2 : obj2 instanceof i ? ((i) obj2).i() : y.a((byte[]) obj2);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.b.size();
+    }
+
+    public c0(ArrayList<Object> arrayList) {
+        this.b = arrayList;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d0
+    public final d0 b() {
+        return this.a ? new n1(this) : this;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.List
+    public final boolean addAll(int i, Collection<? extends String> collection) {
+        e();
+        if (collection instanceof d0) {
+            collection = ((d0) collection).c();
+        }
+        boolean addAll = this.b.addAll(i, collection);
+        ((AbstractList) this).modCount++;
+        return addAll;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d0
+    public final Object b(int i) {
+        return this.b.get(i);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d0
+    public final void a(i iVar) {
+        e();
+        this.b.add(iVar);
+        ((AbstractList) this).modCount++;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/c1.java

@@ -0,0 +1,98 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.io.IOException;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public interface c1 {
+    int a() throws IOException;
+
+    <T> T a(d1<T> d1Var, q qVar) throws IOException;
+
+    @Deprecated
+    <T> T a(Class<T> cls, q qVar) throws IOException;
+
+    void a(List<Integer> list) throws IOException;
+
+    @Deprecated
+    <T> void a(List<T> list, d1<T> d1Var, q qVar) throws IOException;
+
+    int b();
+
+    @Deprecated
+    <T> T b(d1<T> d1Var, q qVar) throws IOException;
+
+    <T> T b(Class<T> cls, q qVar) throws IOException;
+
+    void b(List<Integer> list) throws IOException;
+
+    <T> void b(List<T> list, d1<T> d1Var, q qVar) throws IOException;
+
+    long c() throws IOException;
+
+    void c(List<Integer> list) throws IOException;
+
+    long d() throws IOException;
+
+    void d(List<Long> list) throws IOException;
+
+    int e() throws IOException;
+
+    void e(List<Integer> list) throws IOException;
+
+    long f() throws IOException;
+
+    void f(List<Boolean> list) throws IOException;
+
+    String g() throws IOException;
+
+    void g(List<String> list) throws IOException;
+
+    int h() throws IOException;
+
+    void h(List<Long> list) throws IOException;
+
+    void i(List<String> list) throws IOException;
+
+    boolean i() throws IOException;
+
+    int j() throws IOException;
+
+    void j(List<Float> list) throws IOException;
+
+    long k() throws IOException;
+
+    void k(List<i> list) throws IOException;
+
+    i l() throws IOException;
+
+    void l(List<Double> list) throws IOException;
+
+    int m() throws IOException;
+
+    void m(List<Long> list) throws IOException;
+
+    void n() throws IOException;
+
+    void n(List<Long> list) throws IOException;
+
+    int o() throws IOException;
+
+    void o(List<Long> list) throws IOException;
+
+    void p(List<Integer> list) throws IOException;
+
+    boolean p() throws IOException;
+
+    int q() throws IOException;
+
+    void q(List<Integer> list) throws IOException;
+
+    long r() throws IOException;
+
+    double readDouble() throws IOException;
+
+    float readFloat() throws IOException;
+
+    String s() throws IOException;
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/d.java

@@ -0,0 +1,27 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class d {
+    public static final Class<?> a;
+    public static final boolean b;
+
+    public static boolean a() {
+        return (a == null || b) ? false : true;
+    }
+
+    static {
+        Class<?> cls;
+        Class<?> cls2 = null;
+        try {
+            cls = Class.forName("libcore.io.Memory");
+        } catch (Throwable unused) {
+            cls = null;
+        }
+        a = cls;
+        try {
+            cls2 = Class.forName("org.robolectric.Robolectric");
+        } catch (Throwable unused2) {
+        }
+        b = cls2 != null;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/d0.java

@@ -0,0 +1,14 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public interface d0 extends List {
+    void a(i iVar);
+
+    d0 b();
+
+    Object b(int i);
+
+    List<?> c();
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/d1.java

@@ -0,0 +1,27 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.e;
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+public interface d1<T> {
+    T a();
+
+    void a(T t);
+
+    void a(T t, c1 c1Var, q qVar) throws IOException;
+
+    void a(Object obj, m mVar) throws IOException;
+
+    void a(T t, T t2);
+
+    void a(T t, byte[] bArr, int i, int i2, e.b bVar) throws IOException;
+
+    boolean b(T t);
+
+    boolean b(T t, T t2);
+
+    int c(T t);
+
+    int d(T t);
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/e.java

@@ -0,0 +1,667 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.applovin.exoplayer2.common.base.Ascii;
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+import com.fyber.inneractive.sdk.protobuf.r1;
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+public final class e {
+
+    public static /* synthetic */ class a {
+        public static final /* synthetic */ int[] a;
+
+        static {
+            int[] iArr = new int[r1.b.values().length];
+            a = iArr;
+            try {
+                iArr[r1.b.DOUBLE.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                a[r1.b.FLOAT.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                a[r1.b.INT64.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                a[r1.b.UINT64.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                a[r1.b.INT32.ordinal()] = 5;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                a[r1.b.UINT32.ordinal()] = 6;
+            } catch (NoSuchFieldError unused6) {
+            }
+            try {
+                a[r1.b.FIXED64.ordinal()] = 7;
+            } catch (NoSuchFieldError unused7) {
+            }
+            try {
+                a[r1.b.SFIXED64.ordinal()] = 8;
+            } catch (NoSuchFieldError unused8) {
+            }
+            try {
+                a[r1.b.FIXED32.ordinal()] = 9;
+            } catch (NoSuchFieldError unused9) {
+            }
+            try {
+                a[r1.b.SFIXED32.ordinal()] = 10;
+            } catch (NoSuchFieldError unused10) {
+            }
+            try {
+                a[r1.b.BOOL.ordinal()] = 11;
+            } catch (NoSuchFieldError unused11) {
+            }
+            try {
+                a[r1.b.SINT32.ordinal()] = 12;
+            } catch (NoSuchFieldError unused12) {
+            }
+            try {
+                a[r1.b.SINT64.ordinal()] = 13;
+            } catch (NoSuchFieldError unused13) {
+            }
+            try {
+                a[r1.b.ENUM.ordinal()] = 14;
+            } catch (NoSuchFieldError unused14) {
+            }
+            try {
+                a[r1.b.BYTES.ordinal()] = 15;
+            } catch (NoSuchFieldError unused15) {
+            }
+            try {
+                a[r1.b.STRING.ordinal()] = 16;
+            } catch (NoSuchFieldError unused16) {
+            }
+            try {
+                a[r1.b.GROUP.ordinal()] = 17;
+            } catch (NoSuchFieldError unused17) {
+            }
+            try {
+                a[r1.b.MESSAGE.ordinal()] = 18;
+            } catch (NoSuchFieldError unused18) {
+            }
+        }
+    }
+
+    public static final class b {
+        public int a;
+        public long b;
+        public Object c;
+        public final q d;
+
+        public b(q qVar) {
+            qVar.getClass();
+            this.d = qVar;
+        }
+    }
+
+    public static int a(int i, byte[] bArr, int i2, b bVar) {
+        int i3 = i & 127;
+        int i4 = i2 + 1;
+        byte b2 = bArr[i2];
+        if (b2 >= 0) {
+            bVar.a = i3 | (b2 << 7);
+            return i4;
+        }
+        int i5 = i3 | ((b2 & Byte.MAX_VALUE) << 7);
+        int i6 = i2 + 2;
+        byte b3 = bArr[i4];
+        if (b3 >= 0) {
+            bVar.a = i5 | (b3 << Ascii.SO);
+            return i6;
+        }
+        int i7 = i5 | ((b3 & Byte.MAX_VALUE) << 14);
+        int i8 = i2 + 3;
+        byte b4 = bArr[i6];
+        if (b4 >= 0) {
+            bVar.a = i7 | (b4 << Ascii.NAK);
+            return i8;
+        }
+        int i9 = i7 | ((b4 & Byte.MAX_VALUE) << 21);
+        int i10 = i2 + 4;
+        byte b5 = bArr[i8];
+        if (b5 >= 0) {
+            bVar.a = i9 | (b5 << Ascii.FS);
+            return i10;
+        }
+        int i11 = i9 | ((b5 & Byte.MAX_VALUE) << 28);
+        while (true) {
+            int i12 = i10 + 1;
+            if (bArr[i10] >= 0) {
+                bVar.a = i11;
+                return i12;
+            }
+            i10 = i12;
+        }
+    }
+
+    public static long b(byte[] bArr, int i) {
+        return ((bArr[i + 7] & 255) << 56) | (bArr[i] & 255) | ((bArr[i + 1] & 255) << 8) | ((bArr[i + 2] & 255) << 16) | ((bArr[i + 3] & 255) << 24) | ((bArr[i + 4] & 255) << 32) | ((bArr[i + 5] & 255) << 40) | ((bArr[i + 6] & 255) << 48);
+    }
+
+    public static int c(byte[] bArr, int i, b bVar) {
+        int i2 = i + 1;
+        byte b2 = bArr[i];
+        if (b2 < 0) {
+            return a(b2, bArr, i2, bVar);
+        }
+        bVar.a = b2;
+        return i2;
+    }
+
+    public static int d(byte[] bArr, int i, b bVar) {
+        int i2 = i + 1;
+        long j = bArr[i];
+        if (j >= 0) {
+            bVar.b = j;
+            return i2;
+        }
+        int i3 = i + 2;
+        byte b2 = bArr[i2];
+        long j2 = (j & 127) | ((b2 & Byte.MAX_VALUE) << 7);
+        int i4 = 7;
+        while (b2 < 0) {
+            int i5 = i3 + 1;
+            i4 += 7;
+            j2 |= (r10 & Byte.MAX_VALUE) << i4;
+            b2 = bArr[i3];
+            i3 = i5;
+        }
+        bVar.b = j2;
+        return i3;
+    }
+
+    public static int b(byte[] bArr, int i, b bVar) throws z {
+        int c = c(bArr, i, bVar);
+        int i2 = bVar.a;
+        if (i2 < 0) {
+            throw z.f();
+        }
+        if (i2 == 0) {
+            bVar.c = "";
+            return c;
+        }
+        bVar.c = new String(bArr, c, i2, y.a);
+        return c + i2;
+    }
+
+    public static int b(int i, byte[] bArr, int i2, int i3, y.j<?> jVar, b bVar) throws z {
+        int c = c(bArr, i2, bVar);
+        int i4 = bVar.a;
+        if (i4 < 0) {
+            throw z.f();
+        }
+        if (i4 == 0) {
+            jVar.add("");
+        } else {
+            int i5 = c + i4;
+            if (q1.a.b(bArr, c, i5)) {
+                jVar.add(new String(bArr, c, i4, y.a));
+                c = i5;
+            } else {
+                throw z.c();
+            }
+        }
+        while (c < i3) {
+            int c2 = c(bArr, c, bVar);
+            if (i != bVar.a) {
+                break;
+            }
+            c = c(bArr, c2, bVar);
+            int i6 = bVar.a;
+            if (i6 < 0) {
+                throw z.f();
+            }
+            if (i6 == 0) {
+                jVar.add("");
+            } else {
+                int i7 = c + i6;
+                if (q1.a.b(bArr, c, i7)) {
+                    jVar.add(new String(bArr, c, i6, y.a));
+                    c = i7;
+                } else {
+                    throw z.c();
+                }
+            }
+        }
+        return c;
+    }
+
+    public static int a(byte[] bArr, int i) {
+        return ((bArr[i + 3] & 255) << 24) | (bArr[i] & 255) | ((bArr[i + 1] & 255) << 8) | ((bArr[i + 2] & 255) << 16);
+    }
+
+    public static int a(byte[] bArr, int i, b bVar) throws z {
+        int c = c(bArr, i, bVar);
+        int i2 = bVar.a;
+        if (i2 >= 0) {
+            if (i2 > bArr.length - c) {
+                throw z.i();
+            }
+            if (i2 == 0) {
+                bVar.c = i.b;
+                return c;
+            }
+            bVar.c = i.a(bArr, c, i2);
+            return c + i2;
+        }
+        throw z.f();
+    }
+
+    public static int a(d1 d1Var, byte[] bArr, int i, int i2, b bVar) throws IOException {
+        int i3 = i + 1;
+        int i4 = bArr[i];
+        if (i4 < 0) {
+            i3 = a(i4, bArr, i3, bVar);
+            i4 = bVar.a;
+        }
+        int i5 = i3;
+        if (i4 >= 0 && i4 <= i2 - i5) {
+            Object a2 = d1Var.a();
+            int i6 = i4 + i5;
+            d1Var.a(a2, bArr, i5, i6, bVar);
+            d1Var.a(a2);
+            bVar.c = a2;
+            return i6;
+        }
+        throw z.i();
+    }
+
+    public static int a(d1 d1Var, byte[] bArr, int i, int i2, int i3, b bVar) throws IOException {
+        r0 r0Var = (r0) d1Var;
+        Object a2 = r0Var.a();
+        int a3 = r0Var.a((r0) a2, bArr, i, i2, i3, bVar);
+        r0Var.a((r0) a2);
+        bVar.c = a2;
+        return a3;
+    }
+
+    public static int a(byte[] bArr, int i, y.j<?> jVar, b bVar) throws IOException {
+        x xVar = (x) jVar;
+        int c = c(bArr, i, bVar);
+        int i2 = bVar.a + c;
+        while (c < i2) {
+            c = c(bArr, c, bVar);
+            xVar.c(bVar.a);
+        }
+        if (c == i2) {
+            return c;
+        }
+        throw z.i();
+    }
+
+    public static int a(int i, byte[] bArr, int i2, int i3, y.j<?> jVar, b bVar) throws z {
+        int c = c(bArr, i2, bVar);
+        int i4 = bVar.a;
+        if (i4 < 0) {
+            throw z.f();
+        }
+        if (i4 == 0) {
+            jVar.add("");
+        } else {
+            jVar.add(new String(bArr, c, i4, y.a));
+            c += i4;
+        }
+        while (c < i3) {
+            int c2 = c(bArr, c, bVar);
+            if (i != bVar.a) {
+                break;
+            }
+            c = c(bArr, c2, bVar);
+            int i5 = bVar.a;
+            if (i5 < 0) {
+                throw z.f();
+            }
+            if (i5 == 0) {
+                jVar.add("");
+            } else {
+                jVar.add(new String(bArr, c, i5, y.a));
+                c += i5;
+            }
+        }
+        return c;
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    public static int a(int i, byte[] bArr, int i2, int i3, GeneratedMessageLite.ExtendableMessage<?, ?> extendableMessage, GeneratedMessageLite.e<?, ?> eVar, k1<l1, l1> k1Var, b bVar) throws IOException {
+        Object a2;
+        u<GeneratedMessageLite.d> uVar = extendableMessage.extensions;
+        int i4 = i >>> 3;
+        GeneratedMessageLite.d dVar = eVar.d;
+        if (dVar.d && dVar.e) {
+            switch (a.a[dVar.c.ordinal()]) {
+                case 1:
+                    n nVar = new n();
+                    i2 = c(bArr, i2, bVar);
+                    int i5 = bVar.a + i2;
+                    while (i2 < i5) {
+                        nVar.a(Double.longBitsToDouble(b(bArr, i2)));
+                        i2 += 8;
+                    }
+                    if (i2 == i5) {
+                        uVar.b(eVar.d, nVar);
+                        break;
+                    } else {
+                        throw z.i();
+                    }
+                case 2:
+                    v vVar = new v();
+                    i2 = c(bArr, i2, bVar);
+                    int i6 = bVar.a + i2;
+                    while (i2 < i6) {
+                        vVar.a(Float.intBitsToFloat(a(bArr, i2)));
+                        i2 += 4;
+                    }
+                    if (i2 == i6) {
+                        uVar.b(eVar.d, vVar);
+                        break;
+                    } else {
+                        throw z.i();
+                    }
+                case 3:
+                case 4:
+                    f0 f0Var = new f0();
+                    i2 = c(bArr, i2, bVar);
+                    int i7 = bVar.a + i2;
+                    while (i2 < i7) {
+                        i2 = d(bArr, i2, bVar);
+                        f0Var.a(bVar.b);
+                    }
+                    if (i2 == i7) {
+                        uVar.b(eVar.d, f0Var);
+                        break;
+                    } else {
+                        throw z.i();
+                    }
+                case 5:
+                case 6:
+                    x xVar = new x();
+                    int a3 = a(bArr, i2, xVar, bVar);
+                    uVar.b(eVar.d, xVar);
+                    return a3;
+                case 7:
+                case 8:
+                    f0 f0Var2 = new f0();
+                    i2 = c(bArr, i2, bVar);
+                    int i8 = bVar.a + i2;
+                    while (i2 < i8) {
+                        f0Var2.a(b(bArr, i2));
+                        i2 += 8;
+                    }
+                    if (i2 == i8) {
+                        uVar.b(eVar.d, f0Var2);
+                        break;
+                    } else {
+                        throw z.i();
+                    }
+                case 9:
+                case 10:
+                    x xVar2 = new x();
+                    i2 = c(bArr, i2, bVar);
+                    int i9 = bVar.a + i2;
+                    while (i2 < i9) {
+                        xVar2.c(a(bArr, i2));
+                        i2 += 4;
+                    }
+                    if (i2 == i9) {
+                        uVar.b(eVar.d, xVar2);
+                        break;
+                    } else {
+                        throw z.i();
+                    }
+                case 11:
+                    g gVar = new g();
+                    i2 = c(bArr, i2, bVar);
+                    int i10 = bVar.a + i2;
+                    while (i2 < i10) {
+                        i2 = d(bArr, i2, bVar);
+                        gVar.a(bVar.b != 0);
+                    }
+                    if (i2 == i10) {
+                        uVar.b(eVar.d, gVar);
+                        break;
+                    } else {
+                        throw z.i();
+                    }
+                case 12:
+                    x xVar3 = new x();
+                    i2 = c(bArr, i2, bVar);
+                    int i11 = bVar.a + i2;
+                    while (i2 < i11) {
+                        i2 = c(bArr, i2, bVar);
+                        xVar3.c(j.b(bVar.a));
+                    }
+                    if (i2 == i11) {
+                        uVar.b(eVar.d, xVar3);
+                        break;
+                    } else {
+                        throw z.i();
+                    }
+                case 13:
+                    f0 f0Var3 = new f0();
+                    i2 = c(bArr, i2, bVar);
+                    int i12 = bVar.a + i2;
+                    while (i2 < i12) {
+                        i2 = d(bArr, i2, bVar);
+                        f0Var3.a(j.a(bVar.b));
+                    }
+                    if (i2 == i12) {
+                        uVar.b(eVar.d, f0Var3);
+                        break;
+                    } else {
+                        throw z.i();
+                    }
+                case 14:
+                    x xVar4 = new x();
+                    int a4 = a(bArr, i2, xVar4, bVar);
+                    l1 l1Var = extendableMessage.unknownFields;
+                    l1 l1Var2 = (l1) e1.a(i4, xVar4, eVar.d.a, l1Var != l1.f ? l1Var : null, k1Var);
+                    if (l1Var2 != null) {
+                        extendableMessage.unknownFields = l1Var2;
+                    }
+                    uVar.b(eVar.d, xVar4);
+                    return a4;
+                default:
+                    throw new IllegalStateException("Type cannot be packed: " + eVar.d.c);
+            }
+        } else {
+            r1.b bVar2 = dVar.c;
+            if (bVar2 == r1.b.ENUM) {
+                i2 = c(bArr, i2, bVar);
+                if (eVar.d.a.a(bVar.a) == null) {
+                    l1 l1Var3 = extendableMessage.unknownFields;
+                    if (l1Var3 == l1.f) {
+                        l1Var3 = new l1();
+                        extendableMessage.unknownFields = l1Var3;
+                    }
+                    int i13 = bVar.a;
+                    Class<?> cls = e1.a;
+                    if (l1Var3 == null) {
+                        l1Var3 = k1Var.a();
+                    }
+                    k1Var.b(i4, i13, l1Var3);
+                    return i2;
+                }
+                r7 = Integer.valueOf(bVar.a);
+            } else {
+                switch (a.a[bVar2.ordinal()]) {
+                    case 1:
+                        r7 = Double.valueOf(Double.longBitsToDouble(b(bArr, i2)));
+                        i2 += 8;
+                        break;
+                    case 2:
+                        r7 = Float.valueOf(Float.intBitsToFloat(a(bArr, i2)));
+                        i2 += 4;
+                        break;
+                    case 3:
+                    case 4:
+                        i2 = d(bArr, i2, bVar);
+                        r7 = Long.valueOf(bVar.b);
+                        break;
+                    case 5:
+                    case 6:
+                        i2 = c(bArr, i2, bVar);
+                        r7 = Integer.valueOf(bVar.a);
+                        break;
+                    case 7:
+                    case 8:
+                        r7 = Long.valueOf(b(bArr, i2));
+                        i2 += 8;
+                        break;
+                    case 9:
+                    case 10:
+                        r7 = Integer.valueOf(a(bArr, i2));
+                        i2 += 4;
+                        break;
+                    case 11:
+                        i2 = d(bArr, i2, bVar);
+                        r7 = Boolean.valueOf(bVar.b != 0);
+                        break;
+                    case 12:
+                        i2 = c(bArr, i2, bVar);
+                        r7 = Integer.valueOf(j.b(bVar.a));
+                        break;
+                    case 13:
+                        i2 = d(bArr, i2, bVar);
+                        r7 = Long.valueOf(j.a(bVar.b));
+                        break;
+                    case 14:
+                        throw new IllegalStateException("Shouldn't reach here.");
+                    case 15:
+                        i2 = a(bArr, i2, bVar);
+                        r7 = bVar.c;
+                        break;
+                    case 16:
+                        i2 = b(bArr, i2, bVar);
+                        r7 = bVar.c;
+                        break;
+                    case 17:
+                        i2 = a(z0.c.a(eVar.c.getClass()), bArr, i2, i3, (i4 << 3) | 4, bVar);
+                        r7 = bVar.c;
+                        break;
+                    case 18:
+                        i2 = a(z0.c.a(eVar.c.getClass()), bArr, i2, i3, bVar);
+                        r7 = bVar.c;
+                        break;
+                }
+            }
+            GeneratedMessageLite.d dVar2 = eVar.d;
+            if (dVar2.d) {
+                uVar.a(dVar2, r7);
+            } else {
+                int i14 = a.a[dVar2.c.ordinal()];
+                if ((i14 == 17 || i14 == 18) && (a2 = uVar.a((u<GeneratedMessageLite.d>) eVar.d)) != null) {
+                    r7 = y.a(a2, r7);
+                }
+                uVar.b(eVar.d, r7);
+            }
+        }
+        return i2;
+    }
+
+    public static int a(int i, byte[] bArr, int i2, int i3, l1 l1Var, b bVar) throws z {
+        int i4 = r1.a;
+        if ((i >>> 3) == 0) {
+            throw z.b();
+        }
+        int i5 = i & 7;
+        if (i5 == 0) {
+            int d = d(bArr, i2, bVar);
+            l1Var.a(i, Long.valueOf(bVar.b));
+            return d;
+        }
+        if (i5 == 1) {
+            l1Var.a(i, Long.valueOf(b(bArr, i2)));
+            return i2 + 8;
+        }
+        if (i5 == 2) {
+            int c = c(bArr, i2, bVar);
+            int i6 = bVar.a;
+            if (i6 >= 0) {
+                if (i6 > bArr.length - c) {
+                    throw z.i();
+                }
+                if (i6 == 0) {
+                    l1Var.a(i, i.b);
+                } else {
+                    l1Var.a(i, i.a(bArr, c, i6));
+                }
+                return c + i6;
+            }
+            throw z.f();
+        }
+        if (i5 != 3) {
+            if (i5 != 5) {
+                throw z.b();
+            }
+            l1Var.a(i, Integer.valueOf(a(bArr, i2)));
+            return i2 + 4;
+        }
+        l1 l1Var2 = new l1();
+        int i7 = (i & (-8)) | 4;
+        int i8 = 0;
+        while (true) {
+            if (i2 >= i3) {
+                break;
+            }
+            int c2 = c(bArr, i2, bVar);
+            int i9 = bVar.a;
+            if (i9 == i7) {
+                i8 = i9;
+                i2 = c2;
+                break;
+            }
+            i8 = i9;
+            i2 = a(i9, bArr, c2, i3, l1Var2, bVar);
+        }
+        if (i2 <= i3 && i8 == i7) {
+            l1Var.a(i, l1Var2);
+            return i2;
+        }
+        throw z.g();
+    }
+
+    public static int a(int i, byte[] bArr, int i2, int i3, b bVar) throws z {
+        int i4 = r1.a;
+        if ((i >>> 3) == 0) {
+            throw z.b();
+        }
+        int i5 = i & 7;
+        if (i5 == 0) {
+            return d(bArr, i2, bVar);
+        }
+        if (i5 == 1) {
+            return i2 + 8;
+        }
+        if (i5 == 2) {
+            return c(bArr, i2, bVar) + bVar.a;
+        }
+        if (i5 != 3) {
+            if (i5 == 5) {
+                return i2 + 4;
+            }
+            throw z.b();
+        }
+        int i6 = (i & (-8)) | 4;
+        int i7 = 0;
+        while (i2 < i3) {
+            i2 = c(bArr, i2, bVar);
+            i7 = bVar.a;
+            if (i7 == i6) {
+                break;
+            }
+            i2 = a(i7, bArr, i2, i3, bVar);
+        }
+        if (i2 > i3 || i7 != i6) {
+            throw z.g();
+        }
+        return i2;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/e0.java

@@ -0,0 +1,158 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public abstract class e0 {
+    public static final a a = new a();
+    public static final b b = new b();
+
+    public e0() {
+    }
+
+    public /* synthetic */ e0(int i) {
+        this();
+    }
+
+    public abstract void a(long j, Object obj, Object obj2);
+
+    public abstract void a(Object obj, long j);
+
+    public abstract <L> List<L> b(Object obj, long j);
+
+    public static final class b extends e0 {
+        public b() {
+            super(0);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.e0
+        public final void a(Object obj, long j) {
+            ((y.j) p1.g(obj, j)).a();
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.e0
+        public final <L> List<L> b(Object obj, long j) {
+            y.j jVar = (y.j) p1.g(obj, j);
+            if (jVar.d()) {
+                return jVar;
+            }
+            int size = jVar.size();
+            y.j a = jVar.a(size == 0 ? 10 : size * 2);
+            p1.a(j, obj, a);
+            return a;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.e0
+        public final void a(long j, Object obj, Object obj2) {
+            y.j jVar = (y.j) p1.g(obj, j);
+            y.j jVar2 = (y.j) p1.g(obj2, j);
+            int size = jVar.size();
+            int size2 = jVar2.size();
+            if (size > 0 && size2 > 0) {
+                if (!jVar.d()) {
+                    jVar = jVar.a(size2 + size);
+                }
+                jVar.addAll(jVar2);
+            }
+            if (size > 0) {
+                jVar2 = jVar;
+            }
+            p1.a(j, obj, jVar2);
+        }
+    }
+
+    public static final class a extends e0 {
+        public static final Class<?> c = Collections.unmodifiableList(Collections.emptyList()).getClass();
+
+        public a() {
+            super(0);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.e0
+        public final void a(Object obj, long j) {
+            Object unmodifiableList;
+            List list = (List) p1.g(obj, j);
+            if (list instanceof d0) {
+                unmodifiableList = ((d0) list).b();
+            } else {
+                if (c.isAssignableFrom(list.getClass())) {
+                    return;
+                }
+                if ((list instanceof x0) && (list instanceof y.j)) {
+                    y.j jVar = (y.j) list;
+                    if (jVar.d()) {
+                        jVar.a();
+                        return;
+                    }
+                    return;
+                }
+                unmodifiableList = Collections.unmodifiableList(list);
+            }
+            p1.a(j, obj, unmodifiableList);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.e0
+        public final <L> List<L> b(Object obj, long j) {
+            return a(10, j, obj);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.e0
+        public final void a(long j, Object obj, Object obj2) {
+            List list = (List) p1.g(obj2, j);
+            List a = a(list.size(), j, obj);
+            int size = a.size();
+            int size2 = list.size();
+            if (size > 0 && size2 > 0) {
+                a.addAll(list);
+            }
+            if (size > 0) {
+                list = a;
+            }
+            p1.a(j, obj, list);
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        public static List a(int i, long j, Object obj) {
+            c0 c0Var;
+            List arrayList;
+            List list = (List) p1.g(obj, j);
+            if (list.isEmpty()) {
+                if (list instanceof d0) {
+                    arrayList = new c0(i);
+                } else if ((list instanceof x0) && (list instanceof y.j)) {
+                    arrayList = ((y.j) list).a(i);
+                } else {
+                    arrayList = new ArrayList(i);
+                }
+                p1.a(j, obj, arrayList);
+                return arrayList;
+            }
+            if (c.isAssignableFrom(list.getClass())) {
+                ArrayList arrayList2 = new ArrayList(list.size() + i);
+                arrayList2.addAll(list);
+                p1.a(j, obj, arrayList2);
+                c0Var = arrayList2;
+            } else if (list instanceof n1) {
+                c0 c0Var2 = new c0(list.size() + i);
+                c0Var2.addAll((n1) list);
+                p1.a(j, obj, c0Var2);
+                c0Var = c0Var2;
+            } else {
+                if (!(list instanceof x0) || !(list instanceof y.j)) {
+                    return list;
+                }
+                y.j jVar = (y.j) list;
+                if (jVar.d()) {
+                    return list;
+                }
+                y.j a = jVar.a(list.size() + i);
+                p1.a(j, obj, a);
+                return a;
+            }
+            return c0Var;
+        }
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/e1.java

@@ -0,0 +1,839 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.io.IOException;
+import java.util.AbstractList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.RandomAccess;
+import java.util.logging.Logger;
+
+/* loaded from: classes2.dex */
+public final class e1 {
+    public static final Class<?> a;
+    public static final k1<?, ?> b;
+    public static final k1<?, ?> c;
+    public static final m1 d;
+
+    /* JADX WARN: Can't wrap try/catch for region: R(15:0|1|(2:2|3)|4|5|6|7|(8:24|25|10|11|12|(3:17|18|19)|14|15)|9|10|11|12|(0)|14|15) */
+    /* JADX WARN: Code restructure failed: missing block: B:23:0x0037, code lost:
+    
+        r0 = null;
+     */
+    /* JADX WARN: Removed duplicated region for block: B:17:0x003b A[EXC_TOP_SPLITTER, SYNTHETIC] */
+    static {
+        /*
+            java.lang.String r0 = "com.google.protobuf.UnknownFieldSetSchema"
+            r1 = 0
+            java.lang.String r2 = "com.google.protobuf.GeneratedMessageV3"
+            java.lang.Class r2 = java.lang.Class.forName(r2)     // Catch: java.lang.Throwable -> La
+            goto Lb
+        La:
+            r2 = r1
+        Lb:
+            com.fyber.inneractive.sdk.protobuf.e1.a = r2
+            java.lang.Class r2 = java.lang.Class.forName(r0)     // Catch: java.lang.Throwable -> L12
+            goto L13
+        L12:
+            r2 = r1
+        L13:
+            r3 = 0
+            r4 = 1
+            if (r2 != 0) goto L18
+            goto L2f
+        L18:
+            java.lang.Class[] r5 = new java.lang.Class[r4]     // Catch: java.lang.Throwable -> L2f
+            java.lang.Class r6 = java.lang.Boolean.TYPE     // Catch: java.lang.Throwable -> L2f
+            r5[r3] = r6     // Catch: java.lang.Throwable -> L2f
+            java.lang.reflect.Constructor r2 = r2.getConstructor(r5)     // Catch: java.lang.Throwable -> L2f
+            java.lang.Object[] r5 = new java.lang.Object[r4]     // Catch: java.lang.Throwable -> L2f
+            java.lang.Boolean r6 = java.lang.Boolean.FALSE     // Catch: java.lang.Throwable -> L2f
+            r5[r3] = r6     // Catch: java.lang.Throwable -> L2f
+            java.lang.Object r2 = r2.newInstance(r5)     // Catch: java.lang.Throwable -> L2f
+            com.fyber.inneractive.sdk.protobuf.k1 r2 = (com.fyber.inneractive.sdk.protobuf.k1) r2     // Catch: java.lang.Throwable -> L2f
+            goto L30
+        L2f:
+            r2 = r1
+        L30:
+            com.fyber.inneractive.sdk.protobuf.e1.b = r2
+            java.lang.Class r0 = java.lang.Class.forName(r0)     // Catch: java.lang.Throwable -> L37
+            goto L38
+        L37:
+            r0 = r1
+        L38:
+            if (r0 != 0) goto L3b
+            goto L52
+        L3b:
+            java.lang.Class[] r2 = new java.lang.Class[r4]     // Catch: java.lang.Throwable -> L52
+            java.lang.Class r5 = java.lang.Boolean.TYPE     // Catch: java.lang.Throwable -> L52
+            r2[r3] = r5     // Catch: java.lang.Throwable -> L52
+            java.lang.reflect.Constructor r0 = r0.getConstructor(r2)     // Catch: java.lang.Throwable -> L52
+            java.lang.Object[] r2 = new java.lang.Object[r4]     // Catch: java.lang.Throwable -> L52
+            java.lang.Boolean r4 = java.lang.Boolean.TRUE     // Catch: java.lang.Throwable -> L52
+            r2[r3] = r4     // Catch: java.lang.Throwable -> L52
+            java.lang.Object r0 = r0.newInstance(r2)     // Catch: java.lang.Throwable -> L52
+            com.fyber.inneractive.sdk.protobuf.k1 r0 = (com.fyber.inneractive.sdk.protobuf.k1) r0     // Catch: java.lang.Throwable -> L52
+            r1 = r0
+        L52:
+            com.fyber.inneractive.sdk.protobuf.e1.c = r1
+            com.fyber.inneractive.sdk.protobuf.m1 r0 = new com.fyber.inneractive.sdk.protobuf.m1
+            r0.<init>()
+            com.fyber.inneractive.sdk.protobuf.e1.d = r0
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.e1.<clinit>():void");
+    }
+
+    public static void a(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.a(i, ((Boolean) list.get(i2)).booleanValue());
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            ((Boolean) list.get(i4)).booleanValue();
+            Logger logger = l.b;
+            i3++;
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.a(((Boolean) list.get(i2)).booleanValue() ? (byte) 1 : (byte) 0);
+            i2++;
+        }
+    }
+
+    public static void b(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                l lVar = mVar.a;
+                double doubleValue = ((Double) list.get(i2)).doubleValue();
+                lVar.getClass();
+                lVar.a(i, Double.doubleToRawLongBits(doubleValue));
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            ((Double) list.get(i4)).doubleValue();
+            Logger logger = l.b;
+            i3 += 8;
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            l lVar2 = mVar.a;
+            double doubleValue2 = ((Double) list.get(i2)).doubleValue();
+            lVar2.getClass();
+            lVar2.c(Double.doubleToRawLongBits(doubleValue2));
+            i2++;
+        }
+    }
+
+    public static void c(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.c(i, ((Integer) list.get(i2)).intValue());
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            i3 += l.c(((Integer) list.get(i4)).intValue());
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.h(((Integer) list.get(i2)).intValue());
+            i2++;
+        }
+    }
+
+    public static void d(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.b(i, ((Integer) list.get(i2)).intValue());
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            ((Integer) list.get(i4)).intValue();
+            Logger logger = l.b;
+            i3 += 4;
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.g(((Integer) list.get(i2)).intValue());
+            i2++;
+        }
+    }
+
+    public static void e(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.a(i, ((Long) list.get(i2)).longValue());
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            ((Long) list.get(i4)).longValue();
+            Logger logger = l.b;
+            i3 += 8;
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.c(((Long) list.get(i2)).longValue());
+            i2++;
+        }
+    }
+
+    public static void f(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                l lVar = mVar.a;
+                float floatValue = ((Float) list.get(i2)).floatValue();
+                lVar.getClass();
+                lVar.b(i, Float.floatToRawIntBits(floatValue));
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            ((Float) list.get(i4)).floatValue();
+            Logger logger = l.b;
+            i3 += 4;
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            l lVar2 = mVar.a;
+            float floatValue2 = ((Float) list.get(i2)).floatValue();
+            lVar2.getClass();
+            lVar2.g(Float.floatToRawIntBits(floatValue2));
+            i2++;
+        }
+    }
+
+    public static void g(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.c(i, ((Integer) list.get(i2)).intValue());
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            i3 += l.c(((Integer) list.get(i4)).intValue());
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.h(((Integer) list.get(i2)).intValue());
+            i2++;
+        }
+    }
+
+    public static void h(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.b(i, ((Long) list.get(i2)).longValue());
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            i3 += l.a(((Long) list.get(i4)).longValue());
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.d(((Long) list.get(i2)).longValue());
+            i2++;
+        }
+    }
+
+    public static void i(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.b(i, ((Integer) list.get(i2)).intValue());
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            ((Integer) list.get(i4)).intValue();
+            Logger logger = l.b;
+            i3 += 4;
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.g(((Integer) list.get(i2)).intValue());
+            i2++;
+        }
+    }
+
+    public static void j(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.a(i, ((Long) list.get(i2)).longValue());
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            ((Long) list.get(i4)).longValue();
+            Logger logger = l.b;
+            i3 += 8;
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.c(((Long) list.get(i2)).longValue());
+            i2++;
+        }
+    }
+
+    public static void k(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.e(i, l.f(((Integer) list.get(i2)).intValue()));
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            i3 += l.e(l.f(((Integer) list.get(i4)).intValue()));
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.i(l.f(((Integer) list.get(i2)).intValue()));
+            i2++;
+        }
+    }
+
+    public static void l(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.b(i, l.b(((Long) list.get(i2)).longValue()));
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            i3 += l.a(l.b(((Long) list.get(i4)).longValue()));
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.d(l.b(((Long) list.get(i2)).longValue()));
+            i2++;
+        }
+    }
+
+    public static void m(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.e(i, ((Integer) list.get(i2)).intValue());
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            i3 += l.e(((Integer) list.get(i4)).intValue());
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.i(((Integer) list.get(i2)).intValue());
+            i2++;
+        }
+    }
+
+    public static void n(int i, List list, m mVar, boolean z) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        int i2 = 0;
+        if (!z) {
+            mVar.getClass();
+            while (i2 < list.size()) {
+                mVar.a.b(i, ((Long) list.get(i2)).longValue());
+                i2++;
+            }
+            return;
+        }
+        mVar.a.d(i, 2);
+        int i3 = 0;
+        for (int i4 = 0; i4 < list.size(); i4++) {
+            i3 += l.a(((Long) list.get(i4)).longValue());
+        }
+        mVar.a.i(i3);
+        while (i2 < list.size()) {
+            mVar.a.d(((Long) list.get(i2)).longValue());
+            i2++;
+        }
+    }
+
+    public static int d(List<Integer> list) {
+        int i;
+        int size = list.size();
+        int i2 = 0;
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof x) {
+            x xVar = (x) list;
+            i = 0;
+            while (i2 < size) {
+                i += l.c(xVar.d(i2));
+                i2++;
+            }
+        } else {
+            i = 0;
+            while (i2 < size) {
+                i += l.c(list.get(i2).intValue());
+                i2++;
+            }
+        }
+        return i;
+    }
+
+    public static int e(List<Long> list) {
+        int i;
+        int size = list.size();
+        int i2 = 0;
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof f0) {
+            f0 f0Var = (f0) list;
+            i = 0;
+            while (i2 < size) {
+                if (i2 >= 0 && i2 < f0Var.c) {
+                    i += l.a(f0Var.b[i2]);
+                    i2++;
+                } else {
+                    StringBuilder a2 = com.fyber.inneractive.sdk.bidder.h.a("Index:", i2, ", Size:");
+                    a2.append(f0Var.c);
+                    throw new IndexOutOfBoundsException(a2.toString());
+                }
+            }
+        } else {
+            i = 0;
+            while (i2 < size) {
+                i += l.a(list.get(i2).longValue());
+                i2++;
+            }
+        }
+        return i;
+    }
+
+    public static int g(List<Long> list) {
+        int i;
+        int size = list.size();
+        int i2 = 0;
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof f0) {
+            f0 f0Var = (f0) list;
+            i = 0;
+            while (i2 < size) {
+                if (i2 >= 0 && i2 < f0Var.c) {
+                    i += l.a(l.b(f0Var.b[i2]));
+                    i2++;
+                } else {
+                    StringBuilder a2 = com.fyber.inneractive.sdk.bidder.h.a("Index:", i2, ", Size:");
+                    a2.append(f0Var.c);
+                    throw new IndexOutOfBoundsException(a2.toString());
+                }
+            }
+        } else {
+            i = 0;
+            while (i2 < size) {
+                i += l.a(l.b(list.get(i2).longValue()));
+                i2++;
+            }
+        }
+        return i;
+    }
+
+    public static void a(int i, List list, m mVar) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        mVar.getClass();
+        for (int i2 = 0; i2 < list.size(); i2++) {
+            mVar.a.b(i, (i) list.get(i2));
+        }
+    }
+
+    public static void b(int i, List list, m mVar) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        mVar.getClass();
+        int i2 = 0;
+        if (list instanceof d0) {
+            d0 d0Var = (d0) list;
+            while (i2 < list.size()) {
+                Object b2 = d0Var.b(i2);
+                if (b2 instanceof String) {
+                    mVar.a.a((String) b2, i);
+                } else {
+                    mVar.a.b(i, (i) b2);
+                }
+                i2++;
+            }
+            return;
+        }
+        while (i2 < list.size()) {
+            mVar.a.a((String) list.get(i2), i);
+            i2++;
+        }
+    }
+
+    public static int c(List<?> list) {
+        return list.size() * 8;
+    }
+
+    public static int f(List<Integer> list) {
+        int i;
+        int size = list.size();
+        int i2 = 0;
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof x) {
+            x xVar = (x) list;
+            i = 0;
+            while (i2 < size) {
+                i += l.e(l.f(xVar.d(i2)));
+                i2++;
+            }
+        } else {
+            i = 0;
+            while (i2 < size) {
+                i += l.e(l.f(list.get(i2).intValue()));
+                i2++;
+            }
+        }
+        return i;
+    }
+
+    public static int h(List<Integer> list) {
+        int i;
+        int size = list.size();
+        int i2 = 0;
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof x) {
+            x xVar = (x) list;
+            i = 0;
+            while (i2 < size) {
+                i += l.e(xVar.d(i2));
+                i2++;
+            }
+        } else {
+            i = 0;
+            while (i2 < size) {
+                i += l.e(list.get(i2).intValue());
+                i2++;
+            }
+        }
+        return i;
+    }
+
+    public static int i(List<Long> list) {
+        int i;
+        int size = list.size();
+        int i2 = 0;
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof f0) {
+            f0 f0Var = (f0) list;
+            i = 0;
+            while (i2 < size) {
+                if (i2 >= 0 && i2 < f0Var.c) {
+                    i += l.a(f0Var.b[i2]);
+                    i2++;
+                } else {
+                    StringBuilder a2 = com.fyber.inneractive.sdk.bidder.h.a("Index:", i2, ", Size:");
+                    a2.append(f0Var.c);
+                    throw new IndexOutOfBoundsException(a2.toString());
+                }
+            }
+        } else {
+            i = 0;
+            while (i2 < size) {
+                i += l.a(list.get(i2).longValue());
+                i2++;
+            }
+        }
+        return i;
+    }
+
+    public static int c(int i, List<?> list) {
+        int size = list.size();
+        int i2 = 0;
+        if (size == 0) {
+            return 0;
+        }
+        int d2 = l.d(i) * size;
+        if (list instanceof d0) {
+            d0 d0Var = (d0) list;
+            while (i2 < size) {
+                Object b2 = d0Var.b(i2);
+                if (b2 instanceof i) {
+                    int size2 = ((i) b2).size();
+                    d2 = l.e(size2) + size2 + d2;
+                } else {
+                    d2 = l.a((String) b2) + d2;
+                }
+                i2++;
+            }
+        } else {
+            while (i2 < size) {
+                Object obj = list.get(i2);
+                if (obj instanceof i) {
+                    int size3 = ((i) obj).size();
+                    d2 = l.e(size3) + size3 + d2;
+                } else {
+                    d2 = l.a((String) obj) + d2;
+                }
+                i2++;
+            }
+        }
+        return d2;
+    }
+
+    public static void a(int i, List list, m mVar, d1 d1Var) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        mVar.getClass();
+        for (int i2 = 0; i2 < list.size(); i2++) {
+            mVar.a(i, d1Var, list.get(i2));
+        }
+    }
+
+    public static int a(List<Integer> list) {
+        int i;
+        int size = list.size();
+        int i2 = 0;
+        if (size == 0) {
+            return 0;
+        }
+        if (list instanceof x) {
+            x xVar = (x) list;
+            i = 0;
+            while (i2 < size) {
+                i += l.c(xVar.d(i2));
+                i2++;
+            }
+        } else {
+            i = 0;
+            while (i2 < size) {
+                i += l.c(list.get(i2).intValue());
+                i2++;
+            }
+        }
+        return i;
+    }
+
+    public static void b(int i, List list, m mVar, d1 d1Var) throws IOException {
+        if (list == null || list.isEmpty()) {
+            return;
+        }
+        mVar.getClass();
+        for (int i2 = 0; i2 < list.size(); i2++) {
+            mVar.b(i, d1Var, list.get(i2));
+        }
+    }
+
+    public static int b(List<?> list) {
+        return list.size() * 4;
+    }
+
+    public static int b(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        return l.b(i) * size;
+    }
+
+    public static int a(int i, List list) {
+        int size = list.size();
+        if (size == 0) {
+            return 0;
+        }
+        return l.a(i) * size;
+    }
+
+    public static boolean a(Object obj, Object obj2) {
+        return obj == obj2 || (obj != null && obj.equals(obj2));
+    }
+
+    public static Object a(int i, AbstractList abstractList, y.d dVar, Object obj, k1 k1Var) {
+        if (dVar == null) {
+            return obj;
+        }
+        int size = abstractList.size();
+        int i2 = 0;
+        for (int i3 = 0; i3 < size; i3++) {
+            int intValue = ((Integer) abstractList.get(i3)).intValue();
+            if (dVar.a(intValue) != null) {
+                if (i3 != i2) {
+                    abstractList.set(i2, Integer.valueOf(intValue));
+                }
+                i2++;
+            } else {
+                if (obj == null) {
+                    obj = k1Var.a();
+                }
+                k1Var.b(i, intValue, obj);
+            }
+        }
+        if (i2 != size) {
+            abstractList.subList(i2, size).clear();
+        }
+        return obj;
+    }
+
+    public static <UT, UB> UB a(int i, List<Integer> list, y.e eVar, UB ub, k1<UT, UB> k1Var) {
+        if (eVar == null) {
+            return ub;
+        }
+        if (list instanceof RandomAccess) {
+            int size = list.size();
+            int i2 = 0;
+            for (int i3 = 0; i3 < size; i3++) {
+                int intValue = list.get(i3).intValue();
+                if (eVar.a()) {
+                    if (i3 != i2) {
+                        list.set(i2, Integer.valueOf(intValue));
+                    }
+                    i2++;
+                } else {
+                    if (ub == null) {
+                        ub = (UB) k1Var.a();
+                    }
+                    k1Var.b(i, intValue, ub);
+                }
+            }
+            if (i2 != size) {
+                list.subList(i2, size).clear();
+            }
+        } else {
+            Iterator<Integer> it = list.iterator();
+            while (it.hasNext()) {
+                int intValue2 = it.next().intValue();
+                if (!eVar.a()) {
+                    if (ub == null) {
+                        ub = (UB) k1Var.a();
+                    }
+                    k1Var.b(i, intValue2, ub);
+                    it.remove();
+                }
+            }
+        }
+        return ub;
+    }
+
+    public static <UT, UB> UB a(int i, int i2, UB ub, k1<UT, UB> k1Var) {
+        if (ub == null) {
+            ub = (UB) k1Var.a();
+        }
+        k1Var.b(i, i2, ub);
+        return ub;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/f0.java

@@ -0,0 +1,223 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.nio.charset.Charset;
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.RandomAccess;
+
+/* loaded from: classes2.dex */
+public final class f0 extends c<Long> implements y.i, RandomAccess, x0 {
+    public static final f0 d;
+    public long[] b;
+    public int c;
+
+    static {
+        f0 f0Var = new f0(new long[0], 0);
+        d = f0Var;
+        f0Var.a = false;
+    }
+
+    public f0() {
+        this(new long[10], 0);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final void add(int i, Object obj) {
+        int i2;
+        long longValue = ((Long) obj).longValue();
+        e();
+        if (i < 0 || i > (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        long[] jArr = this.b;
+        if (i2 < jArr.length) {
+            System.arraycopy(jArr, i, jArr, i + 1, i2 - i);
+        } else {
+            long[] jArr2 = new long[((i2 * 3) / 2) + 1];
+            System.arraycopy(jArr, 0, jArr2, 0, i);
+            System.arraycopy(this.b, i, jArr2, i + 1, this.c - i);
+            this.b = jArr2;
+        }
+        this.b[i] = longValue;
+        this.c++;
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean addAll(Collection<? extends Long> collection) {
+        e();
+        Charset charset = y.a;
+        collection.getClass();
+        if (!(collection instanceof f0)) {
+            return super.addAll(collection);
+        }
+        f0 f0Var = (f0) collection;
+        int i = f0Var.c;
+        if (i == 0) {
+            return false;
+        }
+        int i2 = this.c;
+        if (Integer.MAX_VALUE - i2 < i) {
+            throw new OutOfMemoryError();
+        }
+        int i3 = i2 + i;
+        long[] jArr = this.b;
+        if (i3 > jArr.length) {
+            this.b = Arrays.copyOf(jArr, i3);
+        }
+        System.arraycopy(f0Var.b, 0, this.b, this.c, f0Var.c);
+        this.c = i3;
+        ((AbstractList) this).modCount++;
+        return true;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean contains(Object obj) {
+        return indexOf(obj) != -1;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.Collection, java.util.List
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof f0)) {
+            return super.equals(obj);
+        }
+        f0 f0Var = (f0) obj;
+        if (this.c != f0Var.c) {
+            return false;
+        }
+        long[] jArr = f0Var.b;
+        for (int i = 0; i < this.c; i++) {
+            if (this.b[i] != jArr[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final int indexOf(Object obj) {
+        if (!(obj instanceof Long)) {
+            return -1;
+        }
+        long longValue = ((Long) obj).longValue();
+        int i = this.c;
+        for (int i2 = 0; i2 < i; i2++) {
+            if (this.b[i2] == longValue) {
+                return i2;
+            }
+        }
+        return -1;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.List
+    public final Object remove(int i) {
+        int i2;
+        e();
+        if (i < 0 || i >= (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        long[] jArr = this.b;
+        long j = jArr[i];
+        if (i < i2 - 1) {
+            System.arraycopy(jArr, i + 1, jArr, i, (i2 - i) - 1);
+        }
+        this.c--;
+        ((AbstractList) this).modCount++;
+        return Long.valueOf(j);
+    }
+
+    @Override // java.util.AbstractList
+    public final void removeRange(int i, int i2) {
+        e();
+        if (i2 < i) {
+            throw new IndexOutOfBoundsException("toIndex < fromIndex");
+        }
+        long[] jArr = this.b;
+        System.arraycopy(jArr, i2, jArr, i, this.c - i2);
+        this.c -= i2 - i;
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object set(int i, Object obj) {
+        long longValue = ((Long) obj).longValue();
+        e();
+        if (i < 0 || i >= this.c) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        long[] jArr = this.b;
+        long j = jArr[i];
+        jArr[i] = longValue;
+        return Long.valueOf(j);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.c;
+    }
+
+    public f0(long[] jArr, int i) {
+        this.b = jArr;
+        this.c = i;
+    }
+
+    public final void a(long j) {
+        e();
+        int i = this.c;
+        long[] jArr = this.b;
+        if (i == jArr.length) {
+            long[] jArr2 = new long[((i * 3) / 2) + 1];
+            System.arraycopy(jArr, 0, jArr2, 0, i);
+            this.b = jArr2;
+        }
+        long[] jArr3 = this.b;
+        int i2 = this.c;
+        this.c = i2 + 1;
+        jArr3[i2] = j;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object get(int i) {
+        if (i >= 0 && i < this.c) {
+            return Long.valueOf(this.b[i]);
+        }
+        StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+        a.append(this.c);
+        throw new IndexOutOfBoundsException(a.toString());
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.Collection, java.util.List
+    public final int hashCode() {
+        int i = 1;
+        for (int i2 = 0; i2 < this.c; i2++) {
+            i = (i * 31) + y.a(this.b[i2]);
+        }
+        return i;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.y.j
+    /* renamed from: c, reason: merged with bridge method [inline-methods] */
+    public final f0 a(int i) {
+        if (i >= this.c) {
+            return new f0(Arrays.copyOf(this.b, i), this.c);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean add(Object obj) {
+        a(((Long) obj).longValue());
+        return true;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/f1.java

@@ -0,0 +1,36 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.u;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public final class f1 extends g1<Object, Object> {
+    public f1(int i) {
+        super(i, 0);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.g1, java.util.AbstractMap, java.util.Map
+    public final /* bridge */ /* synthetic */ Object put(Object obj, Object obj2) {
+        return put((Comparable) obj, obj2);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.g1
+    public final void c() {
+        if (!this.d) {
+            for (int i = 0; i < this.b.size(); i++) {
+                Map.Entry<Object, Object> a = a(i);
+                if (((u.b) a.getKey()).b()) {
+                    a.setValue(Collections.unmodifiableList((List) a.getValue()));
+                }
+            }
+            for (Map.Entry<Object, Object> entry : b()) {
+                if (((u.b) entry.getKey()).b()) {
+                    entry.setValue(Collections.unmodifiableList((List) entry.getValue()));
+                }
+            }
+        }
+        super.c();
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/g.java

@@ -0,0 +1,226 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.nio.charset.Charset;
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.RandomAccess;
+
+/* loaded from: classes2.dex */
+public final class g extends c<Boolean> implements y.a, RandomAccess, x0 {
+    public static final g d;
+    public boolean[] b;
+    public int c;
+
+    static {
+        g gVar = new g(new boolean[0], 0);
+        d = gVar;
+        gVar.a = false;
+    }
+
+    public g() {
+        this(new boolean[10], 0);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final void add(int i, Object obj) {
+        int i2;
+        boolean booleanValue = ((Boolean) obj).booleanValue();
+        e();
+        if (i < 0 || i > (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        boolean[] zArr = this.b;
+        if (i2 < zArr.length) {
+            System.arraycopy(zArr, i, zArr, i + 1, i2 - i);
+        } else {
+            boolean[] zArr2 = new boolean[((i2 * 3) / 2) + 1];
+            System.arraycopy(zArr, 0, zArr2, 0, i);
+            System.arraycopy(this.b, i, zArr2, i + 1, this.c - i);
+            this.b = zArr2;
+        }
+        this.b[i] = booleanValue;
+        this.c++;
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean addAll(Collection<? extends Boolean> collection) {
+        e();
+        Charset charset = y.a;
+        collection.getClass();
+        if (!(collection instanceof g)) {
+            return super.addAll(collection);
+        }
+        g gVar = (g) collection;
+        int i = gVar.c;
+        if (i == 0) {
+            return false;
+        }
+        int i2 = this.c;
+        if (Integer.MAX_VALUE - i2 < i) {
+            throw new OutOfMemoryError();
+        }
+        int i3 = i2 + i;
+        boolean[] zArr = this.b;
+        if (i3 > zArr.length) {
+            this.b = Arrays.copyOf(zArr, i3);
+        }
+        System.arraycopy(gVar.b, 0, this.b, this.c, gVar.c);
+        this.c = i3;
+        ((AbstractList) this).modCount++;
+        return true;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean contains(Object obj) {
+        return indexOf(obj) != -1;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.Collection, java.util.List
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof g)) {
+            return super.equals(obj);
+        }
+        g gVar = (g) obj;
+        if (this.c != gVar.c) {
+            return false;
+        }
+        boolean[] zArr = gVar.b;
+        for (int i = 0; i < this.c; i++) {
+            if (this.b[i] != zArr[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final int indexOf(Object obj) {
+        if (!(obj instanceof Boolean)) {
+            return -1;
+        }
+        boolean booleanValue = ((Boolean) obj).booleanValue();
+        int i = this.c;
+        for (int i2 = 0; i2 < i; i2++) {
+            if (this.b[i2] == booleanValue) {
+                return i2;
+            }
+        }
+        return -1;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.List
+    public final Object remove(int i) {
+        int i2;
+        e();
+        if (i < 0 || i >= (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        boolean[] zArr = this.b;
+        boolean z = zArr[i];
+        if (i < i2 - 1) {
+            System.arraycopy(zArr, i + 1, zArr, i, (i2 - i) - 1);
+        }
+        this.c--;
+        ((AbstractList) this).modCount++;
+        return Boolean.valueOf(z);
+    }
+
+    @Override // java.util.AbstractList
+    public final void removeRange(int i, int i2) {
+        e();
+        if (i2 < i) {
+            throw new IndexOutOfBoundsException("toIndex < fromIndex");
+        }
+        boolean[] zArr = this.b;
+        System.arraycopy(zArr, i2, zArr, i, this.c - i2);
+        this.c -= i2 - i;
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object set(int i, Object obj) {
+        boolean booleanValue = ((Boolean) obj).booleanValue();
+        e();
+        if (i < 0 || i >= this.c) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        boolean[] zArr = this.b;
+        boolean z = zArr[i];
+        zArr[i] = booleanValue;
+        return Boolean.valueOf(z);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.c;
+    }
+
+    public g(boolean[] zArr, int i) {
+        this.b = zArr;
+        this.c = i;
+    }
+
+    public final void a(boolean z) {
+        e();
+        int i = this.c;
+        boolean[] zArr = this.b;
+        if (i == zArr.length) {
+            boolean[] zArr2 = new boolean[((i * 3) / 2) + 1];
+            System.arraycopy(zArr, 0, zArr2, 0, i);
+            this.b = zArr2;
+        }
+        boolean[] zArr3 = this.b;
+        int i2 = this.c;
+        this.c = i2 + 1;
+        zArr3[i2] = z;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object get(int i) {
+        if (i >= 0 && i < this.c) {
+            return Boolean.valueOf(this.b[i]);
+        }
+        StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+        a.append(this.c);
+        throw new IndexOutOfBoundsException(a.toString());
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.Collection, java.util.List
+    public final int hashCode() {
+        int i = 1;
+        for (int i2 = 0; i2 < this.c; i2++) {
+            int i3 = i * 31;
+            boolean z = this.b[i2];
+            Charset charset = y.a;
+            i = i3 + (z ? 1231 : 1237);
+        }
+        return i;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.y.j
+    /* renamed from: c, reason: merged with bridge method [inline-methods] */
+    public final g a(int i) {
+        if (i >= this.c) {
+            return new g(Arrays.copyOf(this.b, i), this.c);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean add(Object obj) {
+        a(((Boolean) obj).booleanValue());
+        return true;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/g0.java

@@ -0,0 +1,68 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class g0 {
+    public static final a b = new a();
+    public final n0 a;
+
+    public class a implements n0 {
+        @Override // com.fyber.inneractive.sdk.protobuf.n0
+        public final m0 a(Class<?> cls) {
+            throw new IllegalStateException("This should never be called.");
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.n0
+        public final boolean b(Class<?> cls) {
+            return false;
+        }
+    }
+
+    public static class b implements n0 {
+        public final n0[] a;
+
+        public b(n0... n0VarArr) {
+            this.a = n0VarArr;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.n0
+        public final m0 a(Class<?> cls) {
+            for (n0 n0Var : this.a) {
+                if (n0Var.b(cls)) {
+                    return n0Var.a(cls);
+                }
+            }
+            throw new UnsupportedOperationException("No factory is available for message type: ".concat(cls.getName()));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.n0
+        public final boolean b(Class<?> cls) {
+            for (n0 n0Var : this.a) {
+                if (n0Var.b(cls)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    public g0() {
+        this(a());
+    }
+
+    public static b a() {
+        n0 n0Var;
+        n0[] n0VarArr = new n0[2];
+        n0VarArr[0] = w.a;
+        try {
+            n0Var = (n0) Class.forName("com.google.protobuf.DescriptorMessageInfoFactory").getDeclaredMethod("getInstance", new Class[0]).invoke(null, new Object[0]);
+        } catch (Exception unused) {
+            n0Var = b;
+        }
+        n0VarArr[1] = n0Var;
+        return new b(n0VarArr);
+    }
+
+    public g0(b bVar) {
+        this.a = (n0) y.a(bVar, "messageInfoFactory");
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/g1.java

@@ -0,0 +1,549 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.ironsource.v8;
+import java.lang.Comparable;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/* loaded from: classes2.dex */
+public class g1<K extends Comparable<K>, V> extends AbstractMap<K, V> {
+    public static final /* synthetic */ int h = 0;
+    public final int a;
+    public List<g1<K, V>.d> b;
+    public Map<K, V> c;
+    public boolean d;
+    public volatile g1<K, V>.f e;
+    public Map<K, V> f;
+    public volatile g1<K, V>.b g;
+
+    public class a implements Iterator<Map.Entry<K, V>> {
+        public int a;
+        public Iterator<Map.Entry<K, V>> b;
+
+        public a() {
+            this.a = g1.this.b.size();
+        }
+
+        @Override // java.util.Iterator
+        public final void remove() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.Iterator
+        public final boolean hasNext() {
+            int i = this.a;
+            if (i <= 0 || i > g1.this.b.size()) {
+                if (this.b == null) {
+                    this.b = g1.this.f.entrySet().iterator();
+                }
+                if (!this.b.hasNext()) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        @Override // java.util.Iterator
+        public final Object next() {
+            if (this.b == null) {
+                this.b = g1.this.f.entrySet().iterator();
+            }
+            if (this.b.hasNext()) {
+                if (this.b == null) {
+                    this.b = g1.this.f.entrySet().iterator();
+                }
+                return this.b.next();
+            }
+            List<g1<K, V>.d> list = g1.this.b;
+            int i = this.a - 1;
+            this.a = i;
+            return list.get(i);
+        }
+    }
+
+    public class b extends g1<K, V>.f {
+        public b() {
+            super(g1.this, 0);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.g1.f, java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
+        public final Iterator<Map.Entry<K, V>> iterator() {
+            return new a();
+        }
+    }
+
+    public static class c {
+        public static final a a = new a();
+        public static final b b = new b();
+
+        public class a implements Iterator<Object> {
+            @Override // java.util.Iterator
+            public final boolean hasNext() {
+                return false;
+            }
+
+            @Override // java.util.Iterator
+            public final Object next() {
+                throw new NoSuchElementException();
+            }
+
+            @Override // java.util.Iterator
+            public final void remove() {
+                throw new UnsupportedOperationException();
+            }
+        }
+
+        public class b implements Iterable<Object> {
+            @Override // java.lang.Iterable
+            public final Iterator<Object> iterator() {
+                return c.a;
+            }
+        }
+    }
+
+    public class d implements Map.Entry<K, V>, Comparable<g1<K, V>.d> {
+        public final K a;
+        public V b;
+
+        public d() {
+            throw null;
+        }
+
+        public d(K k, V v) {
+            this.a = k;
+            this.b = v;
+        }
+
+        @Override // java.lang.Comparable
+        public final int compareTo(Object obj) {
+            return this.a.compareTo(((d) obj).a);
+        }
+
+        @Override // java.util.Map.Entry
+        public final boolean equals(Object obj) {
+            if (obj == this) {
+                return true;
+            }
+            if (!(obj instanceof Map.Entry)) {
+                return false;
+            }
+            Map.Entry entry = (Map.Entry) obj;
+            K k = this.a;
+            Object key = entry.getKey();
+            if (k != null ? k.equals(key) : key == null) {
+                V v = this.b;
+                Object value = entry.getValue();
+                if (v == null) {
+                    if (value == null) {
+                        return true;
+                    }
+                } else if (v.equals(value)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        @Override // java.util.Map.Entry
+        public final Object getKey() {
+            return this.a;
+        }
+
+        @Override // java.util.Map.Entry
+        public final V getValue() {
+            return this.b;
+        }
+
+        @Override // java.util.Map.Entry
+        public final int hashCode() {
+            K k = this.a;
+            int hashCode = k == null ? 0 : k.hashCode();
+            V v = this.b;
+            return hashCode ^ (v != null ? v.hashCode() : 0);
+        }
+
+        @Override // java.util.Map.Entry
+        public final V setValue(V v) {
+            g1 g1Var = g1.this;
+            int i = g1.h;
+            g1Var.a();
+            V v2 = this.b;
+            this.b = v;
+            return v2;
+        }
+
+        public final String toString() {
+            return this.a + v8.i.b + this.b;
+        }
+    }
+
+    public class e implements Iterator<Map.Entry<K, V>> {
+        public int a = -1;
+        public boolean b;
+        public Iterator<Map.Entry<K, V>> c;
+
+        public e() {
+        }
+
+        @Override // java.util.Iterator
+        public final boolean hasNext() {
+            if (this.a + 1 < g1.this.b.size()) {
+                return true;
+            }
+            if (!g1.this.c.isEmpty()) {
+                if (this.c == null) {
+                    this.c = g1.this.c.entrySet().iterator();
+                }
+                if (this.c.hasNext()) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        @Override // java.util.Iterator
+        public final Object next() {
+            this.b = true;
+            int i = this.a + 1;
+            this.a = i;
+            if (i < g1.this.b.size()) {
+                return g1.this.b.get(this.a);
+            }
+            if (this.c == null) {
+                this.c = g1.this.c.entrySet().iterator();
+            }
+            return this.c.next();
+        }
+
+        @Override // java.util.Iterator
+        public final void remove() {
+            if (this.b) {
+                this.b = false;
+                g1 g1Var = g1.this;
+                int i = g1.h;
+                g1Var.a();
+                if (this.a < g1.this.b.size()) {
+                    g1 g1Var2 = g1.this;
+                    int i2 = this.a;
+                    this.a = i2 - 1;
+                    g1Var2.c(i2);
+                    return;
+                }
+                if (this.c == null) {
+                    this.c = g1.this.c.entrySet().iterator();
+                }
+                this.c.remove();
+                return;
+            }
+            throw new IllegalStateException("remove() was called before next()");
+        }
+    }
+
+    public class f extends AbstractSet<Map.Entry<K, V>> {
+        public f() {
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+        public final boolean add(Object obj) {
+            Map.Entry entry = (Map.Entry) obj;
+            if (contains(entry)) {
+                return false;
+            }
+            g1.this.put((Comparable) entry.getKey(), entry.getValue());
+            return true;
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+        public final void clear() {
+            g1.this.clear();
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+        public final boolean contains(Object obj) {
+            Map.Entry entry = (Map.Entry) obj;
+            Object obj2 = g1.this.get(entry.getKey());
+            Object value = entry.getValue();
+            return obj2 == value || (obj2 != null && obj2.equals(value));
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.Set
+        public Iterator<Map.Entry<K, V>> iterator() {
+            return new e();
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+        public final boolean remove(Object obj) {
+            Map.Entry entry = (Map.Entry) obj;
+            if (!contains(entry)) {
+                return false;
+            }
+            g1.this.remove(entry.getKey());
+            return true;
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.Set
+        public final int size() {
+            return g1.this.size();
+        }
+
+        public /* synthetic */ f(g1 g1Var, int i) {
+            this();
+        }
+    }
+
+    public /* synthetic */ g1(int i, int i2) {
+        this(i);
+    }
+
+    public static f1 b(int i) {
+        return new f1(i);
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final void clear() {
+        a();
+        if (!this.b.isEmpty()) {
+            this.b.clear();
+        }
+        if (this.c.isEmpty()) {
+            return;
+        }
+        this.c.clear();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // java.util.AbstractMap, java.util.Map
+    public final boolean containsKey(Object obj) {
+        Comparable comparable = (Comparable) obj;
+        return a((g1<K, V>) comparable) >= 0 || this.c.containsKey(comparable);
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof g1)) {
+            return super.equals(obj);
+        }
+        g1 g1Var = (g1) obj;
+        int size = size();
+        if (size != g1Var.size()) {
+            return false;
+        }
+        int size2 = this.b.size();
+        if (size2 != g1Var.b.size()) {
+            return entrySet().equals(g1Var.entrySet());
+        }
+        for (int i = 0; i < size2; i++) {
+            if (!a(i).equals(g1Var.a(i))) {
+                return false;
+            }
+        }
+        if (size2 != size) {
+            return this.c.equals(g1Var.c);
+        }
+        return true;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // java.util.AbstractMap, java.util.Map
+    public final V get(Object obj) {
+        Comparable comparable = (Comparable) obj;
+        int a2 = a((g1<K, V>) comparable);
+        return a2 >= 0 ? this.b.get(a2).b : this.c.get(comparable);
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final int hashCode() {
+        int size = this.b.size();
+        int i = 0;
+        for (int i2 = 0; i2 < size; i2++) {
+            i += this.b.get(i2).hashCode();
+        }
+        return this.c.size() > 0 ? i + this.c.hashCode() : i;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // java.util.AbstractMap, java.util.Map
+    public final V remove(Object obj) {
+        a();
+        Comparable comparable = (Comparable) obj;
+        int a2 = a((g1<K, V>) comparable);
+        if (a2 < 0) {
+            if (this.c.isEmpty()) {
+                return null;
+            }
+            return this.c.remove(comparable);
+        }
+        a();
+        V v = this.b.remove(a2).b;
+        if (!this.c.isEmpty()) {
+            a();
+            if (this.c.isEmpty() && !(this.c instanceof TreeMap)) {
+                TreeMap treeMap = new TreeMap();
+                this.c = treeMap;
+                this.f = treeMap.descendingMap();
+            }
+            Iterator it = ((SortedMap) this.c).entrySet().iterator();
+            List<g1<K, V>.d> list = this.b;
+            Map.Entry entry = (Map.Entry) it.next();
+            list.add(new d((Comparable) entry.getKey(), entry.getValue()));
+            it.remove();
+        }
+        return v;
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final int size() {
+        return this.c.size() + this.b.size();
+    }
+
+    public g1(int i) {
+        this.a = i;
+        this.b = Collections.emptyList();
+        this.c = Collections.emptyMap();
+        this.f = Collections.emptyMap();
+    }
+
+    public final Map.Entry<K, V> a(int i) {
+        return this.b.get(i);
+    }
+
+    public final Iterable<Map.Entry<K, V>> b() {
+        return this.c.isEmpty() ? c.b : this.c.entrySet();
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final Set<Map.Entry<K, V>> entrySet() {
+        if (this.e == null) {
+            this.e = new f();
+        }
+        return this.e;
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    /* renamed from: a, reason: merged with bridge method [inline-methods] */
+    public final V put(K k, V v) {
+        a();
+        int a2 = a((g1<K, V>) k);
+        if (a2 >= 0) {
+            return this.b.get(a2).setValue(v);
+        }
+        a();
+        if (this.b.isEmpty() && !(this.b instanceof ArrayList)) {
+            this.b = new ArrayList(this.a);
+        }
+        int i = -(a2 + 1);
+        if (i >= this.a) {
+            a();
+            if (this.c.isEmpty() && !(this.c instanceof TreeMap)) {
+                TreeMap treeMap = new TreeMap();
+                this.c = treeMap;
+                this.f = treeMap.descendingMap();
+            }
+            return (V) ((SortedMap) this.c).put(k, v);
+        }
+        int size = this.b.size();
+        int i2 = this.a;
+        if (size == i2) {
+            g1<K, V>.d remove = this.b.remove(i2 - 1);
+            a();
+            if (this.c.isEmpty() && !(this.c instanceof TreeMap)) {
+                TreeMap treeMap2 = new TreeMap();
+                this.c = treeMap2;
+                this.f = treeMap2.descendingMap();
+            }
+            ((SortedMap) this.c).put(remove.a, remove.b);
+        }
+        this.b.add(i, new d(k, v));
+        return null;
+    }
+
+    public void c() {
+        Map<K, V> unmodifiableMap;
+        Map<K, V> unmodifiableMap2;
+        if (this.d) {
+            return;
+        }
+        if (this.c.isEmpty()) {
+            unmodifiableMap = Collections.emptyMap();
+        } else {
+            unmodifiableMap = Collections.unmodifiableMap(this.c);
+        }
+        this.c = unmodifiableMap;
+        if (this.f.isEmpty()) {
+            unmodifiableMap2 = Collections.emptyMap();
+        } else {
+            unmodifiableMap2 = Collections.unmodifiableMap(this.f);
+        }
+        this.f = unmodifiableMap2;
+        this.d = true;
+    }
+
+    public final V c(int i) {
+        a();
+        V v = this.b.remove(i).b;
+        if (!this.c.isEmpty()) {
+            a();
+            if (this.c.isEmpty() && !(this.c instanceof TreeMap)) {
+                TreeMap treeMap = new TreeMap();
+                this.c = treeMap;
+                this.f = treeMap.descendingMap();
+            }
+            Iterator it = ((SortedMap) this.c).entrySet().iterator();
+            List<g1<K, V>.d> list = this.b;
+            Map.Entry entry = (Map.Entry) it.next();
+            list.add(new d((Comparable) entry.getKey(), entry.getValue()));
+            it.remove();
+        }
+        return v;
+    }
+
+    public final int a(K k) {
+        int i;
+        int size = this.b.size();
+        int i2 = size - 1;
+        if (i2 >= 0) {
+            int compareTo = k.compareTo(this.b.get(i2).a);
+            if (compareTo > 0) {
+                i = size + 1;
+                return -i;
+            }
+            if (compareTo == 0) {
+                return i2;
+            }
+        }
+        int i3 = 0;
+        while (i3 <= i2) {
+            int i4 = (i3 + i2) / 2;
+            int compareTo2 = k.compareTo(this.b.get(i4).a);
+            if (compareTo2 < 0) {
+                i2 = i4 - 1;
+            } else {
+                if (compareTo2 <= 0) {
+                    return i4;
+                }
+                i3 = i4 + 1;
+            }
+        }
+        i = i3 + 1;
+        return -i;
+    }
+
+    public final void a() {
+        if (this.d) {
+            throw new UnsupportedOperationException();
+        }
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/h.java

@@ -0,0 +1,8 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+public abstract class h {
+    public abstract void a(byte[] bArr, int i, int i2) throws IOException;
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/h0.java

@@ -0,0 +1,5 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class h0<K, V> {
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/h1.java

@@ -0,0 +1,19 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class h1 implements m0 {
+    @Override // com.fyber.inneractive.sdk.protobuf.m0
+    public final boolean a() {
+        return false;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.m0
+    public final y0 b() {
+        return null;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.m0
+    public final o0 c() {
+        return null;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/i.java

@@ -0,0 +1,368 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.j;
+import java.io.IOException;
+import java.io.InvalidObjectException;
+import java.io.ObjectInputStream;
+import java.io.Serializable;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.NoSuchElementException;
+
+/* loaded from: classes2.dex */
+public abstract class i implements Iterable<Byte>, Serializable {
+    public static final h b = new h(y.b);
+    public static final e c;
+    public int a = 0;
+
+    public static abstract class b implements f {
+        @Override // java.util.Iterator
+        public final Byte next() {
+            return Byte.valueOf(a());
+        }
+
+        @Override // java.util.Iterator
+        public final void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public static final class c implements e {
+        @Override // com.fyber.inneractive.sdk.protobuf.i.e
+        public final byte[] a(byte[] bArr, int i, int i2) {
+            return Arrays.copyOfRange(bArr, i, i2 + i);
+        }
+    }
+
+    public static final class d extends h {
+        private static final long serialVersionUID = 1;
+        public final int e;
+        public final int f;
+
+        public d(byte[] bArr, int i, int i2) {
+            super(bArr);
+            i.a(i, i + i2, bArr.length);
+            this.e = i;
+            this.f = i2;
+        }
+
+        private void readObject(ObjectInputStream objectInputStream) throws IOException {
+            throw new InvalidObjectException("BoundedByteStream instances are not to be serialized directly");
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i.h, com.fyber.inneractive.sdk.protobuf.i
+        public final byte d(int i) {
+            return this.d[this.e + i];
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i.h
+        public final int j() {
+            return this.e;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i.h, com.fyber.inneractive.sdk.protobuf.i
+        public final int size() {
+            return this.f;
+        }
+
+        public Object writeReplace() {
+            return new h(h());
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i.h, com.fyber.inneractive.sdk.protobuf.i
+        public final byte c(int i) {
+            int i2 = this.f;
+            if (((i2 - (i + 1)) | i) >= 0) {
+                return this.d[this.e + i];
+            }
+            if (i < 0) {
+                throw new ArrayIndexOutOfBoundsException(com.fyber.inneractive.sdk.player.exoplayer2.i.a("Index < 0: ", i));
+            }
+            throw new ArrayIndexOutOfBoundsException("Index > length: " + i + ", " + i2);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i.h, com.fyber.inneractive.sdk.protobuf.i
+        public final void a(int i, int i2, int i3, byte[] bArr) {
+            System.arraycopy(this.d, this.e + i, bArr, i2, i3);
+        }
+    }
+
+    public interface e {
+        byte[] a(byte[] bArr, int i, int i2);
+    }
+
+    public interface f extends Iterator<Byte> {
+        byte a();
+    }
+
+    public static abstract class g extends i {
+        @Override // com.fyber.inneractive.sdk.protobuf.i, java.lang.Iterable
+        public final Iterator<Byte> iterator() {
+            return new a();
+        }
+    }
+
+    public static class h extends g {
+        private static final long serialVersionUID = 1;
+        public final byte[] d;
+
+        public h(byte[] bArr) {
+            bArr.getClass();
+            this.d = bArr;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public final i a(int i, int i2) {
+            int a = i.a(i, i2, size());
+            return a == 0 ? i.b : new d(this.d, j() + i, a);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public final int b(int i, int i2, int i3) {
+            byte[] bArr = this.d;
+            int j = j() + i2;
+            Charset charset = y.a;
+            for (int i4 = j; i4 < j + i3; i4++) {
+                i = (i * 31) + bArr[i4];
+            }
+            return i;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public byte c(int i) {
+            return this.d[i];
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public byte d(int i) {
+            return this.d[i];
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public final boolean e() {
+            int j = j();
+            return q1.a.b(this.d, j, size() + j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public final boolean equals(Object obj) {
+            if (obj == this) {
+                return true;
+            }
+            if (!(obj instanceof i) || size() != ((i) obj).size()) {
+                return false;
+            }
+            if (size() == 0) {
+                return true;
+            }
+            if (!(obj instanceof h)) {
+                return obj.equals(this);
+            }
+            h hVar = (h) obj;
+            int i = this.a;
+            int i2 = hVar.a;
+            if (i == 0 || i2 == 0 || i == i2) {
+                return a(hVar, 0, size());
+            }
+            return false;
+        }
+
+        public int j() {
+            return 0;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public int size() {
+            return this.d.length;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public final j g() {
+            byte[] bArr = this.d;
+            int j = j();
+            int size = size();
+            j.a aVar = new j.a(bArr, j, size, true);
+            try {
+                aVar.d(size);
+                return aVar;
+            } catch (z e) {
+                throw new IllegalArgumentException(e);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public void a(int i, int i2, int i3, byte[] bArr) {
+            System.arraycopy(this.d, i, bArr, i2, i3);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public final void a(com.fyber.inneractive.sdk.protobuf.h hVar) throws IOException {
+            hVar.a(this.d, j(), size());
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i
+        public final String a(Charset charset) {
+            return new String(this.d, j(), size(), charset);
+        }
+
+        public final boolean a(i iVar, int i, int i2) {
+            if (i2 <= iVar.size()) {
+                int i3 = i + i2;
+                if (i3 <= iVar.size()) {
+                    if (iVar instanceof h) {
+                        h hVar = (h) iVar;
+                        byte[] bArr = this.d;
+                        byte[] bArr2 = hVar.d;
+                        int j = j() + i2;
+                        int j2 = j();
+                        int j3 = hVar.j() + i;
+                        while (j2 < j) {
+                            if (bArr[j2] != bArr2[j3]) {
+                                return false;
+                            }
+                            j2++;
+                            j3++;
+                        }
+                        return true;
+                    }
+                    return iVar.a(i, i3).equals(a(0, i2));
+                }
+                throw new IllegalArgumentException("Ran off end of other: " + i + ", " + i2 + ", " + iVar.size());
+            }
+            throw new IllegalArgumentException("Length too large: " + i2 + size());
+        }
+    }
+
+    /* renamed from: com.fyber.inneractive.sdk.protobuf.i$i, reason: collision with other inner class name */
+    public static final class C0105i implements e {
+        @Override // com.fyber.inneractive.sdk.protobuf.i.e
+        public final byte[] a(byte[] bArr, int i, int i2) {
+            byte[] bArr2 = new byte[i2];
+            System.arraycopy(bArr, i, bArr2, 0, i2);
+            return bArr2;
+        }
+    }
+
+    static {
+        c = com.fyber.inneractive.sdk.protobuf.d.a() ? new C0105i() : new c();
+    }
+
+    public static h a(byte[] bArr, int i, int i2) {
+        a(i, i + i2, bArr.length);
+        return new h(c.a(bArr, i, i2));
+    }
+
+    public abstract i a(int i, int i2);
+
+    public abstract String a(Charset charset);
+
+    public abstract void a(int i, int i2, int i3, byte[] bArr);
+
+    public abstract void a(com.fyber.inneractive.sdk.protobuf.h hVar) throws IOException;
+
+    public abstract int b(int i, int i2, int i3);
+
+    public abstract byte c(int i);
+
+    public abstract byte d(int i);
+
+    public abstract boolean e();
+
+    public abstract boolean equals(Object obj);
+
+    @Override // java.lang.Iterable
+    /* renamed from: f, reason: merged with bridge method [inline-methods] */
+    public f iterator() {
+        return new a();
+    }
+
+    public abstract j g();
+
+    public final byte[] h() {
+        int size = size();
+        if (size == 0) {
+            return y.b;
+        }
+        byte[] bArr = new byte[size];
+        a(0, 0, size, bArr);
+        return bArr;
+    }
+
+    public final String i() {
+        return size() == 0 ? "" : a(y.a);
+    }
+
+    public abstract int size();
+
+    public final String toString() {
+        String str;
+        Locale locale = Locale.ROOT;
+        Object[] objArr = new Object[3];
+        objArr[0] = Integer.toHexString(System.identityHashCode(this));
+        objArr[1] = Integer.valueOf(size());
+        if (size() <= 50) {
+            str = i1.a(this);
+        } else {
+            str = i1.a(a(0, 47)) + "...";
+        }
+        objArr[2] = str;
+        return String.format(locale, "<ByteString@%s size=%d contents=\"%s\">", objArr);
+    }
+
+    public static h a(String str) {
+        return new h(str.getBytes(y.a));
+    }
+
+    public static int a(int i, int i2, int i3) {
+        int i4 = i2 - i;
+        if ((i | i2 | i4 | (i3 - i2)) >= 0) {
+            return i4;
+        }
+        if (i < 0) {
+            throw new IndexOutOfBoundsException("Beginning index: " + i + " < 0");
+        }
+        if (i2 < i) {
+            throw new IndexOutOfBoundsException("Beginning index larger than ending index: " + i + ", " + i2);
+        }
+        throw new IndexOutOfBoundsException("End index: " + i2 + " >= " + i3);
+    }
+
+    public final int hashCode() {
+        int i = this.a;
+        if (i == 0) {
+            int size = size();
+            i = b(size, 0, size);
+            if (i == 0) {
+                i = 1;
+            }
+            this.a = i;
+        }
+        return i;
+    }
+
+    public class a extends b {
+        public int a = 0;
+        public final int b;
+
+        public a() {
+            this.b = i.this.size();
+        }
+
+        @Override // java.util.Iterator
+        public final boolean hasNext() {
+            return this.a < this.b;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.i.f
+        public final byte a() {
+            int i = this.a;
+            if (i < this.b) {
+                this.a = i + 1;
+                return i.this.d(i);
+            }
+            throw new NoSuchElementException();
+        }
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/i0.java

@@ -0,0 +1,141 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public final class i0<K, V> extends LinkedHashMap<K, V> {
+    public static final i0 b;
+    public boolean a;
+
+    static {
+        i0 i0Var = new i0();
+        b = i0Var;
+        i0Var.a = false;
+    }
+
+    public i0() {
+        this.a = true;
+    }
+
+    @Override // java.util.LinkedHashMap, java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public final Set<Map.Entry<K, V>> entrySet() {
+        return isEmpty() ? Collections.emptySet() : super.entrySet();
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final boolean equals(Object obj) {
+        if (obj instanceof Map) {
+            Map map = (Map) obj;
+            if (this != map) {
+                if (size() == map.size()) {
+                    for (Map.Entry<K, V> entry : entrySet()) {
+                        if (map.containsKey(entry.getKey())) {
+                            V value = entry.getValue();
+                            Object obj2 = map.get(entry.getKey());
+                            if (!(((value instanceof byte[]) && (obj2 instanceof byte[])) ? Arrays.equals((byte[]) value, (byte[]) obj2) : value.equals(obj2))) {
+                            }
+                        }
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override // java.util.AbstractMap, java.util.Map
+    public final int hashCode() {
+        int hashCode;
+        int i = 0;
+        for (Map.Entry<K, V> entry : entrySet()) {
+            K key = entry.getKey();
+            int i2 = 1;
+            if (key instanceof byte[]) {
+                byte[] bArr = (byte[]) key;
+                Charset charset = y.a;
+                hashCode = bArr.length;
+                for (int i3 : bArr) {
+                    hashCode = (hashCode * 31) + i3;
+                }
+                if (hashCode == 0) {
+                    hashCode = 1;
+                }
+            } else {
+                if (key instanceof y.c) {
+                    throw new UnsupportedOperationException();
+                }
+                hashCode = key.hashCode();
+            }
+            V value = entry.getValue();
+            if (value instanceof byte[]) {
+                byte[] bArr2 = (byte[]) value;
+                Charset charset2 = y.a;
+                int length = bArr2.length;
+                for (int i4 : bArr2) {
+                    length = (length * 31) + i4;
+                }
+                if (length != 0) {
+                    i2 = length;
+                }
+            } else {
+                if (value instanceof y.c) {
+                    throw new UnsupportedOperationException();
+                }
+                i2 = value.hashCode();
+            }
+            i += hashCode ^ i2;
+        }
+        return i;
+    }
+
+    @Override // java.util.LinkedHashMap, java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public final void clear() {
+        if (!this.a) {
+            throw new UnsupportedOperationException();
+        }
+        super.clear();
+    }
+
+    @Override // java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public final V put(K k, V v) {
+        if (!this.a) {
+            throw new UnsupportedOperationException();
+        }
+        Charset charset = y.a;
+        k.getClass();
+        v.getClass();
+        return (V) super.put(k, v);
+    }
+
+    @Override // java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public final void putAll(Map<? extends K, ? extends V> map) {
+        if (!this.a) {
+            throw new UnsupportedOperationException();
+        }
+        for (K k : map.keySet()) {
+            Charset charset = y.a;
+            k.getClass();
+            map.get(k).getClass();
+        }
+        super.putAll(map);
+    }
+
+    @Override // java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public final V remove(Object obj) {
+        if (this.a) {
+            return (V) super.remove(obj);
+        }
+        throw new UnsupportedOperationException();
+    }
+
+    public i0(Map<K, V> map) {
+        super(map);
+        this.a = true;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/i1.java

@@ -0,0 +1,55 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class i1 {
+    public static String a(i iVar) {
+        StringBuilder sb = new StringBuilder(iVar.size());
+        for (int i = 0; i < iVar.size(); i++) {
+            byte c = iVar.c(i);
+            if (c == 34) {
+                sb.append("\\\"");
+            } else if (c == 39) {
+                sb.append("\\'");
+            } else if (c != 92) {
+                switch (c) {
+                    case 7:
+                        sb.append("\\a");
+                        break;
+                    case 8:
+                        sb.append("\\b");
+                        break;
+                    case 9:
+                        sb.append("\\t");
+                        break;
+                    case 10:
+                        sb.append("\\n");
+                        break;
+                    case 11:
+                        sb.append("\\v");
+                        break;
+                    case 12:
+                        sb.append("\\f");
+                        break;
+                    case 13:
+                        sb.append("\\r");
+                        break;
+                    default:
+                        if (c < 32 || c > 126) {
+                            sb.append('\\');
+                            sb.append((char) (((c >>> 6) & 3) + 48));
+                            sb.append((char) (((c >>> 3) & 7) + 48));
+                            sb.append((char) ((c & 7) + 48));
+                            break;
+                        } else {
+                            sb.append((char) c);
+                            break;
+                        }
+                        break;
+                }
+            } else {
+                sb.append("\\\\");
+            }
+        }
+        return sb.toString();
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/j0.java

@@ -0,0 +1,20 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public interface j0 {
+    i0 a();
+
+    i0 a(Object obj, Object obj2);
+
+    void a(int i, Object obj, Object obj2);
+
+    boolean a(Object obj);
+
+    Object b(Object obj);
+
+    void c(Object obj);
+
+    i0 d(Object obj);
+
+    i0 e(Object obj);
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/j1.java

@@ -0,0 +1,10 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class j1 extends RuntimeException {
+    private static final long serialVersionUID = -7466929953374883507L;
+
+    public j1() {
+        super("Message was missing required fields.  (Lite runtime could not determine which fields were missing).");
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/k0.java

@@ -0,0 +1,76 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public final class k0 implements j0 {
+    @Override // com.fyber.inneractive.sdk.protobuf.j0
+    public final boolean a(Object obj) {
+        return !((i0) obj).a;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.j0
+    public final Object b(Object obj) {
+        ((i0) obj).a = false;
+        return obj;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.j0
+    public final void c(Object obj) {
+        ((h0) obj).getClass();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.j0
+    public final i0 d(Object obj) {
+        return (i0) obj;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.j0
+    public final i0 e(Object obj) {
+        return (i0) obj;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.j0
+    public final i0 a() {
+        i0 i0Var = i0.b;
+        return i0Var.isEmpty() ? new i0() : new i0(i0Var);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.j0
+    public final i0 a(Object obj, Object obj2) {
+        i0 i0Var = (i0) obj;
+        i0 i0Var2 = (i0) obj2;
+        if (!i0Var2.isEmpty()) {
+            if (!i0Var.a) {
+                i0Var = i0Var.isEmpty() ? new i0() : new i0(i0Var);
+            }
+            if (i0Var.a) {
+                if (!i0Var2.isEmpty()) {
+                    i0Var.putAll(i0Var2);
+                }
+            } else {
+                throw new UnsupportedOperationException();
+            }
+        }
+        return i0Var;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.j0
+    public final void a(int i, Object obj, Object obj2) {
+        i0 i0Var = (i0) obj;
+        h0 h0Var = (h0) obj2;
+        if (i0Var.isEmpty()) {
+            return;
+        }
+        Iterator it = i0Var.entrySet().iterator();
+        if (it.hasNext()) {
+            Map.Entry entry = (Map.Entry) it.next();
+            entry.getKey();
+            entry.getValue();
+            h0Var.getClass();
+            l.d(i);
+            throw null;
+        }
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/k1.java

@@ -0,0 +1,82 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.z;
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+public abstract class k1<T, B> {
+    public abstract l1 a();
+
+    public abstract l1 a(Object obj);
+
+    public abstract l1 a(Object obj, Object obj2);
+
+    public abstract void a(int i, long j, Object obj);
+
+    public abstract void a(int i, Object obj, Object obj2);
+
+    public abstract void a(B b, int i, int i2);
+
+    public abstract void a(B b, int i, i iVar);
+
+    public abstract void a(Object obj, m mVar) throws IOException;
+
+    public final boolean a(B b, c1 c1Var) throws IOException {
+        int b2 = c1Var.b();
+        int i = r1.a;
+        int i2 = b2 >>> 3;
+        int i3 = b2 & 7;
+        if (i3 == 0) {
+            b(i2, c1Var.r(), b);
+            return true;
+        }
+        if (i3 == 1) {
+            a(i2, c1Var.d(), b);
+            return true;
+        }
+        if (i3 == 2) {
+            a((k1<T, B>) b, i2, c1Var.l());
+            return true;
+        }
+        if (i3 != 3) {
+            if (i3 == 4) {
+                return false;
+            }
+            if (i3 == 5) {
+                a((k1<T, B>) b, i2, c1Var.h());
+                return true;
+            }
+            int i4 = z.a;
+            throw new z.a();
+        }
+        l1 a = a();
+        int a2 = r1.a(i2, 4);
+        while (c1Var.j() != Integer.MAX_VALUE && a((k1<T, B>) a, c1Var)) {
+        }
+        if (a2 != c1Var.b()) {
+            throw z.a();
+        }
+        a(i2, b, f(a));
+        return true;
+    }
+
+    public abstract l1 b(Object obj);
+
+    public abstract void b();
+
+    public abstract void b(int i, long j, Object obj);
+
+    public abstract void b(Object obj, m mVar) throws IOException;
+
+    public abstract void b(Object obj, B b);
+
+    public abstract int c(T t);
+
+    public abstract void c(Object obj, T t);
+
+    public abstract int d(T t);
+
+    public abstract void e(Object obj);
+
+    public abstract l1 f(Object obj);
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/l.java

@@ -0,0 +1,783 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import androidx.work.WorkInfo;
+import com.fyber.inneractive.sdk.protobuf.q1;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/* loaded from: classes2.dex */
+public abstract class l extends h {
+    public static final Logger b = Logger.getLogger(l.class.getName());
+    public static final boolean c = p1.e;
+    public m a;
+
+    public static abstract class a extends l {
+        public final byte[] d;
+        public final int e;
+        public int f;
+
+        public a(int i) {
+            super(0);
+            if (i < 0) {
+                throw new IllegalArgumentException("bufferSize must be >= 0");
+            }
+            int max = Math.max(i, 20);
+            this.d = new byte[max];
+            this.e = max;
+        }
+
+        public final void e(long j) {
+            byte[] bArr = this.d;
+            int i = this.f;
+            bArr[i] = (byte) (j & 255);
+            bArr[i + 1] = (byte) ((j >> 8) & 255);
+            bArr[i + 2] = (byte) ((j >> 16) & 255);
+            bArr[i + 3] = (byte) (255 & (j >> 24));
+            bArr[i + 4] = (byte) (((int) (j >> 32)) & 255);
+            bArr[i + 5] = (byte) (((int) (j >> 40)) & 255);
+            bArr[i + 6] = (byte) (((int) (j >> 48)) & 255);
+            this.f = i + 8;
+            bArr[i + 7] = (byte) (((int) (j >> 56)) & 255);
+        }
+
+        public final void j(int i) {
+            byte[] bArr = this.d;
+            int i2 = this.f;
+            bArr[i2] = (byte) (i & 255);
+            bArr[i2 + 1] = (byte) ((i >> 8) & 255);
+            bArr[i2 + 2] = (byte) ((i >> 16) & 255);
+            this.f = i2 + 4;
+            bArr[i2 + 3] = (byte) ((i >> 24) & 255);
+        }
+
+        public final void f(long j) {
+            if (l.c) {
+                while ((j & (-128)) != 0) {
+                    byte[] bArr = this.d;
+                    int i = this.f;
+                    this.f = i + 1;
+                    p1.a(bArr, i, (byte) ((((int) j) & 127) | 128));
+                    j >>>= 7;
+                }
+                byte[] bArr2 = this.d;
+                int i2 = this.f;
+                this.f = i2 + 1;
+                p1.a(bArr2, i2, (byte) j);
+                return;
+            }
+            while ((j & (-128)) != 0) {
+                byte[] bArr3 = this.d;
+                int i3 = this.f;
+                this.f = i3 + 1;
+                bArr3[i3] = (byte) ((((int) j) & 127) | 128);
+                j >>>= 7;
+            }
+            byte[] bArr4 = this.d;
+            int i4 = this.f;
+            this.f = i4 + 1;
+            bArr4[i4] = (byte) j;
+        }
+
+        public final void k(int i) {
+            if (l.c) {
+                while ((i & WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT) != 0) {
+                    byte[] bArr = this.d;
+                    int i2 = this.f;
+                    this.f = i2 + 1;
+                    p1.a(bArr, i2, (byte) ((i & 127) | 128));
+                    i >>>= 7;
+                }
+                byte[] bArr2 = this.d;
+                int i3 = this.f;
+                this.f = i3 + 1;
+                p1.a(bArr2, i3, (byte) i);
+                return;
+            }
+            while ((i & WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT) != 0) {
+                byte[] bArr3 = this.d;
+                int i4 = this.f;
+                this.f = i4 + 1;
+                bArr3[i4] = (byte) ((i & 127) | 128);
+                i >>>= 7;
+            }
+            byte[] bArr4 = this.d;
+            int i5 = this.f;
+            this.f = i5 + 1;
+            bArr4[i5] = (byte) i;
+        }
+    }
+
+    public static class b extends l {
+        public final byte[] d;
+        public final int e;
+        public int f;
+
+        public b(byte[] bArr, int i) {
+            super(0);
+            if (((bArr.length - i) | i) < 0) {
+                throw new IllegalArgumentException(String.format("Array range is invalid. Buffer.length=%d, offset=%d, length=%d", Integer.valueOf(bArr.length), 0, Integer.valueOf(i)));
+            }
+            this.d = bArr;
+            this.f = 0;
+            this.e = i;
+        }
+
+        public final int a() {
+            return this.e - this.f;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(int i, boolean z) throws IOException {
+            i(r1.a(i, 0));
+            a(z ? (byte) 1 : (byte) 0);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void b(int i, i iVar) throws IOException {
+            i(r1.a(i, 2));
+            i(iVar.size());
+            iVar.a(this);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void c(int i, int i2) throws IOException {
+            i(r1.a(i, 0));
+            h(i2);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void e(int i, int i2) throws IOException {
+            i(r1.a(i, 0));
+            i(i2);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void g(int i) throws IOException {
+            try {
+                byte[] bArr = this.d;
+                int i2 = this.f;
+                bArr[i2] = (byte) (i & 255);
+                bArr[i2 + 1] = (byte) ((i >> 8) & 255);
+                bArr[i2 + 2] = (byte) ((i >> 16) & 255);
+                this.f = i2 + 4;
+                bArr[i2 + 3] = (byte) ((i >> 24) & 255);
+            } catch (IndexOutOfBoundsException e) {
+                throw new c(String.format("Pos: %d, limit: %d, len: %d", Integer.valueOf(this.f), Integer.valueOf(this.e), 1), e);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void h(int i) throws IOException {
+            if (i >= 0) {
+                i(i);
+            } else {
+                d(i);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void d(long j) throws IOException {
+            if (l.c && a() >= 10) {
+                while ((j & (-128)) != 0) {
+                    byte[] bArr = this.d;
+                    int i = this.f;
+                    this.f = i + 1;
+                    p1.a(bArr, i, (byte) ((((int) j) & 127) | 128));
+                    j >>>= 7;
+                }
+                byte[] bArr2 = this.d;
+                int i2 = this.f;
+                this.f = i2 + 1;
+                p1.a(bArr2, i2, (byte) j);
+                return;
+            }
+            while ((j & (-128)) != 0) {
+                try {
+                    byte[] bArr3 = this.d;
+                    int i3 = this.f;
+                    this.f = i3 + 1;
+                    bArr3[i3] = (byte) ((((int) j) & 127) | 128);
+                    j >>>= 7;
+                } catch (IndexOutOfBoundsException e) {
+                    throw new c(String.format("Pos: %d, limit: %d, len: %d", Integer.valueOf(this.f), Integer.valueOf(this.e), 1), e);
+                }
+            }
+            byte[] bArr4 = this.d;
+            int i4 = this.f;
+            this.f = i4 + 1;
+            bArr4[i4] = (byte) j;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void i(int i) throws IOException {
+            if (!l.c || com.fyber.inneractive.sdk.protobuf.d.a() || a() < 5) {
+                while ((i & WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT) != 0) {
+                    try {
+                        byte[] bArr = this.d;
+                        int i2 = this.f;
+                        this.f = i2 + 1;
+                        bArr[i2] = (byte) ((i & 127) | 128);
+                        i >>>= 7;
+                    } catch (IndexOutOfBoundsException e) {
+                        throw new c(String.format("Pos: %d, limit: %d, len: %d", Integer.valueOf(this.f), Integer.valueOf(this.e), 1), e);
+                    }
+                }
+                byte[] bArr2 = this.d;
+                int i3 = this.f;
+                this.f = i3 + 1;
+                bArr2[i3] = (byte) i;
+                return;
+            }
+            if ((i & WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT) == 0) {
+                byte[] bArr3 = this.d;
+                int i4 = this.f;
+                this.f = i4 + 1;
+                p1.a(bArr3, i4, (byte) i);
+                return;
+            }
+            byte[] bArr4 = this.d;
+            int i5 = this.f;
+            this.f = i5 + 1;
+            p1.a(bArr4, i5, (byte) (i | 128));
+            int i6 = i >>> 7;
+            if ((i6 & WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT) == 0) {
+                byte[] bArr5 = this.d;
+                int i7 = this.f;
+                this.f = i7 + 1;
+                p1.a(bArr5, i7, (byte) i6);
+                return;
+            }
+            byte[] bArr6 = this.d;
+            int i8 = this.f;
+            this.f = i8 + 1;
+            p1.a(bArr6, i8, (byte) (i6 | 128));
+            int i9 = i >>> 14;
+            if ((i9 & WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT) == 0) {
+                byte[] bArr7 = this.d;
+                int i10 = this.f;
+                this.f = i10 + 1;
+                p1.a(bArr7, i10, (byte) i9);
+                return;
+            }
+            byte[] bArr8 = this.d;
+            int i11 = this.f;
+            this.f = i11 + 1;
+            p1.a(bArr8, i11, (byte) (i9 | 128));
+            int i12 = i >>> 21;
+            if ((i12 & WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT) == 0) {
+                byte[] bArr9 = this.d;
+                int i13 = this.f;
+                this.f = i13 + 1;
+                p1.a(bArr9, i13, (byte) i12);
+                return;
+            }
+            byte[] bArr10 = this.d;
+            int i14 = this.f;
+            this.f = i14 + 1;
+            p1.a(bArr10, i14, (byte) (i12 | 128));
+            byte[] bArr11 = this.d;
+            int i15 = this.f;
+            this.f = i15 + 1;
+            p1.a(bArr11, i15, (byte) (i >>> 28));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(int i, long j) throws IOException {
+            i(r1.a(i, 1));
+            c(j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void c(int i, i iVar) throws IOException {
+            i(r1.a(1, 3));
+            e(2, i);
+            b(3, iVar);
+            i(r1.a(1, 4));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void b(int i, int i2) throws IOException {
+            i(r1.a(i, 5));
+            g(i2);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(int i, o0 o0Var, d1 d1Var) throws IOException {
+            i(r1.a(i, 2));
+            i(((com.fyber.inneractive.sdk.protobuf.a) o0Var).getSerializedSize(d1Var));
+            d1Var.a((Object) o0Var, this.a);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void b(int i, long j) throws IOException {
+            i(r1.a(i, 0));
+            d(j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void c(long j) throws IOException {
+            try {
+                byte[] bArr = this.d;
+                int i = this.f;
+                bArr[i] = (byte) (((int) j) & 255);
+                bArr[i + 1] = (byte) (((int) (j >> 8)) & 255);
+                bArr[i + 2] = (byte) (((int) (j >> 16)) & 255);
+                bArr[i + 3] = (byte) (((int) (j >> 24)) & 255);
+                bArr[i + 4] = (byte) (((int) (j >> 32)) & 255);
+                bArr[i + 5] = (byte) (((int) (j >> 40)) & 255);
+                bArr[i + 6] = (byte) (((int) (j >> 48)) & 255);
+                this.f = i + 8;
+                bArr[i + 7] = (byte) (((int) (j >> 56)) & 255);
+            } catch (IndexOutOfBoundsException e) {
+                throw new c(String.format("Pos: %d, limit: %d, len: %d", Integer.valueOf(this.f), Integer.valueOf(this.e), 1), e);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(int i, o0 o0Var) throws IOException {
+            i(r1.a(1, 3));
+            e(2, i);
+            i(r1.a(3, 2));
+            i(o0Var.getSerializedSize());
+            o0Var.writeTo(this);
+            i(r1.a(1, 4));
+        }
+
+        public final void b(String str) throws IOException {
+            int i = this.f;
+            try {
+                int e = l.e(str.length() * 3);
+                int e2 = l.e(str.length());
+                if (e2 == e) {
+                    int i2 = i + e2;
+                    this.f = i2;
+                    int a = q1.a.a(str, this.d, i2, a());
+                    this.f = i;
+                    i((a - i) - e2);
+                    this.f = a;
+                } else {
+                    i(q1.a(str));
+                    this.f = q1.a.a(str, this.d, this.f, a());
+                }
+            } catch (q1.d e3) {
+                this.f = i;
+                a(str, e3);
+            } catch (IndexOutOfBoundsException e4) {
+                throw new c(e4);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(String str, int i) throws IOException {
+            i(r1.a(i, 2));
+            b(str);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(byte b) throws IOException {
+            try {
+                byte[] bArr = this.d;
+                int i = this.f;
+                this.f = i + 1;
+                bArr[i] = b;
+            } catch (IndexOutOfBoundsException e) {
+                throw new c(String.format("Pos: %d, limit: %d, len: %d", Integer.valueOf(this.f), Integer.valueOf(this.e), 1), e);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.h
+        public final void a(byte[] bArr, int i, int i2) throws IOException {
+            try {
+                System.arraycopy(bArr, i, this.d, this.f, i2);
+                this.f += i2;
+            } catch (IndexOutOfBoundsException e) {
+                throw new c(String.format("Pos: %d, limit: %d, len: %d", Integer.valueOf(this.f), Integer.valueOf(this.e), Integer.valueOf(i2)), e);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void d(int i, int i2) throws IOException {
+            i(r1.a(i, i2));
+        }
+    }
+
+    public static class c extends IOException {
+        private static final long serialVersionUID = -6947486886997889499L;
+
+        public c(IndexOutOfBoundsException indexOutOfBoundsException) {
+            super("CodedOutputStream was writing to a flat byte array and ran out of space.", indexOutOfBoundsException);
+        }
+
+        public c(String str, IndexOutOfBoundsException indexOutOfBoundsException) {
+            super("CodedOutputStream was writing to a flat byte array and ran out of space.: " + str, indexOutOfBoundsException);
+        }
+    }
+
+    public static final class d extends a {
+        public final OutputStream g;
+
+        public d(OutputStream outputStream, int i) {
+            super(i);
+            if (outputStream == null) {
+                throw new NullPointerException("out");
+            }
+            this.g = outputStream;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(int i, o0 o0Var, d1 d1Var) throws IOException {
+            i(r1.a(i, 2));
+            i(((com.fyber.inneractive.sdk.protobuf.a) o0Var).getSerializedSize(d1Var));
+            d1Var.a((Object) o0Var, this.a);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void b(int i, i iVar) throws IOException {
+            i(r1.a(i, 2));
+            i(iVar.size());
+            iVar.a(this);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void c(int i, i iVar) throws IOException {
+            i(r1.a(1, 3));
+            e(2, i);
+            b(3, iVar);
+            i(r1.a(1, 4));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void d(int i, int i2) throws IOException {
+            i(r1.a(i, i2));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void e(int i, int i2) throws IOException {
+            l(20);
+            k(r1.a(i, 0));
+            k(i2);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void g(int i) throws IOException {
+            l(4);
+            j(i);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void h(int i) throws IOException {
+            if (i >= 0) {
+                i(i);
+            } else {
+                d(i);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void i(int i) throws IOException {
+            l(5);
+            k(i);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void d(long j) throws IOException {
+            l(10);
+            f(j);
+        }
+
+        public final void l(int i) throws IOException {
+            if (this.e - this.f < i) {
+                a();
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(int i, o0 o0Var) throws IOException {
+            i(r1.a(1, 3));
+            e(2, i);
+            i(r1.a(3, 2));
+            i(o0Var.getSerializedSize());
+            o0Var.writeTo(this);
+            i(r1.a(1, 4));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void b(int i, int i2) throws IOException {
+            l(14);
+            k(r1.a(i, 5));
+            j(i2);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void c(int i, int i2) throws IOException {
+            l(20);
+            k(r1.a(i, 0));
+            if (i2 >= 0) {
+                k(i2);
+            } else {
+                f(i2);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void b(int i, long j) throws IOException {
+            l(20);
+            k(r1.a(i, 0));
+            f(j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(String str, int i) throws IOException {
+            i(r1.a(i, 2));
+            b(str);
+        }
+
+        public final void b(String str) throws IOException {
+            try {
+                int length = str.length() * 3;
+                int e = l.e(length);
+                int i = e + length;
+                int i2 = this.e;
+                if (i > i2) {
+                    byte[] bArr = new byte[length];
+                    int a = q1.a.a(str, bArr, 0, length);
+                    i(a);
+                    b(bArr, 0, a);
+                    return;
+                }
+                if (i > i2 - this.f) {
+                    a();
+                }
+                int e2 = l.e(str.length());
+                int i3 = this.f;
+                try {
+                    if (e2 == e) {
+                        int i4 = i3 + e2;
+                        this.f = i4;
+                        int a2 = q1.a.a(str, this.d, i4, this.e - i4);
+                        this.f = i3;
+                        k((a2 - i3) - e2);
+                        this.f = a2;
+                    } else {
+                        int a3 = q1.a(str);
+                        k(a3);
+                        this.f = q1.a.a(str, this.d, this.f, a3);
+                    }
+                } catch (q1.d e3) {
+                    this.f = i3;
+                    throw e3;
+                } catch (ArrayIndexOutOfBoundsException e4) {
+                    throw new c(e4);
+                }
+            } catch (q1.d e5) {
+                a(str, e5);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void c(long j) throws IOException {
+            l(8);
+            e(j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(int i, long j) throws IOException {
+            l(18);
+            k(r1.a(i, 1));
+            e(j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(int i, boolean z) throws IOException {
+            l(11);
+            k(r1.a(i, 0));
+            byte b = z ? (byte) 1 : (byte) 0;
+            byte[] bArr = this.d;
+            int i2 = this.f;
+            this.f = i2 + 1;
+            bArr[i2] = b;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.l
+        public final void a(byte b) throws IOException {
+            if (this.f == this.e) {
+                a();
+            }
+            byte[] bArr = this.d;
+            int i = this.f;
+            this.f = i + 1;
+            bArr[i] = b;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.h
+        public final void a(byte[] bArr, int i, int i2) throws IOException {
+            b(bArr, i, i2);
+        }
+
+        public final void a() throws IOException {
+            this.g.write(this.d, 0, this.f);
+            this.f = 0;
+        }
+
+        public final void b(byte[] bArr, int i, int i2) throws IOException {
+            int i3 = this.e;
+            int i4 = this.f;
+            int i5 = i3 - i4;
+            if (i5 >= i2) {
+                System.arraycopy(bArr, i, this.d, i4, i2);
+                this.f += i2;
+                return;
+            }
+            System.arraycopy(bArr, i, this.d, i4, i5);
+            int i6 = i + i5;
+            int i7 = i2 - i5;
+            this.f = this.e;
+            a();
+            if (i7 <= this.e) {
+                System.arraycopy(bArr, i6, this.d, 0, i7);
+                this.f = i7;
+            } else {
+                this.g.write(bArr, i6, i7);
+            }
+        }
+    }
+
+    public /* synthetic */ l(int i) {
+        this();
+    }
+
+    public static int a(int i, int i2) {
+        return e(i2) + d(i);
+    }
+
+    public static int a(long j) {
+        int i;
+        if (((-128) & j) == 0) {
+            return 1;
+        }
+        if (j < 0) {
+            return 10;
+        }
+        if (((-34359738368L) & j) != 0) {
+            j >>>= 28;
+            i = 6;
+        } else {
+            i = 2;
+        }
+        if (((-2097152) & j) != 0) {
+            i += 2;
+            j >>>= 14;
+        }
+        return (j & (-16384)) != 0 ? i + 1 : i;
+    }
+
+    public static int b(int i) {
+        return d(i) + 8;
+    }
+
+    public static long b(long j) {
+        return (j >> 63) ^ (j << 1);
+    }
+
+    public static int c(int i) {
+        if (i >= 0) {
+            return e(i);
+        }
+        return 10;
+    }
+
+    public static int d(int i) {
+        return e(r1.a(i, 0));
+    }
+
+    public static int e(int i) {
+        if ((i & WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT) == 0) {
+            return 1;
+        }
+        if ((i & (-16384)) == 0) {
+            return 2;
+        }
+        if (((-2097152) & i) == 0) {
+            return 3;
+        }
+        return (i & (-268435456)) == 0 ? 4 : 5;
+    }
+
+    public static int f(int i) {
+        return (i >> 31) ^ (i << 1);
+    }
+
+    public abstract void a(byte b2) throws IOException;
+
+    public abstract void a(int i, long j) throws IOException;
+
+    public abstract void a(int i, o0 o0Var) throws IOException;
+
+    public abstract void a(int i, o0 o0Var, d1 d1Var) throws IOException;
+
+    public abstract void a(int i, boolean z) throws IOException;
+
+    public abstract void a(String str, int i) throws IOException;
+
+    public abstract void b(int i, int i2) throws IOException;
+
+    public abstract void b(int i, long j) throws IOException;
+
+    public abstract void b(int i, i iVar) throws IOException;
+
+    public abstract void c(int i, int i2) throws IOException;
+
+    public abstract void c(int i, i iVar) throws IOException;
+
+    public abstract void c(long j) throws IOException;
+
+    public abstract void d(int i, int i2) throws IOException;
+
+    public abstract void d(long j) throws IOException;
+
+    public abstract void e(int i, int i2) throws IOException;
+
+    public abstract void g(int i) throws IOException;
+
+    public abstract void h(int i) throws IOException;
+
+    public abstract void i(int i) throws IOException;
+
+    public l() {
+    }
+
+    public static int a(int i) {
+        return d(i) + 4;
+    }
+
+    public static int a(int i, i iVar) {
+        int d2 = d(i);
+        int size = iVar.size();
+        return e(size) + size + d2;
+    }
+
+    public static int a(String str) {
+        int length;
+        try {
+            length = q1.a(str);
+        } catch (q1.d unused) {
+            length = str.getBytes(y.a).length;
+        }
+        return e(length) + length;
+    }
+
+    public final void a(String str, q1.d dVar) throws IOException {
+        b.log(Level.WARNING, "Converting ill-formed UTF-16. Your Protocol Buffer will not round trip correctly!", (Throwable) dVar);
+        byte[] bytes = str.getBytes(y.a);
+        try {
+            i(bytes.length);
+            a(bytes, 0, bytes.length);
+        } catch (c e) {
+            throw e;
+        } catch (IndexOutOfBoundsException e2) {
+            throw new c(e2);
+        }
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/l0.java

@@ -0,0 +1,18 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class l0 {
+    public static final j0 a;
+    public static final k0 b;
+
+    static {
+        j0 j0Var;
+        try {
+            j0Var = (j0) Class.forName("com.google.protobuf.MapFieldSchemaFull").getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (Exception unused) {
+            j0Var = null;
+        }
+        a = j0Var;
+        b = new k0();
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/l1.java

@@ -0,0 +1,222 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.z;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import java.io.IOException;
+import java.util.Arrays;
+
+/* loaded from: classes2.dex */
+public final class l1 {
+    public static final l1 f = new l1(0, new int[0], new Object[0], false);
+    public int a;
+    public int[] b;
+    public Object[] c;
+    public int d;
+    public boolean e;
+
+    public l1() {
+        this(0, new int[8], new Object[8], true);
+    }
+
+    public static l1 a(l1 l1Var, l1 l1Var2) {
+        int i = l1Var.a + l1Var2.a;
+        int[] copyOf = Arrays.copyOf(l1Var.b, i);
+        System.arraycopy(l1Var2.b, 0, copyOf, l1Var.a, l1Var2.a);
+        Object[] copyOf2 = Arrays.copyOf(l1Var.c, i);
+        System.arraycopy(l1Var2.c, 0, copyOf2, l1Var.a, l1Var2.a);
+        return new l1(i, copyOf, copyOf2, true);
+    }
+
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || !(obj instanceof l1)) {
+            return false;
+        }
+        l1 l1Var = (l1) obj;
+        int i = this.a;
+        if (i == l1Var.a) {
+            int[] iArr = this.b;
+            int[] iArr2 = l1Var.b;
+            int i2 = 0;
+            while (true) {
+                if (i2 >= i) {
+                    Object[] objArr = this.c;
+                    Object[] objArr2 = l1Var.c;
+                    int i3 = this.a;
+                    for (int i4 = 0; i4 < i3; i4++) {
+                        if (objArr[i4].equals(objArr2[i4])) {
+                        }
+                    }
+                    return true;
+                }
+                if (iArr[i2] != iArr2[i2]) {
+                    break;
+                }
+                i2++;
+            }
+        }
+        return false;
+    }
+
+    public l1(int i, int[] iArr, Object[] objArr, boolean z) {
+        this.d = -1;
+        this.a = i;
+        this.b = iArr;
+        this.c = objArr;
+        this.e = z;
+    }
+
+    public final int hashCode() {
+        int i = this.a;
+        int i2 = (i + IronSourceError.ERROR_NON_EXISTENT_INSTANCE) * 31;
+        int[] iArr = this.b;
+        int i3 = 17;
+        int i4 = 17;
+        for (int i5 = 0; i5 < i; i5++) {
+            i4 = (i4 * 31) + iArr[i5];
+        }
+        int i6 = (i2 + i4) * 31;
+        Object[] objArr = this.c;
+        int i7 = this.a;
+        for (int i8 = 0; i8 < i7; i8++) {
+            i3 = (i3 * 31) + objArr[i8].hashCode();
+        }
+        return i6 + i3;
+    }
+
+    public final boolean a(int i, j jVar) throws IOException {
+        int t;
+        if (this.e) {
+            int i2 = r1.a;
+            int i3 = i >>> 3;
+            int i4 = i & 7;
+            if (i4 == 0) {
+                a(i, Long.valueOf(jVar.l()));
+                return true;
+            }
+            if (i4 == 1) {
+                a(i, Long.valueOf(jVar.i()));
+                return true;
+            }
+            if (i4 == 2) {
+                a(i, jVar.e());
+                return true;
+            }
+            if (i4 != 3) {
+                if (i4 == 4) {
+                    return false;
+                }
+                if (i4 == 5) {
+                    a(i, Integer.valueOf(jVar.h()));
+                    return true;
+                }
+                int i5 = z.a;
+                throw new z.a();
+            }
+            l1 l1Var = new l1();
+            do {
+                t = jVar.t();
+                if (t == 0) {
+                    break;
+                }
+            } while (l1Var.a(t, jVar));
+            jVar.a(r1.a(i3, 4));
+            a(i, l1Var);
+            return true;
+        }
+        throw new UnsupportedOperationException();
+    }
+
+    public final void a(int i, Object obj) {
+        if (this.e) {
+            int i2 = this.a;
+            int[] iArr = this.b;
+            if (i2 == iArr.length) {
+                int i3 = i2 + (i2 < 4 ? 8 : i2 >> 1);
+                this.b = Arrays.copyOf(iArr, i3);
+                this.c = Arrays.copyOf(this.c, i3);
+            }
+            int[] iArr2 = this.b;
+            int i4 = this.a;
+            iArr2[i4] = i;
+            this.c[i4] = obj;
+            this.a = i4 + 1;
+            return;
+        }
+        throw new UnsupportedOperationException();
+    }
+
+    public final void a(m mVar) throws IOException {
+        if (this.a == 0) {
+            return;
+        }
+        mVar.getClass();
+        for (int i = 0; i < this.a; i++) {
+            int i2 = this.b[i];
+            Object obj = this.c[i];
+            int i3 = r1.a;
+            int i4 = i2 >>> 3;
+            int i5 = i2 & 7;
+            if (i5 == 0) {
+                mVar.a.b(i4, ((Long) obj).longValue());
+            } else if (i5 == 1) {
+                mVar.a.a(i4, ((Long) obj).longValue());
+            } else if (i5 == 2) {
+                mVar.a.b(i4, (i) obj);
+            } else if (i5 == 3) {
+                mVar.a.d(i4, 3);
+                ((l1) obj).a(mVar);
+                mVar.a.d(i4, 4);
+            } else if (i5 == 5) {
+                mVar.a.b(i4, ((Integer) obj).intValue());
+            } else {
+                int i6 = z.a;
+                throw new RuntimeException(new z.a());
+            }
+        }
+    }
+
+    public final int a() {
+        int d;
+        int a;
+        int b;
+        int i = this.d;
+        if (i != -1) {
+            return i;
+        }
+        int i2 = 0;
+        for (int i3 = 0; i3 < this.a; i3++) {
+            int i4 = this.b[i3];
+            int i5 = r1.a;
+            int i6 = i4 >>> 3;
+            int i7 = i4 & 7;
+            if (i7 != 0) {
+                if (i7 == 1) {
+                    ((Long) this.c[i3]).longValue();
+                    b = l.b(i6);
+                } else if (i7 == 2) {
+                    b = l.a(i6, (i) this.c[i3]);
+                } else if (i7 == 3) {
+                    d = l.d(i6) * 2;
+                    a = ((l1) this.c[i3]).a();
+                } else if (i7 == 5) {
+                    ((Integer) this.c[i3]).intValue();
+                    b = l.a(i6);
+                } else {
+                    int i8 = z.a;
+                    throw new IllegalStateException(new z.a());
+                }
+                i2 = b + i2;
+            } else {
+                long longValue = ((Long) this.c[i3]).longValue();
+                d = l.d(i6);
+                a = l.a(longValue);
+            }
+            i2 = a + d + i2;
+        }
+        this.d = i2;
+        return i2;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/m.java

@@ -0,0 +1,45 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+public final class m {
+    public final l a;
+
+    public m(l lVar) {
+        l lVar2 = (l) y.a(lVar, "output");
+        this.a = lVar2;
+        lVar2.a = this;
+    }
+
+    public final void a(float f, int i) throws IOException {
+        l lVar = this.a;
+        lVar.getClass();
+        lVar.b(i, Float.floatToRawIntBits(f));
+    }
+
+    public final void b(int i, d1 d1Var, Object obj) throws IOException {
+        this.a.a(i, (o0) obj, d1Var);
+    }
+
+    public final void a(int i, double d) throws IOException {
+        l lVar = this.a;
+        lVar.getClass();
+        lVar.a(i, Double.doubleToRawLongBits(d));
+    }
+
+    public final void a(int i, int i2) throws IOException {
+        this.a.e(i, l.f(i2));
+    }
+
+    public final void a(int i, long j) throws IOException {
+        this.a.b(i, l.b(j));
+    }
+
+    public final void a(int i, d1 d1Var, Object obj) throws IOException {
+        l lVar = this.a;
+        lVar.d(i, 3);
+        d1Var.a(obj, lVar.a);
+        lVar.d(i, 4);
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/m0.java

@@ -0,0 +1,10 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public interface m0 {
+    boolean a();
+
+    y0 b();
+
+    o0 c();
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/m1.java

@@ -0,0 +1,145 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+public final class m1 extends k1<l1, l1> {
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void a(l1 l1Var, int i, int i2) {
+        l1Var.a(r1.a(i, 5), Integer.valueOf(i2));
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void b() {
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void b(int i, long j, Object obj) {
+        ((l1) obj).a(r1.a(i, 0), Long.valueOf(j));
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final int c(l1 l1Var) {
+        return l1Var.a();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final int d(l1 l1Var) {
+        l1 l1Var2 = l1Var;
+        int i = l1Var2.d;
+        if (i != -1) {
+            return i;
+        }
+        int i2 = 0;
+        for (int i3 = 0; i3 < l1Var2.a; i3++) {
+            int i4 = l1Var2.b[i3];
+            int i5 = r1.a;
+            i2 += l.a(3, (i) l1Var2.c[i3]) + l.a(2, i4 >>> 3) + (l.d(1) * 2);
+        }
+        l1Var2.d = i2;
+        return i2;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void e(Object obj) {
+        ((GeneratedMessageLite) obj).unknownFields.e = false;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final l1 f(Object obj) {
+        l1 l1Var = (l1) obj;
+        l1Var.e = false;
+        return l1Var;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void a(int i, long j, Object obj) {
+        ((l1) obj).a(r1.a(i, 1), Long.valueOf(j));
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void b(Object obj, l1 l1Var) {
+        ((GeneratedMessageLite) obj).unknownFields = l1Var;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void c(Object obj, l1 l1Var) {
+        ((GeneratedMessageLite) obj).unknownFields = l1Var;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void a(int i, Object obj, Object obj2) {
+        ((l1) obj).a(r1.a(i, 3), (l1) obj2);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void b(Object obj, m mVar) throws IOException {
+        ((l1) obj).a(mVar);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void a(l1 l1Var, int i, i iVar) {
+        l1Var.a(r1.a(i, 2), iVar);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final l1 b(Object obj) {
+        return ((GeneratedMessageLite) obj).unknownFields;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final l1 a(Object obj, Object obj2) {
+        l1 l1Var = (l1) obj;
+        l1 l1Var2 = (l1) obj2;
+        return l1Var2.equals(l1.f) ? l1Var : l1.a(l1Var, l1Var2);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final void a(Object obj, m mVar) throws IOException {
+        l1 l1Var = (l1) obj;
+        l1Var.getClass();
+        mVar.getClass();
+        if (s1.ASCENDING == s1.DESCENDING) {
+            for (int i = l1Var.a - 1; i >= 0; i--) {
+                int i2 = l1Var.b[i];
+                int i3 = r1.a;
+                int i4 = i2 >>> 3;
+                Object obj2 = l1Var.c[i];
+                if (obj2 instanceof i) {
+                    mVar.a.c(i4, (i) obj2);
+                } else {
+                    mVar.a.a(i4, (o0) obj2);
+                }
+            }
+            return;
+        }
+        for (int i5 = 0; i5 < l1Var.a; i5++) {
+            int i6 = l1Var.b[i5];
+            int i7 = r1.a;
+            int i8 = i6 >>> 3;
+            Object obj3 = l1Var.c[i5];
+            if (obj3 instanceof i) {
+                mVar.a.c(i8, (i) obj3);
+            } else {
+                mVar.a.a(i8, (o0) obj3);
+            }
+        }
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final l1 a() {
+        return new l1();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.k1
+    public final l1 a(Object obj) {
+        GeneratedMessageLite generatedMessageLite = (GeneratedMessageLite) obj;
+        l1 l1Var = generatedMessageLite.unknownFields;
+        if (l1Var != l1.f) {
+            return l1Var;
+        }
+        l1 l1Var2 = new l1();
+        generatedMessageLite.unknownFields = l1Var2;
+        return l1Var2;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/n.java

@@ -0,0 +1,223 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.nio.charset.Charset;
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.RandomAccess;
+
+/* loaded from: classes2.dex */
+public final class n extends c<Double> implements y.b, RandomAccess, x0 {
+    public static final n d;
+    public double[] b;
+    public int c;
+
+    static {
+        n nVar = new n(new double[0], 0);
+        d = nVar;
+        nVar.a = false;
+    }
+
+    public n() {
+        this(new double[10], 0);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final void add(int i, Object obj) {
+        int i2;
+        double doubleValue = ((Double) obj).doubleValue();
+        e();
+        if (i < 0 || i > (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        double[] dArr = this.b;
+        if (i2 < dArr.length) {
+            System.arraycopy(dArr, i, dArr, i + 1, i2 - i);
+        } else {
+            double[] dArr2 = new double[((i2 * 3) / 2) + 1];
+            System.arraycopy(dArr, 0, dArr2, 0, i);
+            System.arraycopy(this.b, i, dArr2, i + 1, this.c - i);
+            this.b = dArr2;
+        }
+        this.b[i] = doubleValue;
+        this.c++;
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean addAll(Collection<? extends Double> collection) {
+        e();
+        Charset charset = y.a;
+        collection.getClass();
+        if (!(collection instanceof n)) {
+            return super.addAll(collection);
+        }
+        n nVar = (n) collection;
+        int i = nVar.c;
+        if (i == 0) {
+            return false;
+        }
+        int i2 = this.c;
+        if (Integer.MAX_VALUE - i2 < i) {
+            throw new OutOfMemoryError();
+        }
+        int i3 = i2 + i;
+        double[] dArr = this.b;
+        if (i3 > dArr.length) {
+            this.b = Arrays.copyOf(dArr, i3);
+        }
+        System.arraycopy(nVar.b, 0, this.b, this.c, nVar.c);
+        this.c = i3;
+        ((AbstractList) this).modCount++;
+        return true;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean contains(Object obj) {
+        return indexOf(obj) != -1;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.Collection, java.util.List
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof n)) {
+            return super.equals(obj);
+        }
+        n nVar = (n) obj;
+        if (this.c != nVar.c) {
+            return false;
+        }
+        double[] dArr = nVar.b;
+        for (int i = 0; i < this.c; i++) {
+            if (Double.doubleToLongBits(this.b[i]) != Double.doubleToLongBits(dArr[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final int indexOf(Object obj) {
+        if (!(obj instanceof Double)) {
+            return -1;
+        }
+        double doubleValue = ((Double) obj).doubleValue();
+        int i = this.c;
+        for (int i2 = 0; i2 < i; i2++) {
+            if (this.b[i2] == doubleValue) {
+                return i2;
+            }
+        }
+        return -1;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.List
+    public final Object remove(int i) {
+        int i2;
+        e();
+        if (i < 0 || i >= (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        double[] dArr = this.b;
+        double d2 = dArr[i];
+        if (i < i2 - 1) {
+            System.arraycopy(dArr, i + 1, dArr, i, (i2 - i) - 1);
+        }
+        this.c--;
+        ((AbstractList) this).modCount++;
+        return Double.valueOf(d2);
+    }
+
+    @Override // java.util.AbstractList
+    public final void removeRange(int i, int i2) {
+        e();
+        if (i2 < i) {
+            throw new IndexOutOfBoundsException("toIndex < fromIndex");
+        }
+        double[] dArr = this.b;
+        System.arraycopy(dArr, i2, dArr, i, this.c - i2);
+        this.c -= i2 - i;
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object set(int i, Object obj) {
+        double doubleValue = ((Double) obj).doubleValue();
+        e();
+        if (i < 0 || i >= this.c) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        double[] dArr = this.b;
+        double d2 = dArr[i];
+        dArr[i] = doubleValue;
+        return Double.valueOf(d2);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.c;
+    }
+
+    public n(double[] dArr, int i) {
+        this.b = dArr;
+        this.c = i;
+    }
+
+    public final void a(double d2) {
+        e();
+        int i = this.c;
+        double[] dArr = this.b;
+        if (i == dArr.length) {
+            double[] dArr2 = new double[((i * 3) / 2) + 1];
+            System.arraycopy(dArr, 0, dArr2, 0, i);
+            this.b = dArr2;
+        }
+        double[] dArr3 = this.b;
+        int i2 = this.c;
+        this.c = i2 + 1;
+        dArr3[i2] = d2;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object get(int i) {
+        if (i >= 0 && i < this.c) {
+            return Double.valueOf(this.b[i]);
+        }
+        StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+        a.append(this.c);
+        throw new IndexOutOfBoundsException(a.toString());
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.Collection, java.util.List
+    public final int hashCode() {
+        int i = 1;
+        for (int i2 = 0; i2 < this.c; i2++) {
+            i = (i * 31) + y.a(Double.doubleToLongBits(this.b[i2]));
+        }
+        return i;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.y.j
+    /* renamed from: c, reason: merged with bridge method [inline-methods] */
+    public final n a(int i) {
+        if (i >= this.c) {
+            return new n(Arrays.copyOf(this.b, i), this.c);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean add(Object obj) {
+        a(((Double) obj).doubleValue());
+        return true;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/n0.java

@@ -0,0 +1,8 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public interface n0 {
+    m0 a(Class<?> cls);
+
+    boolean b(Class<?> cls);
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/n1.java

@@ -0,0 +1,132 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.util.AbstractList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.RandomAccess;
+
+/* loaded from: classes2.dex */
+public final class n1 extends AbstractList<String> implements d0, RandomAccess {
+    public final d0 a;
+
+    public class a implements ListIterator<String> {
+        public final ListIterator<String> a;
+
+        public a(n1 n1Var, int i) {
+            this.a = n1Var.a.listIterator(i);
+        }
+
+        @Override // java.util.ListIterator
+        public final void add(String str) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.ListIterator, java.util.Iterator
+        public final boolean hasNext() {
+            return this.a.hasNext();
+        }
+
+        @Override // java.util.ListIterator
+        public final boolean hasPrevious() {
+            return this.a.hasPrevious();
+        }
+
+        @Override // java.util.ListIterator, java.util.Iterator
+        public final Object next() {
+            return this.a.next();
+        }
+
+        @Override // java.util.ListIterator
+        public final int nextIndex() {
+            return this.a.nextIndex();
+        }
+
+        @Override // java.util.ListIterator
+        public final String previous() {
+            return this.a.previous();
+        }
+
+        @Override // java.util.ListIterator
+        public final int previousIndex() {
+            return this.a.previousIndex();
+        }
+
+        @Override // java.util.ListIterator, java.util.Iterator
+        public final void remove() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // java.util.ListIterator
+        public final void set(String str) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public class b implements Iterator<String> {
+        public final Iterator<String> a;
+
+        public b(n1 n1Var) {
+            this.a = n1Var.a.iterator();
+        }
+
+        @Override // java.util.Iterator
+        public final boolean hasNext() {
+            return this.a.hasNext();
+        }
+
+        @Override // java.util.Iterator
+        public final String next() {
+            return this.a.next();
+        }
+
+        @Override // java.util.Iterator
+        public final void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public n1(d0 d0Var) {
+        this.a = d0Var;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d0
+    public final d0 b() {
+        return this;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d0
+    public final Object b(int i) {
+        return this.a.b(i);
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d0
+    public final List<?> c() {
+        return this.a.c();
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object get(int i) {
+        return (String) this.a.get(i);
+    }
+
+    @Override // java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.lang.Iterable, java.util.List
+    public final Iterator<String> iterator() {
+        return new b(this);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final ListIterator<String> listIterator(int i) {
+        return new a(this, i);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.a.size();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d0
+    public final void a(i iVar) {
+        throw new UnsupportedOperationException();
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/o.java

@@ -0,0 +1,7 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.o0;
+
+/* loaded from: classes2.dex */
+public abstract class o<ContainingType extends o0, Type> {
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/o0.java

@@ -0,0 +1,20 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+public interface o0 extends p0 {
+
+    public interface a extends p0, Cloneable {
+    }
+
+    int getSerializedSize();
+
+    a newBuilderForType();
+
+    a toBuilder();
+
+    i toByteString();
+
+    void writeTo(l lVar) throws IOException;
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/o1.java

@@ -0,0 +1,20 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.lang.reflect.Field;
+import java.security.PrivilegedExceptionAction;
+import sun.misc.Unsafe;
+
+/* loaded from: classes2.dex */
+public final class o1 implements PrivilegedExceptionAction<Unsafe> {
+    @Override // java.security.PrivilegedExceptionAction
+    public final Unsafe run() throws Exception {
+        for (Field field : Unsafe.class.getDeclaredFields()) {
+            field.setAccessible(true);
+            Object obj = field.get(null);
+            if (Unsafe.class.isInstance(obj)) {
+                return (Unsafe) Unsafe.class.cast(obj);
+            }
+        }
+        return null;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/p.java

@@ -0,0 +1,16 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class p {
+    public static final Class<?> a;
+
+    static {
+        Class<?> cls;
+        try {
+            cls = Class.forName("com.google.protobuf.ExtensionRegistry");
+        } catch (ClassNotFoundException unused) {
+            cls = null;
+        }
+        a = cls;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/p0.java

@@ -0,0 +1,8 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public interface p0 {
+    o0 getDefaultInstanceForType();
+
+    boolean isInitialized();
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/p1.java

@@ -0,0 +1,584 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import sun.misc.Unsafe;
+
+/* loaded from: classes2.dex */
+public final class p1 {
+    public static final Unsafe a;
+    public static final Class<?> b;
+    public static final d c;
+    public static final boolean d;
+    public static final boolean e;
+    public static final long f;
+    public static final long g;
+    public static final boolean h;
+
+    /* JADX WARN: Can't wrap try/catch for region: R(23:0|1|(2:2|3)|4|(17:6|(1:(1:9)(1:(1:46)))(1:47)|10|(1:12)(1:44)|13|(1:15)(1:43)|16|(3:18|19|20)|35|36|37|(1:39)|(1:32)(1:25)|26|(1:28)|29|30)|48|10|(0)(0)|13|(0)(0)|16|(0)|35|36|37|(0)|(0)|32|26|(0)|29|30|(1:(0))) */
+    /* JADX WARN: Code restructure failed: missing block: B:21:0x00a0, code lost:
+    
+        if (r3 == null) goto L33;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:22:0x00a2, code lost:
+    
+        r0 = r3;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:40:0x00b4, code lost:
+    
+        if (r3.getType() == java.lang.Long.TYPE) goto L32;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:42:0x00ab, code lost:
+    
+        r3 = null;
+     */
+    /* JADX WARN: Removed duplicated region for block: B:12:0x0045  */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x004f  */
+    /* JADX WARN: Removed duplicated region for block: B:18:0x0098  */
+    /* JADX WARN: Removed duplicated region for block: B:28:0x00cf  */
+    /* JADX WARN: Removed duplicated region for block: B:39:0x00ae  */
+    /* JADX WARN: Removed duplicated region for block: B:43:0x0051  */
+    /* JADX WARN: Removed duplicated region for block: B:44:0x0047  */
+    static {
+        /*
+            r0 = 0
+            com.fyber.inneractive.sdk.protobuf.o1 r1 = new com.fyber.inneractive.sdk.protobuf.o1     // Catch: java.lang.Throwable -> Ld
+            r1.<init>()     // Catch: java.lang.Throwable -> Ld
+            java.lang.Object r1 = java.security.AccessController.doPrivileged(r1)     // Catch: java.lang.Throwable -> Ld
+            sun.misc.Unsafe r1 = (sun.misc.Unsafe) r1     // Catch: java.lang.Throwable -> Ld
+            goto Le
+        Ld:
+            r1 = r0
+        Le:
+            com.fyber.inneractive.sdk.protobuf.p1.a = r1
+            java.lang.Class<?> r2 = com.fyber.inneractive.sdk.protobuf.d.a
+            com.fyber.inneractive.sdk.protobuf.p1.b = r2
+            java.lang.Class r2 = java.lang.Long.TYPE
+            boolean r2 = c(r2)
+            java.lang.Class r3 = java.lang.Integer.TYPE
+            boolean r3 = c(r3)
+            if (r1 != 0) goto L23
+            goto L39
+        L23:
+            boolean r4 = com.fyber.inneractive.sdk.protobuf.d.a()
+            if (r4 == 0) goto L3b
+            if (r2 == 0) goto L31
+            com.fyber.inneractive.sdk.protobuf.p1$b r2 = new com.fyber.inneractive.sdk.protobuf.p1$b
+            r2.<init>(r1)
+            goto L40
+        L31:
+            if (r3 == 0) goto L39
+            com.fyber.inneractive.sdk.protobuf.p1$a r2 = new com.fyber.inneractive.sdk.protobuf.p1$a
+            r2.<init>(r1)
+            goto L40
+        L39:
+            r2 = r0
+            goto L40
+        L3b:
+            com.fyber.inneractive.sdk.protobuf.p1$c r2 = new com.fyber.inneractive.sdk.protobuf.p1$c
+            r2.<init>(r1)
+        L40:
+            com.fyber.inneractive.sdk.protobuf.p1.c = r2
+            r1 = 0
+            if (r2 != 0) goto L47
+            r3 = r1
+            goto L4b
+        L47:
+            boolean r3 = r2.b()
+        L4b:
+            com.fyber.inneractive.sdk.protobuf.p1.d = r3
+            if (r2 != 0) goto L51
+            r3 = r1
+            goto L55
+        L51:
+            boolean r3 = r2.a()
+        L55:
+            com.fyber.inneractive.sdk.protobuf.p1.e = r3
+            java.lang.Class<byte[]> r3 = byte[].class
+            int r3 = a(r3)
+            long r3 = (long) r3
+            com.fyber.inneractive.sdk.protobuf.p1.f = r3
+            java.lang.Class<boolean[]> r3 = boolean[].class
+            a(r3)
+            b(r3)
+            java.lang.Class<int[]> r3 = int[].class
+            a(r3)
+            b(r3)
+            java.lang.Class<long[]> r3 = long[].class
+            a(r3)
+            b(r3)
+            java.lang.Class<float[]> r3 = float[].class
+            a(r3)
+            b(r3)
+            java.lang.Class<double[]> r3 = double[].class
+            a(r3)
+            b(r3)
+            java.lang.Class<java.lang.Object[]> r3 = java.lang.Object[].class
+            a(r3)
+            b(r3)
+            boolean r3 = com.fyber.inneractive.sdk.protobuf.d.a()
+            java.lang.Class<java.nio.Buffer> r4 = java.nio.Buffer.class
+            if (r3 == 0) goto La4
+            java.lang.String r3 = "effectiveDirectAddress"
+            java.lang.reflect.Field r3 = r4.getDeclaredField(r3)     // Catch: java.lang.Throwable -> L9f
+            goto La0
+        L9f:
+            r3 = r0
+        La0:
+            if (r3 == 0) goto La4
+        La2:
+            r0 = r3
+            goto Lb7
+        La4:
+            java.lang.String r3 = "address"
+            java.lang.reflect.Field r3 = r4.getDeclaredField(r3)     // Catch: java.lang.Throwable -> Lab
+            goto Lac
+        Lab:
+            r3 = r0
+        Lac:
+            if (r3 == 0) goto Lb7
+            java.lang.Class r4 = r3.getType()
+            java.lang.Class r5 = java.lang.Long.TYPE
+            if (r4 != r5) goto Lb7
+            goto La2
+        Lb7:
+            if (r0 == 0) goto Lc3
+            if (r2 != 0) goto Lbc
+            goto Lc3
+        Lbc:
+            sun.misc.Unsafe r2 = r2.a
+            long r2 = r2.objectFieldOffset(r0)
+            goto Lc5
+        Lc3:
+            r2 = -1
+        Lc5:
+            com.fyber.inneractive.sdk.protobuf.p1.g = r2
+            java.nio.ByteOrder r0 = java.nio.ByteOrder.nativeOrder()
+            java.nio.ByteOrder r2 = java.nio.ByteOrder.BIG_ENDIAN
+            if (r0 != r2) goto Ld0
+            r1 = 1
+        Ld0:
+            com.fyber.inneractive.sdk.protobuf.p1.h = r1
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.p1.<clinit>():void");
+    }
+
+    public static boolean c(Class<?> cls) {
+        if (!com.fyber.inneractive.sdk.protobuf.d.a()) {
+            return false;
+        }
+        try {
+            Class<?> cls2 = b;
+            Class<?> cls3 = Boolean.TYPE;
+            cls2.getMethod("peekLong", cls, cls3);
+            cls2.getMethod("pokeLong", cls, Long.TYPE, cls3);
+            Class<?> cls4 = Integer.TYPE;
+            cls2.getMethod("pokeInt", cls, cls4, cls3);
+            cls2.getMethod("peekInt", cls, cls3);
+            cls2.getMethod("pokeByte", cls, Byte.TYPE);
+            cls2.getMethod("peekByte", cls);
+            cls2.getMethod("pokeByteArray", cls, byte[].class, cls4, cls4);
+            cls2.getMethod("peekByteArray", cls, byte[].class, cls4, cls4);
+            return true;
+        } catch (Throwable unused) {
+            return false;
+        }
+    }
+
+    public static byte d(Object obj, long j) {
+        return (byte) ((e(obj, (-4) & j) >>> ((int) ((j & 3) << 3))) & 255);
+    }
+
+    public static int a(Class<?> cls) {
+        if (e) {
+            return c.a.arrayBaseOffset(cls);
+        }
+        return -1;
+    }
+
+    public static void b(Class cls) {
+        if (e) {
+            c.a.arrayIndexScale(cls);
+        }
+    }
+
+    public static int e(Object obj, long j) {
+        return c.a.getInt(obj, j);
+    }
+
+    public static long f(Object obj, long j) {
+        return c.a.getLong(obj, j);
+    }
+
+    public static Object g(Object obj, long j) {
+        return c.a.getObject(obj, j);
+    }
+
+    public static final class a extends d {
+        public a(Unsafe unsafe) {
+            super(unsafe);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, byte b) {
+            if (p1.h) {
+                p1.a(obj, j, b);
+            } else {
+                p1.b(obj, j, b);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final byte b(Object obj, long j) {
+            return p1.h ? p1.c(obj, j) : p1.d(obj, j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final boolean b() {
+            return false;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final double c(Object obj, long j) {
+            return Double.longBitsToDouble(this.a.getLong(obj, j));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final float d(Object obj, long j) {
+            return Float.intBitsToFloat(this.a.getInt(obj, j));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final boolean a(Object obj, long j) {
+            if (p1.h) {
+                return p1.a(obj, j);
+            }
+            return p1.b(obj, j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, boolean z) {
+            if (p1.h) {
+                p1.a(obj, j, z ? (byte) 1 : (byte) 0);
+            } else {
+                p1.b(obj, j, z ? (byte) 1 : (byte) 0);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, float f) {
+            this.a.putInt(obj, j, Float.floatToIntBits(f));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, double d) {
+            this.a.putLong(obj, j, Double.doubleToLongBits(d));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final byte a(long j) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(long j, byte[] bArr, long j2) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public static final class b extends d {
+        public b(Unsafe unsafe) {
+            super(unsafe);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, byte b) {
+            if (p1.h) {
+                p1.a(obj, j, b);
+            } else {
+                p1.b(obj, j, b);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final byte b(Object obj, long j) {
+            return p1.h ? p1.c(obj, j) : p1.d(obj, j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final boolean b() {
+            return false;
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final double c(Object obj, long j) {
+            return Double.longBitsToDouble(this.a.getLong(obj, j));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final float d(Object obj, long j) {
+            return Float.intBitsToFloat(this.a.getInt(obj, j));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final boolean a(Object obj, long j) {
+            if (p1.h) {
+                return p1.a(obj, j);
+            }
+            return p1.b(obj, j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, boolean z) {
+            if (p1.h) {
+                p1.a(obj, j, z ? (byte) 1 : (byte) 0);
+            } else {
+                p1.b(obj, j, z ? (byte) 1 : (byte) 0);
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, float f) {
+            this.a.putInt(obj, j, Float.floatToIntBits(f));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, double d) {
+            this.a.putLong(obj, j, Double.doubleToLongBits(d));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final byte a(long j) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(long j, byte[] bArr, long j2) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public static final class c extends d {
+        public c(Unsafe unsafe) {
+            super(unsafe);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final boolean a() {
+            if (!super.a()) {
+                return false;
+            }
+            try {
+                Class<?> cls = this.a.getClass();
+                Class<?> cls2 = Long.TYPE;
+                cls.getMethod("getByte", Object.class, cls2);
+                cls.getMethod("putByte", Object.class, cls2, Byte.TYPE);
+                cls.getMethod("getBoolean", Object.class, cls2);
+                cls.getMethod("putBoolean", Object.class, cls2, Boolean.TYPE);
+                cls.getMethod("getFloat", Object.class, cls2);
+                cls.getMethod("putFloat", Object.class, cls2, Float.TYPE);
+                cls.getMethod("getDouble", Object.class, cls2);
+                cls.getMethod("putDouble", Object.class, cls2, Double.TYPE);
+                return true;
+            } catch (Throwable th) {
+                Logger.getLogger(p1.class.getName()).log(Level.WARNING, "platform method missing - proto runtime falling back to safer methods: " + th);
+                return false;
+            }
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final double c(Object obj, long j) {
+            return this.a.getDouble(obj, j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final float d(Object obj, long j) {
+            return this.a.getFloat(obj, j);
+        }
+
+        /* JADX WARN: Code restructure failed: missing block: B:12:0x003e, code lost:
+        
+            if (r5 == null) goto L16;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:13:0x0040, code lost:
+        
+            r10 = r5;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:29:0x0055, code lost:
+        
+            if (r5.getType() == java.lang.Long.TYPE) goto L13;
+         */
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final boolean b() {
+            /*
+                Method dump skipped, instructions count: 245
+                To view this dump add '--comments-level debug' option
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.p1.c.b():boolean");
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, byte b) {
+            this.a.putByte(obj, j, b);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final boolean a(Object obj, long j) {
+            return this.a.getBoolean(obj, j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, boolean z) {
+            this.a.putBoolean(obj, j, z);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, float f) {
+            this.a.putFloat(obj, j, f);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(Object obj, long j, double d) {
+            this.a.putDouble(obj, j, d);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final byte a(long j) {
+            return this.a.getByte(j);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final void a(long j, byte[] bArr, long j2) {
+            this.a.copyMemory((Object) null, j, bArr, p1.f, j2);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.p1.d
+        public final byte b(Object obj, long j) {
+            return this.a.getByte(obj, j);
+        }
+    }
+
+    public static abstract class d {
+        public final Unsafe a;
+
+        public d(Unsafe unsafe) {
+            this.a = unsafe;
+        }
+
+        public abstract byte a(long j);
+
+        public abstract void a(long j, byte[] bArr, long j2);
+
+        public abstract void a(Object obj, long j, byte b);
+
+        public abstract void a(Object obj, long j, double d);
+
+        public abstract void a(Object obj, long j, float f);
+
+        public abstract void a(Object obj, long j, boolean z);
+
+        public abstract boolean a(Object obj, long j);
+
+        public abstract byte b(Object obj, long j);
+
+        public abstract boolean b();
+
+        public abstract double c(Object obj, long j);
+
+        public abstract float d(Object obj, long j);
+
+        public boolean a() {
+            Unsafe unsafe = this.a;
+            if (unsafe == null) {
+                return false;
+            }
+            try {
+                Class<?> cls = unsafe.getClass();
+                cls.getMethod("objectFieldOffset", Field.class);
+                cls.getMethod("arrayBaseOffset", Class.class);
+                cls.getMethod("arrayIndexScale", Class.class);
+                Class<?> cls2 = Long.TYPE;
+                cls.getMethod("getInt", Object.class, cls2);
+                cls.getMethod("putInt", Object.class, cls2, Integer.TYPE);
+                cls.getMethod("getLong", Object.class, cls2);
+                cls.getMethod("putLong", Object.class, cls2, cls2);
+                cls.getMethod("getObject", Object.class, cls2);
+                cls.getMethod("putObject", Object.class, cls2, Object.class);
+                return true;
+            } catch (Throwable th) {
+                Unsafe unsafe2 = p1.a;
+                Logger.getLogger(p1.class.getName()).log(Level.WARNING, "platform method missing - proto runtime falling back to safer methods: " + th);
+                return false;
+            }
+        }
+    }
+
+    public static void b(Object obj, long j, byte b2) {
+        long j2 = (-4) & j;
+        int i = (((int) j) & 3) << 3;
+        a(((255 & b2) << i) | (e(obj, j2) & (~(255 << i))), j2, obj);
+    }
+
+    public static void a(int i, long j, Object obj) {
+        c.a.putInt(obj, j, i);
+    }
+
+    public static void a(Object obj, long j, long j2) {
+        c.a.putLong(obj, j, j2);
+    }
+
+    public static boolean b(Object obj, long j) {
+        return d(obj, j) != 0;
+    }
+
+    public static void a(Object obj, long j, boolean z) {
+        c.a(obj, j, z);
+    }
+
+    public static void a(Object obj, long j, float f2) {
+        c.a(obj, j, f2);
+    }
+
+    public static void a(Object obj, long j, double d2) {
+        c.a(obj, j, d2);
+    }
+
+    public static void a(long j, Object obj, Object obj2) {
+        c.a.putObject(obj, j, obj2);
+    }
+
+    public static byte c(Object obj, long j) {
+        return (byte) ((e(obj, (-4) & j) >>> ((int) (((~j) & 3) << 3))) & 255);
+    }
+
+    public static byte a(byte[] bArr, long j) {
+        return c.b(bArr, f + j);
+    }
+
+    public static void a(byte[] bArr, long j, byte b2) {
+        c.a((Object) bArr, f + j, b2);
+    }
+
+    public static long a(ByteBuffer byteBuffer) {
+        d dVar = c;
+        return dVar.a.getLong(byteBuffer, g);
+    }
+
+    public static void a(Object obj, long j, byte b2) {
+        long j2 = (-4) & j;
+        int e2 = e(obj, j2);
+        int i = ((~((int) j)) & 3) << 3;
+        a(((255 & b2) << i) | (e2 & (~(255 << i))), j2, obj);
+    }
+
+    public static boolean a(Object obj, long j) {
+        return c(obj, j) != 0;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/q.java

@@ -0,0 +1,69 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import androidx.core.internal.view.SupportMenu;
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public final class q {
+    public static volatile q b;
+    public static final q c = new q(0);
+    public final Map<a, GeneratedMessageLite.e<?, ?>> a;
+
+    public static final class a {
+        public final Object a;
+        public final int b;
+
+        public a(int i, Object obj) {
+            this.a = obj;
+            this.b = i;
+        }
+
+        public final boolean equals(Object obj) {
+            if (!(obj instanceof a)) {
+                return false;
+            }
+            a aVar = (a) obj;
+            return this.a == aVar.a && this.b == aVar.b;
+        }
+
+        public final int hashCode() {
+            return (System.identityHashCode(this.a) * SupportMenu.USER_MASK) + this.b;
+        }
+    }
+
+    public q() {
+        this.a = new HashMap();
+    }
+
+    public q(int i) {
+        this.a = Collections.emptyMap();
+    }
+
+    public static q a() {
+        q qVar = b;
+        if (qVar == null) {
+            synchronized (q.class) {
+                qVar = b;
+                if (qVar == null) {
+                    Class<?> cls = p.a;
+                    q qVar2 = null;
+                    if (cls != null) {
+                        try {
+                            qVar2 = (q) cls.getDeclaredMethod("getEmptyRegistry", new Class[0]).invoke(null, new Object[0]);
+                        } catch (Exception unused) {
+                        }
+                    }
+                    if (qVar2 == null) {
+                        qVar2 = c;
+                    }
+                    b = qVar2;
+                    qVar = qVar2;
+                }
+            }
+        }
+        return qVar;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/q0.java

@@ -0,0 +1,83 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public final class q0 {
+    /* JADX WARN: Removed duplicated region for block: B:64:0x0275  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static void a(com.fyber.inneractive.sdk.protobuf.o0 r16, java.lang.StringBuilder r17, int r18) {
+        /*
+            Method dump skipped, instructions count: 754
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.q0.a(com.fyber.inneractive.sdk.protobuf.o0, java.lang.StringBuilder, int):void");
+    }
+
+    public static final void a(StringBuilder sb, int i, String str, Object obj) {
+        if (obj instanceof List) {
+            Iterator it = ((List) obj).iterator();
+            while (it.hasNext()) {
+                a(sb, i, str, it.next());
+            }
+            return;
+        }
+        if (obj instanceof Map) {
+            Iterator it2 = ((Map) obj).entrySet().iterator();
+            while (it2.hasNext()) {
+                a(sb, i, str, (Map.Entry) it2.next());
+            }
+            return;
+        }
+        sb.append('\n');
+        int i2 = 0;
+        for (int i3 = 0; i3 < i; i3++) {
+            sb.append(' ');
+        }
+        sb.append(str);
+        if (obj instanceof String) {
+            sb.append(": \"");
+            sb.append(i1.a(i.a((String) obj)));
+            sb.append('\"');
+            return;
+        }
+        if (obj instanceof i) {
+            sb.append(": \"");
+            sb.append(i1.a((i) obj));
+            sb.append('\"');
+            return;
+        }
+        if (obj instanceof GeneratedMessageLite) {
+            sb.append(" {");
+            a((GeneratedMessageLite) obj, sb, i + 2);
+            sb.append("\n");
+            while (i2 < i) {
+                sb.append(' ');
+                i2++;
+            }
+            sb.append("}");
+            return;
+        }
+        if (obj instanceof Map.Entry) {
+            sb.append(" {");
+            Map.Entry entry = (Map.Entry) obj;
+            int i4 = i + 2;
+            a(sb, i4, "key", entry.getKey());
+            a(sb, i4, "value", entry.getValue());
+            sb.append("\n");
+            while (i2 < i) {
+                sb.append(' ');
+                i2++;
+            }
+            sb.append("}");
+            return;
+        }
+        sb.append(": ");
+        sb.append(obj.toString());
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/q1.java

@@ -0,0 +1,580 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.applovin.exoplayer2.common.base.Ascii;
+import com.fyber.inneractive.sdk.protobuf.p1;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes2.dex */
+public final class q1 {
+    public static final b a;
+
+    public static abstract class b {
+        public static String a(ByteBuffer byteBuffer, int i, int i2) throws z {
+            if ((i | i2 | ((byteBuffer.limit() - i) - i2)) < 0) {
+                throw new ArrayIndexOutOfBoundsException(String.format("buffer limit=%d, index=%d, limit=%d", Integer.valueOf(byteBuffer.limit()), Integer.valueOf(i), Integer.valueOf(i2)));
+            }
+            int i3 = i + i2;
+            char[] cArr = new char[i2];
+            int i4 = 0;
+            while (i < i3) {
+                byte b = byteBuffer.get(i);
+                if (!a.a(b)) {
+                    break;
+                }
+                i++;
+                cArr[i4] = (char) b;
+                i4++;
+            }
+            int i5 = i4;
+            while (i < i3) {
+                int i6 = i + 1;
+                byte b2 = byteBuffer.get(i);
+                if (a.a(b2)) {
+                    cArr[i5] = (char) b2;
+                    i5++;
+                    i = i6;
+                    while (i < i3) {
+                        byte b3 = byteBuffer.get(i);
+                        if (!a.a(b3)) {
+                            break;
+                        }
+                        i++;
+                        cArr[i5] = (char) b3;
+                        i5++;
+                    }
+                } else if (a.b(b2)) {
+                    if (i6 >= i3) {
+                        throw z.c();
+                    }
+                    i += 2;
+                    a.a(b2, byteBuffer.get(i6), cArr, i5);
+                    i5++;
+                } else if (a.c(b2)) {
+                    if (i6 >= i3 - 1) {
+                        throw z.c();
+                    }
+                    int i7 = i + 2;
+                    i += 3;
+                    a.a(b2, byteBuffer.get(i6), byteBuffer.get(i7), cArr, i5);
+                    i5++;
+                } else {
+                    if (i6 >= i3 - 2) {
+                        throw z.c();
+                    }
+                    byte b4 = byteBuffer.get(i6);
+                    int i8 = i + 3;
+                    byte b5 = byteBuffer.get(i + 2);
+                    i += 4;
+                    a.a(b2, b4, b5, byteBuffer.get(i8), cArr, i5);
+                    i5 += 2;
+                }
+            }
+            return new String(cArr, 0, i5);
+        }
+
+        public abstract int a(int i, int i2, int i3, byte[] bArr);
+
+        public abstract int a(CharSequence charSequence, byte[] bArr, int i, int i2);
+
+        public abstract String a(byte[] bArr, int i, int i2) throws z;
+
+        public abstract String b(ByteBuffer byteBuffer, int i, int i2) throws z;
+
+        public final boolean b(byte[] bArr, int i, int i2) {
+            return a(0, i, i2, bArr) == 0;
+        }
+    }
+
+    public static class d extends IllegalArgumentException {
+        public d(int i, int i2) {
+            super("Unpaired surrogate at index " + i + " of " + i2);
+        }
+    }
+
+    static {
+        a = (p1.e && p1.d && !com.fyber.inneractive.sdk.protobuf.d.a()) ? new e() : new c();
+    }
+
+    public static int a(int i, int i2) {
+        if (i > -12 || i2 > -65) {
+            return -1;
+        }
+        return i ^ (i2 << 8);
+    }
+
+    public static int a(int i, int i2, int i3) {
+        if (i > -12 || i2 > -65 || i3 > -65) {
+            return -1;
+        }
+        return (i ^ (i2 << 8)) ^ (i3 << 16);
+    }
+
+    public static int a(CharSequence charSequence) {
+        int length = charSequence.length();
+        int i = 0;
+        int i2 = 0;
+        while (i2 < length && charSequence.charAt(i2) < 128) {
+            i2++;
+        }
+        int i3 = length;
+        while (true) {
+            if (i2 >= length) {
+                break;
+            }
+            char charAt = charSequence.charAt(i2);
+            if (charAt < 2048) {
+                i3 += (127 - charAt) >>> 31;
+                i2++;
+            } else {
+                int length2 = charSequence.length();
+                while (i2 < length2) {
+                    char charAt2 = charSequence.charAt(i2);
+                    if (charAt2 < 2048) {
+                        i += (127 - charAt2) >>> 31;
+                    } else {
+                        i += 2;
+                        if (55296 <= charAt2 && charAt2 <= 57343) {
+                            if (Character.codePointAt(charSequence, i2) < 65536) {
+                                throw new d(i2, length2);
+                            }
+                            i2++;
+                        }
+                    }
+                    i2++;
+                }
+                i3 += i;
+            }
+        }
+        if (i3 >= length) {
+            return i3;
+        }
+        throw new IllegalArgumentException("UTF-8 length does not fit in int: " + (i3 + 4294967296L));
+    }
+
+    public static class a {
+        public static void a(byte b, byte b2, char[] cArr, int i) throws z {
+            if (b < -62 || d(b2)) {
+                throw z.c();
+            }
+            cArr[i] = (char) (((b & Ascii.US) << 6) | (b2 & 63));
+        }
+
+        public static boolean a(byte b) {
+            return b >= 0;
+        }
+
+        public static boolean b(byte b) {
+            return b < -32;
+        }
+
+        public static boolean c(byte b) {
+            return b < -16;
+        }
+
+        public static boolean d(byte b) {
+            return b > -65;
+        }
+
+        public static void a(byte b, byte b2, byte b3, char[] cArr, int i) throws z {
+            if (!d(b2) && ((b != -32 || b2 >= -96) && ((b != -19 || b2 < -96) && !d(b3)))) {
+                cArr[i] = (char) (((b & Ascii.SI) << 12) | ((b2 & 63) << 6) | (b3 & 63));
+                return;
+            }
+            throw z.c();
+        }
+
+        public static void a(byte b, byte b2, byte b3, byte b4, char[] cArr, int i) throws z {
+            if (!d(b2)) {
+                if ((((b2 + 112) + (b << Ascii.FS)) >> 30) == 0 && !d(b3) && !d(b4)) {
+                    int i2 = ((b & 7) << 18) | ((b2 & 63) << 12) | ((b3 & 63) << 6) | (b4 & 63);
+                    cArr[i] = (char) ((i2 >>> 10) + 55232);
+                    cArr[i + 1] = (char) ((i2 & 1023) + 56320);
+                    return;
+                }
+            }
+            throw z.c();
+        }
+    }
+
+    public static final class c extends b {
+        /* JADX WARN: Code restructure failed: missing block: B:26:0x004f, code lost:
+        
+            if (r21[r0] > (-65)) goto L29;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:47:0x0090, code lost:
+        
+            if (r21[r0] > (-65)) goto L50;
+         */
+        @Override // com.fyber.inneractive.sdk.protobuf.q1.b
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final int a(int r18, int r19, int r20, byte[] r21) {
+            /*
+                Method dump skipped, instructions count: 325
+                To view this dump add '--comments-level debug' option
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.q1.c.a(int, int, int, byte[]):int");
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.q1.b
+        public final String b(ByteBuffer byteBuffer, int i, int i2) throws z {
+            return b.a(byteBuffer, i, i2);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.q1.b
+        public final String a(byte[] bArr, int i, int i2) throws z {
+            if ((i | i2 | ((bArr.length - i) - i2)) >= 0) {
+                int i3 = i + i2;
+                char[] cArr = new char[i2];
+                int i4 = 0;
+                while (i < i3) {
+                    byte b = bArr[i];
+                    if (!a.a(b)) {
+                        break;
+                    }
+                    i++;
+                    cArr[i4] = (char) b;
+                    i4++;
+                }
+                int i5 = i4;
+                while (i < i3) {
+                    int i6 = i + 1;
+                    byte b2 = bArr[i];
+                    if (a.a(b2)) {
+                        cArr[i5] = (char) b2;
+                        i5++;
+                        i = i6;
+                        while (i < i3) {
+                            byte b3 = bArr[i];
+                            if (!a.a(b3)) {
+                                break;
+                            }
+                            i++;
+                            cArr[i5] = (char) b3;
+                            i5++;
+                        }
+                    } else if (a.b(b2)) {
+                        if (i6 < i3) {
+                            i += 2;
+                            a.a(b2, bArr[i6], cArr, i5);
+                            i5++;
+                        } else {
+                            throw z.c();
+                        }
+                    } else if (a.c(b2)) {
+                        if (i6 < i3 - 1) {
+                            int i7 = i + 2;
+                            i += 3;
+                            a.a(b2, bArr[i6], bArr[i7], cArr, i5);
+                            i5++;
+                        } else {
+                            throw z.c();
+                        }
+                    } else if (i6 < i3 - 2) {
+                        byte b4 = bArr[i6];
+                        int i8 = i + 3;
+                        byte b5 = bArr[i + 2];
+                        i += 4;
+                        a.a(b2, b4, b5, bArr[i8], cArr, i5);
+                        i5 += 2;
+                    } else {
+                        throw z.c();
+                    }
+                }
+                return new String(cArr, 0, i5);
+            }
+            throw new ArrayIndexOutOfBoundsException(String.format("buffer length=%d, index=%d, size=%d", Integer.valueOf(bArr.length), Integer.valueOf(i), Integer.valueOf(i2)));
+        }
+
+        /* JADX WARN: Code restructure failed: missing block: B:12:0x001d, code lost:
+        
+            return r10 + r0;
+         */
+        @Override // com.fyber.inneractive.sdk.protobuf.q1.b
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final int a(java.lang.CharSequence r8, byte[] r9, int r10, int r11) {
+            /*
+                Method dump skipped, instructions count: 251
+                To view this dump add '--comments-level debug' option
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.q1.c.a(java.lang.CharSequence, byte[], int, int):int");
+        }
+    }
+
+    public static final class e extends b {
+        /* JADX WARN: Code restructure failed: missing block: B:101:?, code lost:
+        
+            return r1;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:128:0x017d, code lost:
+        
+            if (r1 > (-12)) goto L130;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:13:0x0034, code lost:
+        
+            if (com.fyber.inneractive.sdk.protobuf.p1.a(r26, r4) > (-65)) goto L16;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:30:0x0065, code lost:
+        
+            if (com.fyber.inneractive.sdk.protobuf.p1.a(r26, r4) > (-65)) goto L32;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:50:0x00a9, code lost:
+        
+            if (com.fyber.inneractive.sdk.protobuf.p1.a(r26, r4) > (-65)) goto L53;
+         */
+        /* JADX WARN: Code restructure failed: missing block: B:99:0x012e, code lost:
+        
+            if (r1 > (-12)) goto L130;
+         */
+        @Override // com.fyber.inneractive.sdk.protobuf.q1.b
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final int a(int r23, int r24, int r25, byte[] r26) {
+            /*
+                Method dump skipped, instructions count: 456
+                To view this dump add '--comments-level debug' option
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.q1.e.a(int, int, int, byte[]):int");
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.q1.b
+        public final String b(ByteBuffer byteBuffer, int i, int i2) throws z {
+            long j;
+            if ((i | i2 | ((byteBuffer.limit() - i) - i2)) < 0) {
+                throw new ArrayIndexOutOfBoundsException(String.format("buffer limit=%d, index=%d, limit=%d", Integer.valueOf(byteBuffer.limit()), Integer.valueOf(i), Integer.valueOf(i2)));
+            }
+            long a = p1.a(byteBuffer) + i;
+            long j2 = i2 + a;
+            char[] cArr = new char[i2];
+            int i3 = 0;
+            while (true) {
+                j = 1;
+                if (a >= j2) {
+                    break;
+                }
+                byte a2 = p1.c.a(a);
+                if (!a.a(a2)) {
+                    break;
+                }
+                a++;
+                cArr[i3] = (char) a2;
+                i3++;
+            }
+            int i4 = i3;
+            while (a < j2) {
+                long j3 = a + j;
+                p1.d dVar = p1.c;
+                byte a3 = dVar.a(a);
+                if (a.a(a3)) {
+                    cArr[i4] = (char) a3;
+                    i4++;
+                    a = j3;
+                    while (a < j2) {
+                        byte a4 = p1.c.a(a);
+                        if (!a.a(a4)) {
+                            break;
+                        }
+                        a += j;
+                        cArr[i4] = (char) a4;
+                        i4++;
+                    }
+                } else if (a.b(a3)) {
+                    if (j3 >= j2) {
+                        throw z.c();
+                    }
+                    a += 2;
+                    a.a(a3, dVar.a(j3), cArr, i4);
+                    i4++;
+                } else if (a.c(a3)) {
+                    if (j3 >= j2 - j) {
+                        throw z.c();
+                    }
+                    long j4 = a + 2;
+                    a += 3;
+                    a.a(a3, dVar.a(j3), dVar.a(j4), cArr, i4);
+                    i4++;
+                } else {
+                    if (j3 >= j2 - 2) {
+                        throw z.c();
+                    }
+                    byte a5 = dVar.a(j3);
+                    long j5 = a + 3;
+                    byte a6 = dVar.a(a + 2);
+                    a += 4;
+                    a.a(a3, a5, a6, dVar.a(j5), cArr, i4);
+                    i4 += 2;
+                    j = 1;
+                }
+            }
+            return new String(cArr, 0, i4);
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.q1.b
+        public final String a(byte[] bArr, int i, int i2) throws z {
+            if ((i | i2 | ((bArr.length - i) - i2)) >= 0) {
+                int i3 = i + i2;
+                char[] cArr = new char[i2];
+                int i4 = 0;
+                while (i < i3) {
+                    byte a = p1.a(bArr, i);
+                    if (!a.a(a)) {
+                        break;
+                    }
+                    i++;
+                    cArr[i4] = (char) a;
+                    i4++;
+                }
+                int i5 = i4;
+                while (i < i3) {
+                    int i6 = i + 1;
+                    byte a2 = p1.a(bArr, i);
+                    if (a.a(a2)) {
+                        cArr[i5] = (char) a2;
+                        i5++;
+                        i = i6;
+                        while (i < i3) {
+                            byte a3 = p1.a(bArr, i);
+                            if (!a.a(a3)) {
+                                break;
+                            }
+                            i++;
+                            cArr[i5] = (char) a3;
+                            i5++;
+                        }
+                    } else if (a.b(a2)) {
+                        if (i6 < i3) {
+                            i += 2;
+                            a.a(a2, p1.a(bArr, i6), cArr, i5);
+                            i5++;
+                        } else {
+                            throw z.c();
+                        }
+                    } else if (a.c(a2)) {
+                        if (i6 < i3 - 1) {
+                            int i7 = i + 2;
+                            i += 3;
+                            a.a(a2, p1.a(bArr, i6), p1.a(bArr, i7), cArr, i5);
+                            i5++;
+                        } else {
+                            throw z.c();
+                        }
+                    } else if (i6 < i3 - 2) {
+                        byte a4 = p1.a(bArr, i6);
+                        int i8 = i + 3;
+                        byte a5 = p1.a(bArr, i + 2);
+                        i += 4;
+                        a.a(a2, a4, a5, p1.a(bArr, i8), cArr, i5);
+                        i5 += 2;
+                    } else {
+                        throw z.c();
+                    }
+                }
+                return new String(cArr, 0, i5);
+            }
+            throw new ArrayIndexOutOfBoundsException(String.format("buffer length=%d, index=%d, size=%d", Integer.valueOf(bArr.length), Integer.valueOf(i), Integer.valueOf(i2)));
+        }
+
+        @Override // com.fyber.inneractive.sdk.protobuf.q1.b
+        public final int a(CharSequence charSequence, byte[] bArr, int i, int i2) {
+            long j;
+            String str;
+            String str2;
+            int i3;
+            long j2;
+            long j3;
+            char charAt;
+            long j4 = i;
+            long j5 = i2 + j4;
+            int length = charSequence.length();
+            String str3 = " at index ";
+            String str4 = "Failed writing ";
+            if (length > i2 || bArr.length - i2 < i) {
+                throw new ArrayIndexOutOfBoundsException("Failed writing " + charSequence.charAt(length - 1) + " at index " + (i + i2));
+            }
+            int i4 = 0;
+            while (true) {
+                j = 1;
+                if (i4 >= length || (charAt = charSequence.charAt(i4)) >= 128) {
+                    break;
+                }
+                p1.a(bArr, j4, (byte) charAt);
+                i4++;
+                j4 = 1 + j4;
+            }
+            if (i4 == length) {
+                return (int) j4;
+            }
+            while (i4 < length) {
+                char charAt2 = charSequence.charAt(i4);
+                if (charAt2 >= 128 || j4 >= j5) {
+                    if (charAt2 >= 2048 || j4 > j5 - 2) {
+                        str = str3;
+                        str2 = str4;
+                        if ((charAt2 >= 55296 && 57343 >= charAt2) || j4 > j5 - 3) {
+                            if (j4 <= j5 - 4) {
+                                int i5 = i4 + 1;
+                                if (i5 != length) {
+                                    char charAt3 = charSequence.charAt(i5);
+                                    if (Character.isSurrogatePair(charAt2, charAt3)) {
+                                        int codePoint = Character.toCodePoint(charAt2, charAt3);
+                                        j2 = 1;
+                                        p1.a(bArr, j4, (byte) ((codePoint >>> 18) | PsExtractor.VIDEO_STREAM_MASK));
+                                        j3 = j5;
+                                        p1.a(bArr, j4 + 1, (byte) (((codePoint >>> 12) & 63) | 128));
+                                        long j6 = j4 + 3;
+                                        p1.a(bArr, j4 + 2, (byte) (((codePoint >>> 6) & 63) | 128));
+                                        j4 += 4;
+                                        p1.a(bArr, j6, (byte) ((codePoint & 63) | 128));
+                                        i4 = i5;
+                                    } else {
+                                        i4 = i5;
+                                    }
+                                }
+                                throw new d(i4 - 1, length);
+                            }
+                            if (55296 <= charAt2 && charAt2 <= 57343 && ((i3 = i4 + 1) == length || !Character.isSurrogatePair(charAt2, charSequence.charAt(i3)))) {
+                                throw new d(i4, length);
+                            }
+                            throw new ArrayIndexOutOfBoundsException(str2 + charAt2 + str + j4);
+                        }
+                        p1.a(bArr, j4, (byte) ((charAt2 >>> '\f') | 480));
+                        long j7 = j4 + 2;
+                        p1.a(bArr, j4 + 1, (byte) (((charAt2 >>> 6) & 63) | 128));
+                        j4 += 3;
+                        p1.a(bArr, j7, (byte) ((charAt2 & '?') | 128));
+                    } else {
+                        str = str3;
+                        str2 = str4;
+                        long j8 = j4 + j;
+                        p1.a(bArr, j4, (byte) ((charAt2 >>> 6) | 960));
+                        j4 += 2;
+                        p1.a(bArr, j8, (byte) ((charAt2 & '?') | 128));
+                    }
+                    j3 = j5;
+                    j2 = 1;
+                } else {
+                    p1.a(bArr, j4, (byte) charAt2);
+                    j3 = j5;
+                    str2 = str4;
+                    j2 = j;
+                    j4 += j;
+                    str = str3;
+                }
+                i4++;
+                str3 = str;
+                str4 = str2;
+                j = j2;
+                j5 = j3;
+            }
+            return (int) j4;
+        }
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/r.java

@@ -0,0 +1,30 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+import com.fyber.inneractive.sdk.protobuf.u;
+import com.fyber.inneractive.sdk.protobuf.u.b;
+import java.io.IOException;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public abstract class r<T extends u.b<T>> {
+    public abstract int a(Map.Entry<?, ?> entry);
+
+    public abstract GeneratedMessageLite.e a(q qVar, o0 o0Var, int i);
+
+    public abstract u<T> a(Object obj);
+
+    public abstract <UT, UB> UB a(c1 c1Var, Object obj, q qVar, u<T> uVar, UB ub, k1<UT, UB> k1Var) throws IOException;
+
+    public abstract void a(c1 c1Var, Object obj, q qVar, u<T> uVar) throws IOException;
+
+    public abstract void a(i iVar, Object obj, q qVar, u<T> uVar) throws IOException;
+
+    public abstract void a(m mVar, Map.Entry entry) throws IOException;
+
+    public abstract boolean a(o0 o0Var);
+
+    public abstract u<T> b(Object obj);
+
+    public abstract void c(Object obj);
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/r1.java

@@ -0,0 +1,385 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.io.IOException;
+import java.io.Serializable;
+
+/* loaded from: classes2.dex */
+public final class r1 {
+    public static final int a = a(1, 3);
+    public static final int b = a(1, 4);
+    public static final int c = a(2, 0);
+    public static final int d = a(3, 2);
+
+    public static /* synthetic */ class a {
+        public static final /* synthetic */ int[] a;
+
+        static {
+            int[] iArr = new int[b.values().length];
+            a = iArr;
+            try {
+                iArr[b.DOUBLE.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                a[b.FLOAT.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                a[b.INT64.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                a[b.UINT64.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                a[b.INT32.ordinal()] = 5;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                a[b.FIXED64.ordinal()] = 6;
+            } catch (NoSuchFieldError unused6) {
+            }
+            try {
+                a[b.FIXED32.ordinal()] = 7;
+            } catch (NoSuchFieldError unused7) {
+            }
+            try {
+                a[b.BOOL.ordinal()] = 8;
+            } catch (NoSuchFieldError unused8) {
+            }
+            try {
+                a[b.BYTES.ordinal()] = 9;
+            } catch (NoSuchFieldError unused9) {
+            }
+            try {
+                a[b.UINT32.ordinal()] = 10;
+            } catch (NoSuchFieldError unused10) {
+            }
+            try {
+                a[b.SFIXED32.ordinal()] = 11;
+            } catch (NoSuchFieldError unused11) {
+            }
+            try {
+                a[b.SFIXED64.ordinal()] = 12;
+            } catch (NoSuchFieldError unused12) {
+            }
+            try {
+                a[b.SINT32.ordinal()] = 13;
+            } catch (NoSuchFieldError unused13) {
+            }
+            try {
+                a[b.SINT64.ordinal()] = 14;
+            } catch (NoSuchFieldError unused14) {
+            }
+            try {
+                a[b.STRING.ordinal()] = 15;
+            } catch (NoSuchFieldError unused15) {
+            }
+            try {
+                a[b.GROUP.ordinal()] = 16;
+            } catch (NoSuchFieldError unused16) {
+            }
+            try {
+                a[b.MESSAGE.ordinal()] = 17;
+            } catch (NoSuchFieldError unused17) {
+            }
+            try {
+                a[b.ENUM.ordinal()] = 18;
+            } catch (NoSuchFieldError unused18) {
+            }
+        }
+    }
+
+    /* JADX WARN: Enum visitor error
+    jadx.core.utils.exceptions.JadxRuntimeException: Init of enum field 'INT64' uses external variables
+    	at jadx.core.dex.visitors.EnumVisitor.createEnumFieldByConstructor(EnumVisitor.java:451)
+    	at jadx.core.dex.visitors.EnumVisitor.processEnumFieldByRegister(EnumVisitor.java:395)
+    	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromFilledArray(EnumVisitor.java:324)
+    	at jadx.core.dex.visitors.EnumVisitor.extractEnumFieldsFromInsn(EnumVisitor.java:262)
+    	at jadx.core.dex.visitors.EnumVisitor.convertToEnum(EnumVisitor.java:151)
+    	at jadx.core.dex.visitors.EnumVisitor.visit(EnumVisitor.java:100)
+     */
+    /* JADX WARN: Failed to restore enum class, 'enum' modifier and super class removed */
+    public static class b {
+        private static final /* synthetic */ b[] $VALUES;
+        public static final b BOOL;
+        public static final b BYTES;
+        public static final b DOUBLE;
+        public static final b ENUM;
+        public static final b FIXED32;
+        public static final b FIXED64;
+        public static final b FLOAT;
+        public static final b GROUP;
+        public static final b INT32;
+        public static final b INT64;
+        public static final b MESSAGE;
+        public static final b SFIXED32;
+        public static final b SFIXED64;
+        public static final b SINT32;
+        public static final b SINT64;
+        public static final b STRING;
+        public static final b UINT32;
+        public static final b UINT64;
+        private final c javaType;
+        private final int wireType;
+
+        public enum a extends b {
+            public a(c cVar) {
+                super("STRING", 8, cVar, 2, 0);
+            }
+        }
+
+        /* renamed from: com.fyber.inneractive.sdk.protobuf.r1$b$b, reason: collision with other inner class name */
+        public enum C0106b extends b {
+            public C0106b(c cVar) {
+                super("GROUP", 9, cVar, 3, 0);
+            }
+
+            @Override // com.fyber.inneractive.sdk.protobuf.r1.b
+            public final boolean g() {
+                return false;
+            }
+        }
+
+        public enum c extends b {
+            public c(c cVar) {
+                super("MESSAGE", 10, cVar, 2, 0);
+            }
+
+            @Override // com.fyber.inneractive.sdk.protobuf.r1.b
+            public final boolean g() {
+                return false;
+            }
+        }
+
+        public enum d extends b {
+            public d(c cVar) {
+                super("BYTES", 11, cVar, 2, 0);
+            }
+
+            @Override // com.fyber.inneractive.sdk.protobuf.r1.b
+            public final boolean g() {
+                return false;
+            }
+        }
+
+        static {
+            b bVar = new b("DOUBLE", 0, c.DOUBLE, 1);
+            DOUBLE = bVar;
+            b bVar2 = new b("FLOAT", 1, c.FLOAT, 5);
+            FLOAT = bVar2;
+            c cVar = c.LONG;
+            b bVar3 = new b("INT64", 2, cVar, 0);
+            INT64 = bVar3;
+            b bVar4 = new b("UINT64", 3, cVar, 0);
+            UINT64 = bVar4;
+            c cVar2 = c.INT;
+            b bVar5 = new b("INT32", 4, cVar2, 0);
+            INT32 = bVar5;
+            b bVar6 = new b("FIXED64", 5, cVar, 1);
+            FIXED64 = bVar6;
+            b bVar7 = new b("FIXED32", 6, cVar2, 5);
+            FIXED32 = bVar7;
+            b bVar8 = new b("BOOL", 7, c.BOOLEAN, 0);
+            BOOL = bVar8;
+            a aVar = new a(c.STRING);
+            STRING = aVar;
+            c cVar3 = c.MESSAGE;
+            C0106b c0106b = new C0106b(cVar3);
+            GROUP = c0106b;
+            c cVar4 = new c(cVar3);
+            MESSAGE = cVar4;
+            d dVar = new d(c.BYTE_STRING);
+            BYTES = dVar;
+            b bVar9 = new b("UINT32", 12, cVar2, 0);
+            UINT32 = bVar9;
+            b bVar10 = new b("ENUM", 13, c.ENUM, 0);
+            ENUM = bVar10;
+            b bVar11 = new b("SFIXED32", 14, cVar2, 5);
+            SFIXED32 = bVar11;
+            b bVar12 = new b("SFIXED64", 15, cVar, 1);
+            SFIXED64 = bVar12;
+            b bVar13 = new b("SINT32", 16, cVar2, 0);
+            SINT32 = bVar13;
+            b bVar14 = new b("SINT64", 17, cVar, 0);
+            SINT64 = bVar14;
+            $VALUES = new b[]{bVar, bVar2, bVar3, bVar4, bVar5, bVar6, bVar7, bVar8, aVar, c0106b, cVar4, dVar, bVar9, bVar10, bVar11, bVar12, bVar13, bVar14};
+        }
+
+        public /* synthetic */ b(String str, int i, c cVar, int i2, int i3) {
+            this(str, i, cVar, i2);
+        }
+
+        public static b valueOf(String str) {
+            return (b) Enum.valueOf(b.class, str);
+        }
+
+        public static b[] values() {
+            return (b[]) $VALUES.clone();
+        }
+
+        public final c e() {
+            return this.javaType;
+        }
+
+        public final int f() {
+            return this.wireType;
+        }
+
+        public boolean g() {
+            return !(this instanceof a);
+        }
+
+        public b(String str, int i, c cVar, int i2) {
+            this.javaType = cVar;
+            this.wireType = i2;
+        }
+    }
+
+    public enum c {
+        INT(0),
+        LONG(0L),
+        FLOAT(Float.valueOf(0.0f)),
+        DOUBLE(Double.valueOf(0.0d)),
+        BOOLEAN(Boolean.FALSE),
+        STRING(""),
+        BYTE_STRING(i.b),
+        ENUM(null),
+        MESSAGE(null);
+
+        private final Object defaultDefault;
+
+        c(Serializable serializable) {
+            this.defaultDefault = serializable;
+        }
+    }
+
+    /* 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 d {
+        private static final /* synthetic */ d[] $VALUES;
+        public static final d LAZY;
+        public static final d LOOSE;
+        public static final d STRICT;
+
+        public enum a extends d {
+            /* JADX WARN: Illegal instructions before constructor call */
+            /*
+                Code decompiled incorrectly, please refer to instructions dump.
+                To view partially-correct add '--show-bad-code' argument
+            */
+            public a() {
+                /*
+                    r2 = this;
+                    java.lang.String r0 = "LOOSE"
+                    r1 = 0
+                    r2.<init>(r0, r1, r1)
+                    return
+                */
+                throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.r1.d.a.<init>():void");
+            }
+
+            @Override // com.fyber.inneractive.sdk.protobuf.r1.d
+            public final Object a(j jVar) throws IOException {
+                return jVar.r();
+            }
+        }
+
+        public enum b extends d {
+            public b() {
+                super("STRICT", 1, 0);
+            }
+
+            @Override // com.fyber.inneractive.sdk.protobuf.r1.d
+            public final Object a(j jVar) throws IOException {
+                return jVar.s();
+            }
+        }
+
+        public enum c extends d {
+            public c() {
+                super("LAZY", 2, 0);
+            }
+
+            @Override // com.fyber.inneractive.sdk.protobuf.r1.d
+            public final Object a(j jVar) throws IOException {
+                return jVar.e();
+            }
+        }
+
+        static {
+            a aVar = new a();
+            LOOSE = aVar;
+            b bVar = new b();
+            STRICT = bVar;
+            c cVar = new c();
+            LAZY = cVar;
+            $VALUES = new d[]{aVar, bVar, cVar};
+        }
+
+        public d(String str, int i) {
+        }
+
+        public static d valueOf(String str) {
+            return (d) Enum.valueOf(d.class, str);
+        }
+
+        public static d[] values() {
+            return (d[]) $VALUES.clone();
+        }
+
+        public abstract Object a(j jVar) throws IOException;
+
+        public /* synthetic */ d(String str, int i, int i2) {
+            this(str, i);
+        }
+    }
+
+    public static int a(int i, int i2) {
+        return (i << 3) | i2;
+    }
+
+    public static Object a(j jVar, b bVar, d dVar) throws IOException {
+        switch (a.a[bVar.ordinal()]) {
+            case 1:
+                return Double.valueOf(jVar.f());
+            case 2:
+                return Float.valueOf(jVar.j());
+            case 3:
+                return Long.valueOf(jVar.l());
+            case 4:
+                return Long.valueOf(jVar.v());
+            case 5:
+                return Integer.valueOf(jVar.k());
+            case 6:
+                return Long.valueOf(jVar.i());
+            case 7:
+                return Integer.valueOf(jVar.h());
+            case 8:
+                return Boolean.valueOf(jVar.d());
+            case 9:
+                return jVar.e();
+            case 10:
+                return Integer.valueOf(jVar.u());
+            case 11:
+                return Integer.valueOf(jVar.n());
+            case 12:
+                return Long.valueOf(jVar.o());
+            case 13:
+                return Integer.valueOf(jVar.p());
+            case 14:
+                return Long.valueOf(jVar.q());
+            case 15:
+                return dVar.a(jVar);
+            case 16:
+                throw new IllegalArgumentException("readPrimitiveField() cannot handle nested groups.");
+            case 17:
+                throw new IllegalArgumentException("readPrimitiveField() cannot handle embedded messages.");
+            case 18:
+                throw new IllegalArgumentException("readPrimitiveField() cannot handle enums.");
+            default:
+                throw new RuntimeException("There is no way to get here, but the compiler thinks otherwise.");
+        }
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/s.java

@@ -0,0 +1,437 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+import com.fyber.inneractive.sdk.protobuf.f;
+import com.fyber.inneractive.sdk.protobuf.q;
+import com.fyber.inneractive.sdk.protobuf.r1;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public final class s extends r<GeneratedMessageLite.d> {
+
+    public static /* synthetic */ class a {
+        public static final /* synthetic */ int[] a;
+
+        static {
+            int[] iArr = new int[r1.b.values().length];
+            a = iArr;
+            try {
+                iArr[r1.b.DOUBLE.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                a[r1.b.FLOAT.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                a[r1.b.INT64.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                a[r1.b.UINT64.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                a[r1.b.INT32.ordinal()] = 5;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                a[r1.b.FIXED64.ordinal()] = 6;
+            } catch (NoSuchFieldError unused6) {
+            }
+            try {
+                a[r1.b.FIXED32.ordinal()] = 7;
+            } catch (NoSuchFieldError unused7) {
+            }
+            try {
+                a[r1.b.BOOL.ordinal()] = 8;
+            } catch (NoSuchFieldError unused8) {
+            }
+            try {
+                a[r1.b.UINT32.ordinal()] = 9;
+            } catch (NoSuchFieldError unused9) {
+            }
+            try {
+                a[r1.b.SFIXED32.ordinal()] = 10;
+            } catch (NoSuchFieldError unused10) {
+            }
+            try {
+                a[r1.b.SFIXED64.ordinal()] = 11;
+            } catch (NoSuchFieldError unused11) {
+            }
+            try {
+                a[r1.b.SINT32.ordinal()] = 12;
+            } catch (NoSuchFieldError unused12) {
+            }
+            try {
+                a[r1.b.SINT64.ordinal()] = 13;
+            } catch (NoSuchFieldError unused13) {
+            }
+            try {
+                a[r1.b.ENUM.ordinal()] = 14;
+            } catch (NoSuchFieldError unused14) {
+            }
+            try {
+                a[r1.b.BYTES.ordinal()] = 15;
+            } catch (NoSuchFieldError unused15) {
+            }
+            try {
+                a[r1.b.STRING.ordinal()] = 16;
+            } catch (NoSuchFieldError unused16) {
+            }
+            try {
+                a[r1.b.GROUP.ordinal()] = 17;
+            } catch (NoSuchFieldError unused17) {
+            }
+            try {
+                a[r1.b.MESSAGE.ordinal()] = 18;
+            } catch (NoSuchFieldError unused18) {
+            }
+        }
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.r
+    public final boolean a(o0 o0Var) {
+        return o0Var instanceof GeneratedMessageLite.ExtendableMessage;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.r
+    public final u<GeneratedMessageLite.d> b(Object obj) {
+        return ((GeneratedMessageLite.ExtendableMessage) obj).ensureExtensionsAreMutable();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.r
+    public final void c(Object obj) {
+        ((GeneratedMessageLite.ExtendableMessage) obj).extensions.f();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.r
+    public final u<GeneratedMessageLite.d> a(Object obj) {
+        return ((GeneratedMessageLite.ExtendableMessage) obj).extensions;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.r
+    public final <UT, UB> UB a(c1 c1Var, Object obj, q qVar, u<GeneratedMessageLite.d> uVar, UB ub, k1<UT, UB> k1Var) throws IOException {
+        Object valueOf;
+        Object a2;
+        ArrayList arrayList;
+        GeneratedMessageLite.e eVar = (GeneratedMessageLite.e) obj;
+        GeneratedMessageLite.d dVar = eVar.d;
+        int i = dVar.b;
+        if (dVar.d && dVar.e) {
+            switch (a.a[dVar.c.ordinal()]) {
+                case 1:
+                    arrayList = new ArrayList();
+                    c1Var.l(arrayList);
+                    break;
+                case 2:
+                    arrayList = new ArrayList();
+                    c1Var.j(arrayList);
+                    break;
+                case 3:
+                    arrayList = new ArrayList();
+                    c1Var.m(arrayList);
+                    break;
+                case 4:
+                    arrayList = new ArrayList();
+                    c1Var.h(arrayList);
+                    break;
+                case 5:
+                    arrayList = new ArrayList();
+                    c1Var.p(arrayList);
+                    break;
+                case 6:
+                    arrayList = new ArrayList();
+                    c1Var.o(arrayList);
+                    break;
+                case 7:
+                    arrayList = new ArrayList();
+                    c1Var.b(arrayList);
+                    break;
+                case 8:
+                    arrayList = new ArrayList();
+                    c1Var.f(arrayList);
+                    break;
+                case 9:
+                    arrayList = new ArrayList();
+                    c1Var.e(arrayList);
+                    break;
+                case 10:
+                    arrayList = new ArrayList();
+                    c1Var.c(arrayList);
+                    break;
+                case 11:
+                    arrayList = new ArrayList();
+                    c1Var.n(arrayList);
+                    break;
+                case 12:
+                    arrayList = new ArrayList();
+                    c1Var.a(arrayList);
+                    break;
+                case 13:
+                    arrayList = new ArrayList();
+                    c1Var.d(arrayList);
+                    break;
+                case 14:
+                    arrayList = new ArrayList();
+                    c1Var.q(arrayList);
+                    ub = (UB) e1.a(i, arrayList, eVar.d.a, ub, k1Var);
+                    break;
+                default:
+                    throw new IllegalStateException("Type cannot be packed: " + eVar.d.c);
+            }
+            uVar.b(eVar.d, arrayList);
+        } else {
+            r1.b bVar = dVar.c;
+            if (bVar == r1.b.ENUM) {
+                int o = c1Var.o();
+                if (eVar.d.a.a(o) == null) {
+                    Class<?> cls = e1.a;
+                    if (ub == null) {
+                        ub = (UB) k1Var.a();
+                    }
+                    k1Var.b(i, o, ub);
+                    return ub;
+                }
+                valueOf = Integer.valueOf(o);
+            } else {
+                switch (a.a[bVar.ordinal()]) {
+                    case 1:
+                        valueOf = Double.valueOf(c1Var.readDouble());
+                        break;
+                    case 2:
+                        valueOf = Float.valueOf(c1Var.readFloat());
+                        break;
+                    case 3:
+                        valueOf = Long.valueOf(c1Var.r());
+                        break;
+                    case 4:
+                        valueOf = Long.valueOf(c1Var.c());
+                        break;
+                    case 5:
+                        valueOf = Integer.valueOf(c1Var.o());
+                        break;
+                    case 6:
+                        valueOf = Long.valueOf(c1Var.d());
+                        break;
+                    case 7:
+                        valueOf = Integer.valueOf(c1Var.h());
+                        break;
+                    case 8:
+                        valueOf = Boolean.valueOf(c1Var.i());
+                        break;
+                    case 9:
+                        valueOf = Integer.valueOf(c1Var.m());
+                        break;
+                    case 10:
+                        valueOf = Integer.valueOf(c1Var.q());
+                        break;
+                    case 11:
+                        valueOf = Long.valueOf(c1Var.k());
+                        break;
+                    case 12:
+                        valueOf = Integer.valueOf(c1Var.e());
+                        break;
+                    case 13:
+                        valueOf = Long.valueOf(c1Var.f());
+                        break;
+                    case 14:
+                        throw new IllegalStateException("Shouldn't reach here.");
+                    case 15:
+                        valueOf = c1Var.l();
+                        break;
+                    case 16:
+                        valueOf = c1Var.g();
+                        break;
+                    case 17:
+                        valueOf = c1Var.a(eVar.c.getClass(), qVar);
+                        break;
+                    case 18:
+                        valueOf = c1Var.b(eVar.c.getClass(), qVar);
+                        break;
+                    default:
+                        valueOf = null;
+                        break;
+                }
+            }
+            GeneratedMessageLite.d dVar2 = eVar.d;
+            if (dVar2.d) {
+                uVar.a(dVar2, valueOf);
+            } else {
+                int i2 = a.a[dVar2.c.ordinal()];
+                if ((i2 == 17 || i2 == 18) && (a2 = uVar.a((u<GeneratedMessageLite.d>) eVar.d)) != null) {
+                    valueOf = y.a(a2, valueOf);
+                }
+                uVar.b(eVar.d, valueOf);
+            }
+        }
+        return ub;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.r
+    public final GeneratedMessageLite.e a(q qVar, o0 o0Var, int i) {
+        return qVar.a.get(new q.a(i, o0Var));
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.r
+    public final int a(Map.Entry<?, ?> entry) {
+        return ((GeneratedMessageLite.d) entry.getKey()).b;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.r
+    public final void a(m mVar, Map.Entry entry) throws IOException {
+        GeneratedMessageLite.d dVar = (GeneratedMessageLite.d) entry.getKey();
+        if (dVar.d) {
+            switch (a.a[dVar.c.ordinal()]) {
+                case 1:
+                    e1.b(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 2:
+                    e1.f(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 3:
+                    e1.h(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 4:
+                    e1.n(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 5:
+                    e1.g(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 6:
+                    e1.e(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 7:
+                    e1.d(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 8:
+                    e1.a(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 9:
+                    e1.m(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 10:
+                    e1.i(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 11:
+                    e1.j(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 12:
+                    e1.k(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 13:
+                    e1.l(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 14:
+                    e1.g(dVar.b, (List) entry.getValue(), mVar, dVar.e);
+                    break;
+                case 15:
+                    e1.a(dVar.b, (List) entry.getValue(), mVar);
+                    break;
+                case 16:
+                    e1.b(dVar.b, (List) entry.getValue(), mVar);
+                    break;
+                case 17:
+                    List list = (List) entry.getValue();
+                    if (list != null && !list.isEmpty()) {
+                        e1.a(dVar.b, (List) entry.getValue(), mVar, z0.c.a(list.get(0).getClass()));
+                        break;
+                    }
+                    break;
+                case 18:
+                    List list2 = (List) entry.getValue();
+                    if (list2 != null && !list2.isEmpty()) {
+                        e1.b(dVar.b, (List) entry.getValue(), mVar, z0.c.a(list2.get(0).getClass()));
+                        break;
+                    }
+                    break;
+            }
+        }
+        switch (a.a[dVar.c.ordinal()]) {
+            case 1:
+                mVar.a(dVar.b, ((Double) entry.getValue()).doubleValue());
+                break;
+            case 2:
+                mVar.a(((Float) entry.getValue()).floatValue(), dVar.b);
+                break;
+            case 3:
+                mVar.a.b(dVar.b, ((Long) entry.getValue()).longValue());
+                break;
+            case 4:
+                mVar.a.b(dVar.b, ((Long) entry.getValue()).longValue());
+                break;
+            case 5:
+                mVar.a.c(dVar.b, ((Integer) entry.getValue()).intValue());
+                break;
+            case 6:
+                mVar.a.a(dVar.b, ((Long) entry.getValue()).longValue());
+                break;
+            case 7:
+                mVar.a.b(dVar.b, ((Integer) entry.getValue()).intValue());
+                break;
+            case 8:
+                mVar.a.a(dVar.b, ((Boolean) entry.getValue()).booleanValue());
+                break;
+            case 9:
+                mVar.a.e(dVar.b, ((Integer) entry.getValue()).intValue());
+                break;
+            case 10:
+                mVar.a.b(dVar.b, ((Integer) entry.getValue()).intValue());
+                break;
+            case 11:
+                mVar.a.a(dVar.b, ((Long) entry.getValue()).longValue());
+                break;
+            case 12:
+                mVar.a(dVar.b, ((Integer) entry.getValue()).intValue());
+                break;
+            case 13:
+                mVar.a(dVar.b, ((Long) entry.getValue()).longValue());
+                break;
+            case 14:
+                mVar.a.c(dVar.b, ((Integer) entry.getValue()).intValue());
+                break;
+            case 15:
+                mVar.a.b(dVar.b, (i) entry.getValue());
+                break;
+            case 16:
+                int i = dVar.b;
+                mVar.a.a((String) entry.getValue(), i);
+                break;
+            case 17:
+                mVar.a(dVar.b, z0.c.a(entry.getValue().getClass()), entry.getValue());
+                break;
+            case 18:
+                mVar.b(dVar.b, z0.c.a(entry.getValue().getClass()), entry.getValue());
+                break;
+        }
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.r
+    public final void a(c1 c1Var, Object obj, q qVar, u<GeneratedMessageLite.d> uVar) throws IOException {
+        GeneratedMessageLite.e eVar = (GeneratedMessageLite.e) obj;
+        uVar.b(eVar.d, c1Var.b(eVar.c.getClass(), qVar));
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.r
+    public final void a(i iVar, Object obj, q qVar, u<GeneratedMessageLite.d> uVar) throws IOException {
+        GeneratedMessageLite.e eVar = (GeneratedMessageLite.e) obj;
+        GeneratedMessageLite b = ((GeneratedMessageLite.b) eVar.c.newBuilderForType()).b();
+        ByteBuffer wrap = ByteBuffer.wrap(iVar.h());
+        if (wrap.hasArray()) {
+            f.a aVar = new f.a(wrap);
+            z0 z0Var = z0.c;
+            z0Var.getClass();
+            z0Var.a(b.getClass()).a(b, aVar, qVar);
+            uVar.b(eVar.d, b);
+            if (aVar.j() != Integer.MAX_VALUE) {
+                throw z.a();
+            }
+            return;
+        }
+        throw new IllegalArgumentException("Direct buffers not yet supported");
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/s0.java

@@ -0,0 +1,319 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+import com.fyber.inneractive.sdk.protobuf.a0;
+import com.fyber.inneractive.sdk.protobuf.r1;
+import com.fyber.inneractive.sdk.protobuf.u;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public final class s0<T> implements d1<T> {
+    public final o0 a;
+    public final k1<?, ?> b;
+    public final boolean c;
+    public final r<?> d;
+
+    public s0(k1<?, ?> k1Var, r<?> rVar, o0 o0Var) {
+        this.b = k1Var;
+        this.c = rVar.a(o0Var);
+        this.d = rVar;
+        this.a = o0Var;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d1
+    public final T a() {
+        return (T) ((GeneratedMessageLite.b) this.a.newBuilderForType()).b();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d1
+    public final boolean b(T t, T t2) {
+        if (!this.b.b(t).equals(this.b.b(t2))) {
+            return false;
+        }
+        if (this.c) {
+            return this.d.a(t).equals(this.d.a(t2));
+        }
+        return true;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d1
+    public final int d(T t) {
+        int hashCode = this.b.b(t).hashCode();
+        return this.c ? (hashCode * 53) + this.d.a(t).a.hashCode() : hashCode;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d1
+    public final int c(T t) {
+        k1<?, ?> k1Var = this.b;
+        int d = k1Var.d(k1Var.b(t));
+        if (!this.c) {
+            return d;
+        }
+        u<?> a = this.d.a(t);
+        int i = 0;
+        for (int i2 = 0; i2 < a.a.b.size(); i2++) {
+            i += u.a(a.a.a(i2));
+        }
+        Iterator<Map.Entry<?, Object>> it = a.a.b().iterator();
+        while (it.hasNext()) {
+            i += u.a(it.next());
+        }
+        return d + i;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d1
+    public final void a(T t, T t2) {
+        k1<?, ?> k1Var = this.b;
+        Class<?> cls = e1.a;
+        k1Var.c(t, k1Var.a(k1Var.b(t), k1Var.b(t2)));
+        if (this.c) {
+            r<?> rVar = this.d;
+            u<?> a = rVar.a(t2);
+            if (a.a.isEmpty()) {
+                return;
+            }
+            u<?> b = rVar.b(t);
+            b.getClass();
+            for (int i = 0; i < a.a.b.size(); i++) {
+                b.c(a.a.a(i));
+            }
+            Iterator<Map.Entry<?, Object>> it = a.a.b().iterator();
+            while (it.hasNext()) {
+                b.c(it.next());
+            }
+        }
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d1
+    public final boolean b(T t) {
+        return this.d.a(t).d();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // com.fyber.inneractive.sdk.protobuf.d1
+    public final void a(Object obj, m mVar) throws IOException {
+        Iterator<Map.Entry<?, Object>> e = this.d.a(obj).e();
+        while (e.hasNext()) {
+            Map.Entry<?, Object> next = e.next();
+            u.b bVar = (u.b) next.getKey();
+            if (bVar.d() == r1.c.MESSAGE && !bVar.b() && !bVar.isPacked()) {
+                if (next instanceof a0.a) {
+                    int a = bVar.a();
+                    i a2 = ((a0.a) next).a.getValue().a();
+                    mVar.getClass();
+                    if (a2 instanceof i) {
+                        mVar.a.c(a, a2);
+                    } else {
+                        mVar.a.a(a, (o0) a2);
+                    }
+                } else {
+                    int a3 = bVar.a();
+                    Object value = next.getValue();
+                    mVar.getClass();
+                    if (value instanceof i) {
+                        mVar.a.c(a3, (i) value);
+                    } else {
+                        mVar.a.a(a3, (o0) value);
+                    }
+                }
+            } else {
+                throw new IllegalStateException("Found invalid MessageSet item.");
+            }
+        }
+        k1<?, ?> k1Var = this.b;
+        k1Var.a((Object) k1Var.b(obj), mVar);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Removed duplicated region for block: B:22:0x00b0  */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x00b5 A[EDGE_INSN: B:24:0x00b5->B:25:0x00b5 BREAK  A[LOOP:1: B:10:0x0061->B:18:0x0061], SYNTHETIC] */
+    @Override // com.fyber.inneractive.sdk.protobuf.d1
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void a(T r11, byte[] r12, int r13, int r14, com.fyber.inneractive.sdk.protobuf.e.b r15) throws java.io.IOException {
+        /*
+            r10 = this;
+            r0 = r11
+            com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite r0 = (com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite) r0
+            com.fyber.inneractive.sdk.protobuf.l1 r1 = r0.unknownFields
+            com.fyber.inneractive.sdk.protobuf.l1 r2 = com.fyber.inneractive.sdk.protobuf.l1.f
+            if (r1 != r2) goto L10
+            com.fyber.inneractive.sdk.protobuf.l1 r1 = new com.fyber.inneractive.sdk.protobuf.l1
+            r1.<init>()
+            r0.unknownFields = r1
+        L10:
+            com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite$ExtendableMessage r11 = (com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite.ExtendableMessage) r11
+            com.fyber.inneractive.sdk.protobuf.u r11 = r11.ensureExtensionsAreMutable()
+            r0 = 0
+            r2 = r0
+        L18:
+            if (r13 >= r14) goto Lc1
+            int r4 = com.fyber.inneractive.sdk.protobuf.e.c(r12, r13, r15)
+            int r13 = r15.a
+            int r3 = com.fyber.inneractive.sdk.protobuf.r1.a
+            r5 = 2
+            if (r13 == r3) goto L5f
+            r3 = r13 & 7
+            if (r3 != r5) goto L5a
+            com.fyber.inneractive.sdk.protobuf.r<?> r2 = r10.d
+            com.fyber.inneractive.sdk.protobuf.q r3 = r15.d
+            com.fyber.inneractive.sdk.protobuf.o0 r5 = r10.a
+            int r6 = r13 >>> 3
+            com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite$e r8 = r2.a(r3, r5, r6)
+            if (r8 == 0) goto L50
+            com.fyber.inneractive.sdk.protobuf.z0 r13 = com.fyber.inneractive.sdk.protobuf.z0.c
+            com.fyber.inneractive.sdk.protobuf.o0 r2 = r8.c
+            java.lang.Class r2 = r2.getClass()
+            com.fyber.inneractive.sdk.protobuf.d1 r13 = r13.a(r2)
+            int r13 = com.fyber.inneractive.sdk.protobuf.e.a(r13, r12, r4, r14, r15)
+            com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite$d r2 = r8.d
+            java.lang.Object r3 = r15.c
+            r11.b(r2, r3)
+        L4e:
+            r2 = r8
+            goto L18
+        L50:
+            r2 = r13
+            r3 = r12
+            r5 = r14
+            r6 = r1
+            r7 = r15
+            int r13 = com.fyber.inneractive.sdk.protobuf.e.a(r2, r3, r4, r5, r6, r7)
+            goto L4e
+        L5a:
+            int r13 = com.fyber.inneractive.sdk.protobuf.e.a(r13, r12, r4, r14, r15)
+            goto L18
+        L5f:
+            r13 = 0
+            r3 = r0
+        L61:
+            if (r4 >= r14) goto Lb5
+            int r4 = com.fyber.inneractive.sdk.protobuf.e.c(r12, r4, r15)
+            int r6 = r15.a
+            int r7 = r6 >>> 3
+            r8 = r6 & 7
+            if (r7 == r5) goto L98
+            r9 = 3
+            if (r7 == r9) goto L73
+            goto Lab
+        L73:
+            if (r2 == 0) goto L8d
+            com.fyber.inneractive.sdk.protobuf.z0 r6 = com.fyber.inneractive.sdk.protobuf.z0.c
+            com.fyber.inneractive.sdk.protobuf.o0 r7 = r2.c
+            java.lang.Class r7 = r7.getClass()
+            com.fyber.inneractive.sdk.protobuf.d1 r6 = r6.a(r7)
+            int r4 = com.fyber.inneractive.sdk.protobuf.e.a(r6, r12, r4, r14, r15)
+            com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite$d r6 = r2.d
+            java.lang.Object r7 = r15.c
+            r11.b(r6, r7)
+            goto L61
+        L8d:
+            if (r8 != r5) goto Lab
+            int r4 = com.fyber.inneractive.sdk.protobuf.e.a(r12, r4, r15)
+            java.lang.Object r3 = r15.c
+            com.fyber.inneractive.sdk.protobuf.i r3 = (com.fyber.inneractive.sdk.protobuf.i) r3
+            goto L61
+        L98:
+            if (r8 != 0) goto Lab
+            int r4 = com.fyber.inneractive.sdk.protobuf.e.c(r12, r4, r15)
+            int r13 = r15.a
+            com.fyber.inneractive.sdk.protobuf.r<?> r2 = r10.d
+            com.fyber.inneractive.sdk.protobuf.q r6 = r15.d
+            com.fyber.inneractive.sdk.protobuf.o0 r7 = r10.a
+            com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite$e r2 = r2.a(r6, r7, r13)
+            goto L61
+        Lab:
+            int r7 = com.fyber.inneractive.sdk.protobuf.r1.b
+            if (r6 != r7) goto Lb0
+            goto Lb5
+        Lb0:
+            int r4 = com.fyber.inneractive.sdk.protobuf.e.a(r6, r12, r4, r14, r15)
+            goto L61
+        Lb5:
+            if (r3 == 0) goto Lbe
+            int r13 = com.fyber.inneractive.sdk.protobuf.r1.a(r13, r5)
+            r1.a(r13, r3)
+        Lbe:
+            r13 = r4
+            goto L18
+        Lc1:
+            if (r13 != r14) goto Lc4
+            return
+        Lc4:
+            com.fyber.inneractive.sdk.protobuf.z r11 = com.fyber.inneractive.sdk.protobuf.z.g()
+            throw r11
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.s0.a(java.lang.Object, byte[], int, int, com.fyber.inneractive.sdk.protobuf.e$b):void");
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d1
+    public final void a(T t, c1 c1Var, q qVar) throws IOException {
+        k1 k1Var = this.b;
+        r rVar = this.d;
+        l1 a = k1Var.a(t);
+        u<ET> b = rVar.b(t);
+        do {
+            try {
+                if (c1Var.j() == Integer.MAX_VALUE) {
+                    break;
+                }
+            } finally {
+                k1Var.b((Object) t, (T) a);
+            }
+        } while (a(c1Var, qVar, rVar, b, k1Var, a));
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.d1
+    public final void a(T t) {
+        this.b.e(t);
+        this.d.c(t);
+    }
+
+    public final <UT, UB, ET extends u.b<ET>> boolean a(c1 c1Var, q qVar, r<ET> rVar, u<ET> uVar, k1<UT, UB> k1Var, UB ub) throws IOException {
+        int b = c1Var.b();
+        if (b != r1.a) {
+            if ((b & 7) == 2) {
+                GeneratedMessageLite.e a = rVar.a(qVar, this.a, b >>> 3);
+                if (a != null) {
+                    rVar.a(c1Var, a, qVar, uVar);
+                    return true;
+                }
+                return k1Var.a((k1<UT, UB>) ub, c1Var);
+            }
+            return c1Var.p();
+        }
+        GeneratedMessageLite.e eVar = null;
+        int i = 0;
+        i iVar = null;
+        while (c1Var.j() != Integer.MAX_VALUE) {
+            int b2 = c1Var.b();
+            if (b2 == r1.c) {
+                i = c1Var.m();
+                eVar = rVar.a(qVar, this.a, i);
+            } else if (b2 == r1.d) {
+                if (eVar != null) {
+                    rVar.a(c1Var, eVar, qVar, uVar);
+                } else {
+                    iVar = c1Var.l();
+                }
+            } else if (!c1Var.p()) {
+                break;
+            }
+        }
+        if (c1Var.b() != r1.b) {
+            throw z.a();
+        }
+        if (iVar != null) {
+            if (eVar != null) {
+                rVar.a(iVar, eVar, qVar, uVar);
+            } else {
+                k1Var.a((k1<UT, UB>) ub, i, iVar);
+            }
+        }
+        return true;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/s1.java

@@ -0,0 +1,7 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public enum s1 {
+    ASCENDING,
+    DESCENDING
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/t.java

@@ -0,0 +1,17 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class t {
+    public static final s a = new s();
+    public static final r<?> b;
+
+    static {
+        r<?> rVar;
+        try {
+            rVar = (r) Class.forName("com.google.protobuf.ExtensionSchemaFull").getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (Exception unused) {
+            rVar = null;
+        }
+        b = rVar;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/t0.java

@@ -0,0 +1,6 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public interface t0 {
+    Object a(o0 o0Var);
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/u.java

@@ -0,0 +1,605 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+import com.fyber.inneractive.sdk.protobuf.a0;
+import com.fyber.inneractive.sdk.protobuf.o0;
+import com.fyber.inneractive.sdk.protobuf.r1;
+import com.fyber.inneractive.sdk.protobuf.u.b;
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+/* loaded from: classes2.dex */
+public final class u<T extends b<T>> {
+    public static final u d;
+    public final g1<T, Object> a;
+    public boolean b;
+    public boolean c;
+
+    public static /* synthetic */ class a {
+        public static final /* synthetic */ int[] a;
+        public static final /* synthetic */ int[] b;
+
+        static {
+            int[] iArr = new int[r1.b.values().length];
+            b = iArr;
+            try {
+                iArr[r1.b.DOUBLE.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                b[r1.b.FLOAT.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                b[r1.b.INT64.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                b[r1.b.UINT64.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+            try {
+                b[r1.b.INT32.ordinal()] = 5;
+            } catch (NoSuchFieldError unused5) {
+            }
+            try {
+                b[r1.b.FIXED64.ordinal()] = 6;
+            } catch (NoSuchFieldError unused6) {
+            }
+            try {
+                b[r1.b.FIXED32.ordinal()] = 7;
+            } catch (NoSuchFieldError unused7) {
+            }
+            try {
+                b[r1.b.BOOL.ordinal()] = 8;
+            } catch (NoSuchFieldError unused8) {
+            }
+            try {
+                b[r1.b.GROUP.ordinal()] = 9;
+            } catch (NoSuchFieldError unused9) {
+            }
+            try {
+                b[r1.b.MESSAGE.ordinal()] = 10;
+            } catch (NoSuchFieldError unused10) {
+            }
+            try {
+                b[r1.b.STRING.ordinal()] = 11;
+            } catch (NoSuchFieldError unused11) {
+            }
+            try {
+                b[r1.b.BYTES.ordinal()] = 12;
+            } catch (NoSuchFieldError unused12) {
+            }
+            try {
+                b[r1.b.UINT32.ordinal()] = 13;
+            } catch (NoSuchFieldError unused13) {
+            }
+            try {
+                b[r1.b.SFIXED32.ordinal()] = 14;
+            } catch (NoSuchFieldError unused14) {
+            }
+            try {
+                b[r1.b.SFIXED64.ordinal()] = 15;
+            } catch (NoSuchFieldError unused15) {
+            }
+            try {
+                b[r1.b.SINT32.ordinal()] = 16;
+            } catch (NoSuchFieldError unused16) {
+            }
+            try {
+                b[r1.b.SINT64.ordinal()] = 17;
+            } catch (NoSuchFieldError unused17) {
+            }
+            try {
+                b[r1.b.ENUM.ordinal()] = 18;
+            } catch (NoSuchFieldError unused18) {
+            }
+            int[] iArr2 = new int[r1.c.values().length];
+            a = iArr2;
+            try {
+                iArr2[r1.c.INT.ordinal()] = 1;
+            } catch (NoSuchFieldError unused19) {
+            }
+            try {
+                a[r1.c.LONG.ordinal()] = 2;
+            } catch (NoSuchFieldError unused20) {
+            }
+            try {
+                a[r1.c.FLOAT.ordinal()] = 3;
+            } catch (NoSuchFieldError unused21) {
+            }
+            try {
+                a[r1.c.DOUBLE.ordinal()] = 4;
+            } catch (NoSuchFieldError unused22) {
+            }
+            try {
+                a[r1.c.BOOLEAN.ordinal()] = 5;
+            } catch (NoSuchFieldError unused23) {
+            }
+            try {
+                a[r1.c.STRING.ordinal()] = 6;
+            } catch (NoSuchFieldError unused24) {
+            }
+            try {
+                a[r1.c.BYTE_STRING.ordinal()] = 7;
+            } catch (NoSuchFieldError unused25) {
+            }
+            try {
+                a[r1.c.ENUM.ordinal()] = 8;
+            } catch (NoSuchFieldError unused26) {
+            }
+            try {
+                a[r1.c.MESSAGE.ordinal()] = 9;
+            } catch (NoSuchFieldError unused27) {
+            }
+        }
+    }
+
+    public interface b<T extends b<T>> extends Comparable<T> {
+        int a();
+
+        GeneratedMessageLite.b a(o0.a aVar, o0 o0Var);
+
+        boolean b();
+
+        r1.b c();
+
+        r1.c d();
+
+        boolean isPacked();
+    }
+
+    static {
+        u uVar = new u(new f1(0));
+        uVar.f();
+        d = uVar;
+    }
+
+    public u() {
+        this.a = g1.b(16);
+    }
+
+    public static <T extends b<T>> u<T> b() {
+        return d;
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    /* JADX WARN: Removed duplicated region for block: B:24:? A[RETURN, SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static void c(com.fyber.inneractive.sdk.protobuf.u.b r2, java.lang.Object r3) {
+        /*
+            com.fyber.inneractive.sdk.protobuf.r1$b r0 = r2.c()
+            java.nio.charset.Charset r1 = com.fyber.inneractive.sdk.protobuf.y.a
+            r3.getClass()
+            int[] r1 = com.fyber.inneractive.sdk.protobuf.u.a.a
+            com.fyber.inneractive.sdk.protobuf.r1$c r0 = r0.e()
+            int r0 = r0.ordinal()
+            r0 = r1[r0]
+            switch(r0) {
+                case 1: goto L43;
+                case 2: goto L40;
+                case 3: goto L3d;
+                case 4: goto L3a;
+                case 5: goto L37;
+                case 6: goto L34;
+                case 7: goto L2b;
+                case 8: goto L22;
+                case 9: goto L19;
+                default: goto L18;
+            }
+        L18:
+            goto L48
+        L19:
+            boolean r0 = r3 instanceof com.fyber.inneractive.sdk.protobuf.o0
+            if (r0 != 0) goto L47
+            boolean r0 = r3 instanceof com.fyber.inneractive.sdk.protobuf.a0
+            if (r0 == 0) goto L48
+            goto L47
+        L22:
+            boolean r0 = r3 instanceof java.lang.Integer
+            if (r0 != 0) goto L47
+            boolean r0 = r3 instanceof com.fyber.inneractive.sdk.protobuf.y.c
+            if (r0 == 0) goto L48
+            goto L47
+        L2b:
+            boolean r0 = r3 instanceof com.fyber.inneractive.sdk.protobuf.i
+            if (r0 != 0) goto L47
+            boolean r0 = r3 instanceof byte[]
+            if (r0 == 0) goto L48
+            goto L47
+        L34:
+            boolean r0 = r3 instanceof java.lang.String
+            goto L45
+        L37:
+            boolean r0 = r3 instanceof java.lang.Boolean
+            goto L45
+        L3a:
+            boolean r0 = r3 instanceof java.lang.Double
+            goto L45
+        L3d:
+            boolean r0 = r3 instanceof java.lang.Float
+            goto L45
+        L40:
+            boolean r0 = r3 instanceof java.lang.Long
+            goto L45
+        L43:
+            boolean r0 = r3 instanceof java.lang.Integer
+        L45:
+            if (r0 == 0) goto L48
+        L47:
+            return
+        L48:
+            java.lang.IllegalArgumentException r0 = new java.lang.IllegalArgumentException
+            int r1 = r2.a()
+            java.lang.Integer r1 = java.lang.Integer.valueOf(r1)
+            com.fyber.inneractive.sdk.protobuf.r1$b r2 = r2.c()
+            com.fyber.inneractive.sdk.protobuf.r1$c r2 = r2.e()
+            java.lang.Class r3 = r3.getClass()
+            java.lang.String r3 = r3.getName()
+            java.lang.Object[] r2 = new java.lang.Object[]{r1, r2, r3}
+            java.lang.String r3 = "Wrong object type used with protocol message reflection.\nField number: %d, field java type: %s, value type: %s\n"
+            java.lang.String r2 = java.lang.String.format(r3, r2)
+            r0.<init>(r2)
+            throw r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.fyber.inneractive.sdk.protobuf.u.c(com.fyber.inneractive.sdk.protobuf.u$b, java.lang.Object):void");
+    }
+
+    /* renamed from: a, reason: merged with bridge method [inline-methods] */
+    public final u<T> clone() {
+        u<T> uVar = new u<>();
+        for (int i = 0; i < this.a.b.size(); i++) {
+            Map.Entry<T, Object> a2 = this.a.a(i);
+            uVar.b(a2.getKey(), a2.getValue());
+        }
+        for (Map.Entry<T, Object> entry : this.a.b()) {
+            uVar.b(entry.getKey(), entry.getValue());
+        }
+        uVar.c = this.c;
+        return uVar;
+    }
+
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof u) {
+            return this.a.equals(((u) obj).a);
+        }
+        return false;
+    }
+
+    public final int hashCode() {
+        return this.a.hashCode();
+    }
+
+    public final void b(T t, Object obj) {
+        if (!t.b()) {
+            c(t, obj);
+        } else {
+            if (!(obj instanceof List)) {
+                throw new IllegalArgumentException("Wrong object type used with protocol message reflection.");
+            }
+            ArrayList arrayList = new ArrayList();
+            arrayList.addAll((List) obj);
+            Iterator it = arrayList.iterator();
+            while (it.hasNext()) {
+                c(t, it.next());
+            }
+            obj = arrayList;
+        }
+        if (obj instanceof a0) {
+            this.c = true;
+        }
+        this.a.put(t, obj);
+    }
+
+    public final boolean d() {
+        for (int i = 0; i < this.a.b.size(); i++) {
+            if (!b(this.a.a(i))) {
+                return false;
+            }
+        }
+        Iterator<Map.Entry<T, Object>> it = this.a.b().iterator();
+        while (it.hasNext()) {
+            if (!b(it.next())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public final Iterator<Map.Entry<T, Object>> e() {
+        return this.c ? new a0.b(this.a.entrySet().iterator()) : this.a.entrySet().iterator();
+    }
+
+    public u(f1 f1Var) {
+        this.a = f1Var;
+        f();
+    }
+
+    public final void f() {
+        if (this.b) {
+            return;
+        }
+        this.a.c();
+        this.b = true;
+    }
+
+    public final Object a(T t) {
+        Object obj = this.a.get(t);
+        return obj instanceof a0 ? ((a0) obj).a(null) : obj;
+    }
+
+    public static int a(Map.Entry entry) {
+        int a2;
+        int d2;
+        int serializedSize;
+        int e;
+        b bVar = (b) entry.getKey();
+        Object value = entry.getValue();
+        if (bVar.d() == r1.c.MESSAGE && !bVar.b() && !bVar.isPacked()) {
+            if (value instanceof a0) {
+                a0 a0Var = (a0) value;
+                a2 = l.a(2, ((b) entry.getKey()).a()) + (l.d(1) * 2);
+                d2 = l.d(3);
+                if (a0Var.b != null) {
+                    serializedSize = a0Var.b.size();
+                } else {
+                    serializedSize = a0Var.a != null ? a0Var.a.getSerializedSize() : 0;
+                }
+                e = l.e(serializedSize);
+            } else {
+                a2 = l.a(2, ((b) entry.getKey()).a()) + (l.d(1) * 2);
+                d2 = l.d(3);
+                serializedSize = ((o0) value).getSerializedSize();
+                e = l.e(serializedSize);
+            }
+            return e + serializedSize + d2 + a2;
+        }
+        return a((b<?>) bVar, value);
+    }
+
+    public static <T extends b<T>> boolean b(Map.Entry<T, Object> entry) {
+        T key = entry.getKey();
+        if (key.d() == r1.c.MESSAGE) {
+            if (key.b()) {
+                Iterator it = ((List) entry.getValue()).iterator();
+                while (it.hasNext()) {
+                    if (!((o0) it.next()).isInitialized()) {
+                        return false;
+                    }
+                }
+            } else {
+                Object value = entry.getValue();
+                if (value instanceof o0) {
+                    if (!((o0) value).isInitialized()) {
+                        return false;
+                    }
+                } else {
+                    if (value instanceof a0) {
+                        return true;
+                    }
+                    throw new IllegalArgumentException("Wrong object type used with protocol message reflection.");
+                }
+            }
+        }
+        return true;
+    }
+
+    public static int a(r1.b bVar, Object obj) {
+        int serializedSize;
+        int e;
+        switch (a.b[bVar.ordinal()]) {
+            case 1:
+                ((Double) obj).doubleValue();
+                Logger logger = l.b;
+                return 8;
+            case 2:
+                ((Float) obj).floatValue();
+                Logger logger2 = l.b;
+                return 4;
+            case 3:
+                return l.a(((Long) obj).longValue());
+            case 4:
+                return l.a(((Long) obj).longValue());
+            case 5:
+                return l.c(((Integer) obj).intValue());
+            case 6:
+                ((Long) obj).longValue();
+                Logger logger3 = l.b;
+                return 8;
+            case 7:
+                ((Integer) obj).intValue();
+                Logger logger4 = l.b;
+                return 4;
+            case 8:
+                ((Boolean) obj).booleanValue();
+                Logger logger5 = l.b;
+                return 1;
+            case 9:
+                Logger logger6 = l.b;
+                return ((o0) obj).getSerializedSize();
+            case 10:
+                if (obj instanceof a0) {
+                    a0 a0Var = (a0) obj;
+                    Logger logger7 = l.b;
+                    if (a0Var.b != null) {
+                        serializedSize = a0Var.b.size();
+                    } else {
+                        serializedSize = a0Var.a != null ? a0Var.a.getSerializedSize() : 0;
+                    }
+                    e = l.e(serializedSize);
+                    break;
+                } else {
+                    Logger logger8 = l.b;
+                    serializedSize = ((o0) obj).getSerializedSize();
+                    e = l.e(serializedSize);
+                    break;
+                }
+            case 11:
+                if (obj instanceof i) {
+                    Logger logger9 = l.b;
+                    serializedSize = ((i) obj).size();
+                    e = l.e(serializedSize);
+                    break;
+                } else {
+                    return l.a((String) obj);
+                }
+            case 12:
+                if (obj instanceof i) {
+                    Logger logger10 = l.b;
+                    serializedSize = ((i) obj).size();
+                    e = l.e(serializedSize);
+                    break;
+                } else {
+                    Logger logger11 = l.b;
+                    serializedSize = ((byte[]) obj).length;
+                    e = l.e(serializedSize);
+                    break;
+                }
+            case 13:
+                return l.e(((Integer) obj).intValue());
+            case 14:
+                ((Integer) obj).intValue();
+                Logger logger12 = l.b;
+                return 4;
+            case 15:
+                ((Long) obj).longValue();
+                Logger logger13 = l.b;
+                return 8;
+            case 16:
+                return l.e(l.f(((Integer) obj).intValue()));
+            case 17:
+                return l.a(l.b(((Long) obj).longValue()));
+            case 18:
+                if (obj instanceof y.c) {
+                    return l.c(((y.c) obj).a());
+                }
+                return l.c(((Integer) obj).intValue());
+            default:
+                throw new RuntimeException("There is no way to get here, but the compiler thinks otherwise.");
+        }
+        return e + serializedSize;
+    }
+
+    public final void c(Map.Entry<T, Object> entry) {
+        T key = entry.getKey();
+        Object value = entry.getValue();
+        if (value instanceof a0) {
+            value = ((a0) value).a(null);
+        }
+        if (key.b()) {
+            Object a2 = a((u<T>) key);
+            if (a2 == null) {
+                a2 = new ArrayList();
+            }
+            for (Object obj : (List) value) {
+                List list = (List) a2;
+                if (obj instanceof byte[]) {
+                    byte[] bArr = (byte[]) obj;
+                    byte[] bArr2 = new byte[bArr.length];
+                    System.arraycopy(bArr, 0, bArr2, 0, bArr.length);
+                    obj = bArr2;
+                }
+                list.add(obj);
+            }
+            this.a.put(key, a2);
+            return;
+        }
+        if (key.d() == r1.c.MESSAGE) {
+            Object a3 = a((u<T>) key);
+            if (a3 == null) {
+                g1<T, Object> g1Var = this.a;
+                if (value instanceof byte[]) {
+                    byte[] bArr3 = (byte[]) value;
+                    byte[] bArr4 = new byte[bArr3.length];
+                    System.arraycopy(bArr3, 0, bArr4, 0, bArr3.length);
+                    value = bArr4;
+                }
+                g1Var.put(key, value);
+                return;
+            }
+            this.a.put(key, key.a(((o0) a3).toBuilder(), (o0) value).a());
+            return;
+        }
+        g1<T, Object> g1Var2 = this.a;
+        if (value instanceof byte[]) {
+            byte[] bArr5 = (byte[]) value;
+            byte[] bArr6 = new byte[bArr5.length];
+            System.arraycopy(bArr5, 0, bArr6, 0, bArr5.length);
+            value = bArr6;
+        }
+        g1Var2.put(key, value);
+    }
+
+    public final int c() {
+        int i = 0;
+        for (int i2 = 0; i2 < this.a.b.size(); i2++) {
+            Map.Entry<T, Object> a2 = this.a.a(i2);
+            i += a((b<?>) a2.getKey(), a2.getValue());
+        }
+        for (Map.Entry<T, Object> entry : this.a.b()) {
+            i += a((b<?>) entry.getKey(), entry.getValue());
+        }
+        return i;
+    }
+
+    public static int a(b<?> bVar, Object obj) {
+        int d2;
+        int a2;
+        r1.b c = bVar.c();
+        int a3 = bVar.a();
+        if (bVar.b()) {
+            int i = 0;
+            if (bVar.isPacked()) {
+                Iterator it = ((List) obj).iterator();
+                while (it.hasNext()) {
+                    i += a(c, it.next());
+                }
+                d2 = l.d(a3) + i;
+                a2 = l.e(i);
+            } else {
+                for (Object obj2 : (List) obj) {
+                    int d3 = l.d(a3);
+                    if (c == r1.b.GROUP) {
+                        d3 *= 2;
+                    }
+                    i += a(c, obj2) + d3;
+                }
+                return i;
+            }
+        } else {
+            d2 = l.d(a3);
+            if (c == r1.b.GROUP) {
+                d2 *= 2;
+            }
+            a2 = a(c, obj);
+        }
+        return a2 + d2;
+    }
+
+    public final void a(GeneratedMessageLite.d dVar, Object obj) {
+        List list;
+        if (dVar.d) {
+            c(dVar, obj);
+            Object a2 = a((u<T>) dVar);
+            if (a2 == null) {
+                list = new ArrayList();
+                this.a.put(dVar, list);
+            } else {
+                list = (List) a2;
+            }
+            list.add(obj);
+            return;
+        }
+        throw new IllegalArgumentException("addRepeatedField() can only be called on repeated fields.");
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/u0.java

@@ -0,0 +1,11 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+
+/* loaded from: classes2.dex */
+public final class u0 implements t0 {
+    @Override // com.fyber.inneractive.sdk.protobuf.t0
+    public final Object a(o0 o0Var) {
+        return ((GeneratedMessageLite) o0Var).dynamicMethod(GeneratedMessageLite.f.NEW_MUTABLE_INSTANCE);
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/v.java

@@ -0,0 +1,223 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.nio.charset.Charset;
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.RandomAccess;
+
+/* loaded from: classes2.dex */
+public final class v extends c<Float> implements y.f, RandomAccess, x0 {
+    public static final v d;
+    public float[] b;
+    public int c;
+
+    static {
+        v vVar = new v(new float[0], 0);
+        d = vVar;
+        vVar.a = false;
+    }
+
+    public v() {
+        this(new float[10], 0);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final void add(int i, Object obj) {
+        int i2;
+        float floatValue = ((Float) obj).floatValue();
+        e();
+        if (i < 0 || i > (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        float[] fArr = this.b;
+        if (i2 < fArr.length) {
+            System.arraycopy(fArr, i, fArr, i + 1, i2 - i);
+        } else {
+            float[] fArr2 = new float[((i2 * 3) / 2) + 1];
+            System.arraycopy(fArr, 0, fArr2, 0, i);
+            System.arraycopy(this.b, i, fArr2, i + 1, this.c - i);
+            this.b = fArr2;
+        }
+        this.b[i] = floatValue;
+        this.c++;
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean addAll(Collection<? extends Float> collection) {
+        e();
+        Charset charset = y.a;
+        collection.getClass();
+        if (!(collection instanceof v)) {
+            return super.addAll(collection);
+        }
+        v vVar = (v) collection;
+        int i = vVar.c;
+        if (i == 0) {
+            return false;
+        }
+        int i2 = this.c;
+        if (Integer.MAX_VALUE - i2 < i) {
+            throw new OutOfMemoryError();
+        }
+        int i3 = i2 + i;
+        float[] fArr = this.b;
+        if (i3 > fArr.length) {
+            this.b = Arrays.copyOf(fArr, i3);
+        }
+        System.arraycopy(vVar.b, 0, this.b, this.c, vVar.c);
+        this.c = i3;
+        ((AbstractList) this).modCount++;
+        return true;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean contains(Object obj) {
+        return indexOf(obj) != -1;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.Collection, java.util.List
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof v)) {
+            return super.equals(obj);
+        }
+        v vVar = (v) obj;
+        if (this.c != vVar.c) {
+            return false;
+        }
+        float[] fArr = vVar.b;
+        for (int i = 0; i < this.c; i++) {
+            if (Float.floatToIntBits(this.b[i]) != Float.floatToIntBits(fArr[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final int indexOf(Object obj) {
+        if (!(obj instanceof Float)) {
+            return -1;
+        }
+        float floatValue = ((Float) obj).floatValue();
+        int i = this.c;
+        for (int i2 = 0; i2 < i; i2++) {
+            if (this.b[i2] == floatValue) {
+                return i2;
+            }
+        }
+        return -1;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.List
+    public final Object remove(int i) {
+        int i2;
+        e();
+        if (i < 0 || i >= (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        float[] fArr = this.b;
+        float f = fArr[i];
+        if (i < i2 - 1) {
+            System.arraycopy(fArr, i + 1, fArr, i, (i2 - i) - 1);
+        }
+        this.c--;
+        ((AbstractList) this).modCount++;
+        return Float.valueOf(f);
+    }
+
+    @Override // java.util.AbstractList
+    public final void removeRange(int i, int i2) {
+        e();
+        if (i2 < i) {
+            throw new IndexOutOfBoundsException("toIndex < fromIndex");
+        }
+        float[] fArr = this.b;
+        System.arraycopy(fArr, i2, fArr, i, this.c - i2);
+        this.c -= i2 - i;
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object set(int i, Object obj) {
+        float floatValue = ((Float) obj).floatValue();
+        e();
+        if (i < 0 || i >= this.c) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        float[] fArr = this.b;
+        float f = fArr[i];
+        fArr[i] = floatValue;
+        return Float.valueOf(f);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.c;
+    }
+
+    public v(float[] fArr, int i) {
+        this.b = fArr;
+        this.c = i;
+    }
+
+    public final void a(float f) {
+        e();
+        int i = this.c;
+        float[] fArr = this.b;
+        if (i == fArr.length) {
+            float[] fArr2 = new float[((i * 3) / 2) + 1];
+            System.arraycopy(fArr, 0, fArr2, 0, i);
+            this.b = fArr2;
+        }
+        float[] fArr3 = this.b;
+        int i2 = this.c;
+        this.c = i2 + 1;
+        fArr3[i2] = f;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object get(int i) {
+        if (i >= 0 && i < this.c) {
+            return Float.valueOf(this.b[i]);
+        }
+        StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+        a.append(this.c);
+        throw new IndexOutOfBoundsException(a.toString());
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.Collection, java.util.List
+    public final int hashCode() {
+        int i = 1;
+        for (int i2 = 0; i2 < this.c; i2++) {
+            i = (i * 31) + Float.floatToIntBits(this.b[i2]);
+        }
+        return i;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.y.j
+    /* renamed from: c, reason: merged with bridge method [inline-methods] */
+    public final v a(int i) {
+        if (i >= this.c) {
+            return new v(Arrays.copyOf(this.b, i), this.c);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean add(Object obj) {
+        a(((Float) obj).floatValue());
+        return true;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/v0.java

@@ -0,0 +1,18 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class v0 {
+    public static final t0 a;
+    public static final u0 b;
+
+    static {
+        t0 t0Var;
+        try {
+            t0Var = (t0) Class.forName("com.google.protobuf.NewInstanceSchemaFull").getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
+        } catch (Exception unused) {
+            t0Var = null;
+        }
+        a = t0Var;
+        b = new u0();
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/w.java

@@ -0,0 +1,23 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public final class w implements n0 {
+    public static final w a = new w();
+
+    @Override // com.fyber.inneractive.sdk.protobuf.n0
+    public final m0 a(Class<?> cls) {
+        if (!GeneratedMessageLite.class.isAssignableFrom(cls)) {
+            throw new IllegalArgumentException("Unsupported message type: ".concat(cls.getName()));
+        }
+        try {
+            return (m0) GeneratedMessageLite.getDefaultInstance(cls.asSubclass(GeneratedMessageLite.class)).buildMessageInfo();
+        } catch (Exception e) {
+            throw new RuntimeException("Unable to get message info for ".concat(cls.getName()), e);
+        }
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.n0
+    public final boolean b(Class<?> cls) {
+        return GeneratedMessageLite.class.isAssignableFrom(cls);
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/w0.java

@@ -0,0 +1,5 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public interface w0<MessageType> {
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/x.java

@@ -0,0 +1,227 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.y;
+import java.nio.charset.Charset;
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.RandomAccess;
+
+/* loaded from: classes2.dex */
+public final class x extends c<Integer> implements y.g, RandomAccess, x0 {
+    public static final x d;
+    public int[] b;
+    public int c;
+
+    static {
+        x xVar = new x(new int[0], 0);
+        d = xVar;
+        xVar.a = false;
+    }
+
+    public x() {
+        this(new int[10], 0);
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final void add(int i, Object obj) {
+        int i2;
+        int intValue = ((Integer) obj).intValue();
+        e();
+        if (i < 0 || i > (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        int[] iArr = this.b;
+        if (i2 < iArr.length) {
+            System.arraycopy(iArr, i, iArr, i + 1, i2 - i);
+        } else {
+            int[] iArr2 = new int[((i2 * 3) / 2) + 1];
+            System.arraycopy(iArr, 0, iArr2, 0, i);
+            System.arraycopy(this.b, i, iArr2, i + 1, this.c - i);
+            this.b = iArr2;
+        }
+        this.b[i] = intValue;
+        this.c++;
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean addAll(Collection<? extends Integer> collection) {
+        e();
+        Charset charset = y.a;
+        collection.getClass();
+        if (!(collection instanceof x)) {
+            return super.addAll(collection);
+        }
+        x xVar = (x) collection;
+        int i = xVar.c;
+        if (i == 0) {
+            return false;
+        }
+        int i2 = this.c;
+        if (Integer.MAX_VALUE - i2 < i) {
+            throw new OutOfMemoryError();
+        }
+        int i3 = i2 + i;
+        int[] iArr = this.b;
+        if (i3 > iArr.length) {
+            this.b = Arrays.copyOf(iArr, i3);
+        }
+        System.arraycopy(xVar.b, 0, this.b, this.c, xVar.c);
+        this.c = i3;
+        ((AbstractList) this).modCount++;
+        return true;
+    }
+
+    public final void c(int i) {
+        e();
+        int i2 = this.c;
+        int[] iArr = this.b;
+        if (i2 == iArr.length) {
+            int[] iArr2 = new int[((i2 * 3) / 2) + 1];
+            System.arraycopy(iArr, 0, iArr2, 0, i2);
+            this.b = iArr2;
+        }
+        int[] iArr3 = this.b;
+        int i3 = this.c;
+        this.c = i3 + 1;
+        iArr3[i3] = i;
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean contains(Object obj) {
+        return indexOf(obj) != -1;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.Collection, java.util.List
+    public final boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof x)) {
+            return super.equals(obj);
+        }
+        x xVar = (x) obj;
+        if (this.c != xVar.c) {
+            return false;
+        }
+        int[] iArr = xVar.b;
+        for (int i = 0; i < this.c; i++) {
+            if (this.b[i] != iArr[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object get(int i) {
+        return Integer.valueOf(d(i));
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final int indexOf(Object obj) {
+        if (!(obj instanceof Integer)) {
+            return -1;
+        }
+        int intValue = ((Integer) obj).intValue();
+        int i = this.c;
+        for (int i2 = 0; i2 < i; i2++) {
+            if (this.b[i2] == intValue) {
+                return i2;
+            }
+        }
+        return -1;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.List
+    public final Object remove(int i) {
+        int i2;
+        e();
+        if (i < 0 || i >= (i2 = this.c)) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        int[] iArr = this.b;
+        int i3 = iArr[i];
+        if (i < i2 - 1) {
+            System.arraycopy(iArr, i + 1, iArr, i, (i2 - i) - 1);
+        }
+        this.c--;
+        ((AbstractList) this).modCount++;
+        return Integer.valueOf(i3);
+    }
+
+    @Override // java.util.AbstractList
+    public final void removeRange(int i, int i2) {
+        e();
+        if (i2 < i) {
+            throw new IndexOutOfBoundsException("toIndex < fromIndex");
+        }
+        int[] iArr = this.b;
+        System.arraycopy(iArr, i2, iArr, i, this.c - i2);
+        this.c -= i2 - i;
+        ((AbstractList) this).modCount++;
+    }
+
+    @Override // java.util.AbstractList, java.util.List
+    public final Object set(int i, Object obj) {
+        int intValue = ((Integer) obj).intValue();
+        e();
+        if (i < 0 || i >= this.c) {
+            StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+            a.append(this.c);
+            throw new IndexOutOfBoundsException(a.toString());
+        }
+        int[] iArr = this.b;
+        int i2 = iArr[i];
+        iArr[i] = intValue;
+        return Integer.valueOf(i2);
+    }
+
+    @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final int size() {
+        return this.c;
+    }
+
+    public x(int[] iArr, int i) {
+        this.b = iArr;
+        this.c = i;
+    }
+
+    public final int d(int i) {
+        if (i >= 0 && i < this.c) {
+            return this.b[i];
+        }
+        StringBuilder a = com.fyber.inneractive.sdk.bidder.h.a("Index:", i, ", Size:");
+        a.append(this.c);
+        throw new IndexOutOfBoundsException(a.toString());
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.Collection, java.util.List
+    public final int hashCode() {
+        int i = 1;
+        for (int i2 = 0; i2 < this.c; i2++) {
+            i = (i * 31) + this.b[i2];
+        }
+        return i;
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.y.j
+    /* renamed from: e, reason: merged with bridge method [inline-methods] */
+    public final x a(int i) {
+        if (i >= this.c) {
+            return new x(Arrays.copyOf(this.b, i), this.c);
+        }
+        throw new IllegalArgumentException();
+    }
+
+    @Override // com.fyber.inneractive.sdk.protobuf.c, java.util.AbstractList, java.util.AbstractCollection, java.util.Collection, java.util.List
+    public final boolean add(Object obj) {
+        c(((Integer) obj).intValue());
+        return true;
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/x0.java

@@ -0,0 +1,5 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public interface x0 {
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/y.java

@@ -0,0 +1,117 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.bidder.TokenParametersOuterClass$TokenParameters;
+import com.fyber.inneractive.sdk.protobuf.GeneratedMessageLite;
+import com.fyber.inneractive.sdk.protobuf.a;
+import com.fyber.inneractive.sdk.protobuf.j;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.AbstractList;
+import java.util.List;
+import java.util.RandomAccess;
+
+/* loaded from: classes2.dex */
+public final class y {
+    public static final Charset a = Charset.forName("UTF-8");
+    public static final byte[] b;
+
+    public interface a extends j<Boolean> {
+    }
+
+    public interface b extends j<Double> {
+    }
+
+    public interface c {
+        int a();
+    }
+
+    public interface d<T extends c> {
+        T a(int i);
+    }
+
+    public interface e {
+        boolean a();
+    }
+
+    public interface f extends j<Float> {
+    }
+
+    public interface g extends j<Integer> {
+    }
+
+    public static class h<F, T> extends AbstractList<T> {
+        public final List<F> a;
+        public final a<F, T> b;
+
+        public interface a<F, T> {
+        }
+
+        public h(g gVar, a aVar) {
+            this.a = gVar;
+            this.b = aVar;
+        }
+
+        @Override // java.util.AbstractList, java.util.List
+        public final T get(int i) {
+            a<F, T> aVar = this.b;
+            F f = this.a.get(i);
+            ((TokenParametersOuterClass$TokenParameters.a) aVar).getClass();
+            T t = (T) TokenParametersOuterClass$TokenParameters.k.a(((Integer) f).intValue());
+            return t == null ? (T) TokenParametersOuterClass$TokenParameters.k.UNRECOGNIZED : t;
+        }
+
+        @Override // java.util.AbstractCollection, java.util.Collection, java.util.List
+        public final int size() {
+            return this.a.size();
+        }
+    }
+
+    public interface i extends j<Long> {
+    }
+
+    public interface j<E> extends List<E>, RandomAccess {
+        j<E> a(int i);
+
+        void a();
+
+        boolean d();
+    }
+
+    static {
+        Charset.forName("ISO-8859-1");
+        byte[] bArr = new byte[0];
+        b = bArr;
+        ByteBuffer.wrap(bArr);
+        try {
+            new j.a(bArr, 0, 0, false).d(0);
+        } catch (z e2) {
+            throw new IllegalArgumentException(e2);
+        }
+    }
+
+    public static int a(long j2) {
+        return (int) (j2 ^ (j2 >>> 32));
+    }
+
+    public static <T> T a(T t, String str) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(str);
+    }
+
+    public static String a(byte[] bArr) {
+        return new String(bArr, a);
+    }
+
+    public static GeneratedMessageLite a(Object obj, Object obj2) {
+        o0 o0Var = (o0) obj2;
+        a.AbstractC0103a abstractC0103a = (a.AbstractC0103a) ((o0) obj).toBuilder();
+        abstractC0103a.getClass();
+        GeneratedMessageLite.b bVar = (GeneratedMessageLite.b) abstractC0103a;
+        if (bVar.a.getClass().isInstance(o0Var)) {
+            return bVar.a((GeneratedMessageLite) ((com.fyber.inneractive.sdk.protobuf.a) o0Var)).b();
+        }
+        throw new IllegalArgumentException("mergeFrom(MessageLite) can only merge messages of the same type.");
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/y0.java

@@ -0,0 +1,7 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+/* loaded from: classes2.dex */
+public enum y0 {
+    PROTO2,
+    PROTO3
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/z.java

@@ -0,0 +1,57 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import java.io.IOException;
+
+/* loaded from: classes2.dex */
+public class z extends IOException {
+    public static final /* synthetic */ int a = 0;
+    private static final long serialVersionUID = -1616151763072450476L;
+
+    public static class a extends z {
+        private static final long serialVersionUID = 3283890091615336259L;
+
+        public a() {
+            super("Protocol message tag had invalid wire type.");
+        }
+    }
+
+    public z(String str) {
+        super(str);
+    }
+
+    public static z a() {
+        return new z("Protocol message end-group tag did not match expected tag.");
+    }
+
+    public static z b() {
+        return new z("Protocol message contained an invalid tag (zero).");
+    }
+
+    public static z c() {
+        return new z("Protocol message had invalid UTF-8.");
+    }
+
+    public static a d() {
+        return new a();
+    }
+
+    public static z e() {
+        return new z("CodedInputStream encountered a malformed varint.");
+    }
+
+    public static z f() {
+        return new z("CodedInputStream encountered an embedded string or message which claimed to have negative size.");
+    }
+
+    public static z g() {
+        return new z("Failed to parse the message.");
+    }
+
+    public static z h() {
+        return new z("Protocol message had too many levels of nesting.  May be malicious.  Use CodedInputStream.setRecursionLimit() to increase the depth limit.");
+    }
+
+    public static z i() {
+        return new z("While parsing a protocol message, the input ended unexpectedly in the middle of a field.  This could mean either that the input has been truncated or that an embedded message misreported its own length.");
+    }
+}

decompiled/sources/com/fyber/inneractive/sdk/protobuf/z0.java

@@ -0,0 +1,64 @@
+package com.fyber.inneractive.sdk.protobuf;
+
+import com.fyber.inneractive.sdk.protobuf.e0;
+import java.nio.charset.Charset;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes2.dex */
+public final class z0 {
+    public static final z0 c = new z0();
+    public final ConcurrentHashMap b = new ConcurrentHashMap();
+    public final g0 a = new g0();
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r3v5, types: [com.fyber.inneractive.sdk.protobuf.s0] */
+    /* JADX WARN: Type inference failed for: r3v7, types: [com.fyber.inneractive.sdk.protobuf.s0] */
+    public final <T> d1<T> a(Class<T> cls) {
+        r0 a;
+        r0 r0Var;
+        Class<?> cls2;
+        Charset charset = y.a;
+        if (cls == null) {
+            throw new NullPointerException("messageType");
+        }
+        d1<T> d1Var = (d1) this.b.get(cls);
+        if (d1Var != null) {
+            return d1Var;
+        }
+        g0 g0Var = this.a;
+        g0Var.getClass();
+        Class<?> cls3 = e1.a;
+        if (!GeneratedMessageLite.class.isAssignableFrom(cls) && (cls2 = e1.a) != null && !cls2.isAssignableFrom(cls)) {
+            throw new IllegalArgumentException("Message classes must extend GeneratedMessage or GeneratedMessageLite");
+        }
+        m0 a2 = g0Var.a.a(cls);
+        if (a2.a()) {
+            if (GeneratedMessageLite.class.isAssignableFrom(cls)) {
+                r0Var = new s0(e1.d, t.a, a2.c());
+            } else {
+                k1<?, ?> k1Var = e1.b;
+                r<?> rVar = t.b;
+                if (rVar == null) {
+                    throw new IllegalStateException("Protobuf runtime is not correctly loaded.");
+                }
+                r0Var = new s0(k1Var, rVar, a2.c());
+            }
+            a = r0Var;
+        } else if (GeneratedMessageLite.class.isAssignableFrom(cls)) {
+            a = a2.b() == y0.PROTO2 ? r0.a(a2, v0.b, e0.b, e1.d, t.a, l0.b) : r0.a(a2, v0.b, e0.b, e1.d, (r) null, l0.b);
+        } else if (a2.b() == y0.PROTO2) {
+            t0 t0Var = v0.a;
+            e0.a aVar = e0.a;
+            k1<?, ?> k1Var2 = e1.b;
+            r<?> rVar2 = t.b;
+            if (rVar2 == null) {
+                throw new IllegalStateException("Protobuf runtime is not correctly loaded.");
+            }
+            a = r0.a(a2, t0Var, aVar, k1Var2, rVar2, l0.a);
+        } else {
+            a = r0.a(a2, v0.a, e0.a, e1.c, (r) null, l0.a);
+        }
+        d1<T> d1Var2 = (d1) this.b.putIfAbsent(cls, a);
+        return d1Var2 != null ? d1Var2 : a;
+    }
+}