package com.google.protobuf;

import V.C0629x;
import com.google.crypto.tink.shaded.protobuf.C1256d;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/* JADX INFO: loaded from: classes3.dex */
public abstract class L extends AbstractC1298c {
    private static final int MEMOIZED_SERIALIZED_SIZE_MASK = Integer.MAX_VALUE;
    private static final int MUTABLE_FLAG_MASK = Integer.MIN_VALUE;
    static final int UNINITIALIZED_HASH_CODE = 0;
    static final int UNINITIALIZED_SERIALIZED_SIZE = Integer.MAX_VALUE;
    private static Map<Object, L> defaultInstanceMap = new ConcurrentHashMap();
    private int memoizedSerializedSize;
    protected T0 unknownFields;

    public L() {
        this.memoizedHashCode = 0;
        this.memoizedSerializedSize = -1;
        this.unknownFields = T0.f14225f;
    }

    public static J access$000(AbstractC1339x abstractC1339x) {
        abstractC1339x.getClass();
        return (J) abstractC1339x;
    }

    public static void c(L l) throws C1297b0 {
        if (l == null || l.isInitialized()) {
            return;
        }
        S0 s0NewUninitializedMessageException = l.newUninitializedMessageException();
        s0NewUninitializedMessageException.getClass();
        throw new C1297b0(s0NewUninitializedMessageException.getMessage());
    }

    public static L d(L l, InputStream inputStream, C1343z c1343z) throws C1297b0 {
        try {
            int i6 = inputStream.read();
            if (i6 == -1) {
                return null;
            }
            AbstractC1329s abstractC1329sG = AbstractC1329s.g(new C1294a(inputStream, AbstractC1329s.s(inputStream, i6)));
            L partialFrom = parsePartialFrom(l, abstractC1329sG, c1343z);
            abstractC1329sG.a(0);
            return partialFrom;
        } catch (C1297b0 e6) {
            if (e6.f14239a) {
                throw new C1297b0(e6.getMessage(), e6);
            }
            throw e6;
        } catch (IOException e7) {
            throw new C1297b0(e7.getMessage(), e7);
        }
    }

    public static L e(L l, byte[] bArr, int i6, int i7, C1343z c1343z) throws C1297b0 {
        L lNewMutableInstance = l.newMutableInstance();
        try {
            J0 j0B = D0.f14169c.b(lNewMutableInstance);
            j0B.j(lNewMutableInstance, bArr, i6, i6 + i7, new C1256d(c1343z));
            j0B.b(lNewMutableInstance);
            return lNewMutableInstance;
        } catch (S0 e6) {
            throw new C1297b0(e6.getMessage());
        } catch (C1297b0 e7) {
            if (e7.f14239a) {
                throw new C1297b0(e7.getMessage(), e7);
            }
            throw e7;
        } catch (IOException e8) {
            if (e8.getCause() instanceof C1297b0) {
                throw ((C1297b0) e8.getCause());
            }
            throw new C1297b0(e8.getMessage(), e8);
        } catch (IndexOutOfBoundsException unused) {
            throw C1297b0.h();
        }
    }

    public static Q emptyBooleanList() {
        return C1308h.f14274d;
    }

    public static S emptyDoubleList() {
        return C1337w.f14365d;
    }

    public static V emptyFloatList() {
        return E.f14172d;
    }

    public static W emptyIntList() {
        return P.f14219d;
    }

    public static X emptyLongList() {
        return C1313j0.f14282d;
    }

    public static <E> Y emptyProtobufList() {
        return E0.f14175d;
    }

    public static <T extends L> T getDefaultInstance(Class<T> cls) {
        T t6 = (T) defaultInstanceMap.get(cls);
        if (t6 == null) {
            try {
                Class.forName(cls.getName(), true, cls.getClassLoader());
                t6 = (T) defaultInstanceMap.get(cls);
            } catch (ClassNotFoundException e6) {
                throw new IllegalStateException("Class initialization cannot fail.", e6);
            }
        }
        if (t6 != null) {
            return t6;
        }
        T t7 = (T) ((L) c1.b(cls)).getDefaultInstanceForType();
        if (t7 == null) {
            throw new IllegalStateException();
        }
        defaultInstanceMap.put(cls, t7);
        return t7;
    }

    public static Method getMethodOrDie(Class cls, String str, Class... clsArr) {
        try {
            return cls.getMethod(str, clsArr);
        } catch (NoSuchMethodException e6) {
            throw new RuntimeException("Generated message class \"" + cls.getName() + "\" missing method \"" + str + "\".", e6);
        }
    }

    public static Object invokeOrDie(Method method, Object obj, Object... objArr) {
        try {
            return method.invoke(obj, objArr);
        } catch (IllegalAccessException e6) {
            throw new RuntimeException("Couldn't use Java reflection to implement protocol message reflection.", e6);
        } catch (InvocationTargetException e7) {
            Throwable cause = e7.getCause();
            if (cause instanceof RuntimeException) {
                throw ((RuntimeException) cause);
            }
            if (cause instanceof Error) {
                throw ((Error) cause);
            }
            throw new RuntimeException("Unexpected exception thrown by generated accessor method.", cause);
        }
    }

    public static W mutableCopy(W w6) {
        P p6 = (P) w6;
        int i6 = p6.f14221c;
        int i7 = i6 == 0 ? 10 : i6 * 2;
        if (i7 >= i6) {
            return new P(Arrays.copyOf(p6.f14220b, i7), p6.f14221c, true);
        }
        throw new IllegalArgumentException();
    }

    public static Object newMessageInfo(InterfaceC1332t0 interfaceC1332t0, String str, Object[] objArr) {
        return new F0(interfaceC1332t0, str, objArr);
    }

    public static <ContainingType extends InterfaceC1332t0, Type> J newRepeatedGeneratedExtension(ContainingType containingtype, InterfaceC1332t0 interfaceC1332t0, U u6, int i6, k1 k1Var, boolean z6, Class cls) {
        return new J(containingtype, Collections.EMPTY_LIST, interfaceC1332t0, new I(u6, i6, k1Var, true, z6));
    }

    public static <ContainingType extends InterfaceC1332t0, Type> J newSingularGeneratedExtension(ContainingType containingtype, Type type, InterfaceC1332t0 interfaceC1332t0, U u6, int i6, k1 k1Var, Class cls) {
        return new J(containingtype, type, interfaceC1332t0, new I(u6, i6, k1Var, false, false));
    }

    public static <T extends L> T parseDelimitedFrom(T t6, InputStream inputStream) throws C1297b0 {
        T t7 = (T) d(t6, inputStream, C1343z.a());
        c(t7);
        return t7;
    }

    public static <T extends L> T parseFrom(T t6, ByteBuffer byteBuffer, C1343z c1343z) throws C1297b0 {
        AbstractC1329s abstractC1329sF;
        if (byteBuffer.hasArray()) {
            abstractC1329sF = AbstractC1329s.f(byteBuffer.array(), byteBuffer.position() + byteBuffer.arrayOffset(), byteBuffer.remaining(), false);
        } else if (byteBuffer.isDirect() && c1.f14252d) {
            abstractC1329sF = new r(byteBuffer, false);
        } else {
            int iRemaining = byteBuffer.remaining();
            byte[] bArr = new byte[iRemaining];
            byteBuffer.duplicate().get(bArr);
            abstractC1329sF = AbstractC1329s.f(bArr, 0, iRemaining, true);
        }
        T t7 = (T) parseFrom(t6, abstractC1329sF, c1343z);
        c(t7);
        return t7;
    }

    /* JADX WARN: Type inference fix 'apply assigned field type' failed
    java.lang.UnsupportedOperationException: ArgType.getObject(), call class: class jadx.core.dex.instructions.args.ArgType$UnknownArg
    	at jadx.core.dex.instructions.args.ArgType.getObject(ArgType.java:593)
    	at jadx.core.dex.attributes.nodes.ClassTypeVarsAttr.getTypeVarsMapFor(ClassTypeVarsAttr.java:35)
    	at jadx.core.dex.nodes.utils.TypeUtils.replaceClassGenerics(TypeUtils.java:177)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.insertExplicitUseCast(FixTypesVisitor.java:397)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.tryFieldTypeWithNewCasts(FixTypesVisitor.java:359)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.applyFieldType(FixTypesVisitor.java:309)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.visit(FixTypesVisitor.java:94)
     */
    public static <T extends L> T parsePartialFrom(T t6, AbstractC1329s abstractC1329s, C1343z c1343z) throws C1297b0 {
        T t7 = (T) t6.newMutableInstance();
        try {
            J0 j0B = D0.f14169c.b(t7);
            C0629x c0629x = abstractC1329s.f14353c;
            if (c0629x == null) {
                c0629x = new C0629x(abstractC1329s);
            }
            j0B.f(t7, c0629x, c1343z);
            j0B.b(t7);
            return t7;
        } catch (S0 e6) {
            throw new C1297b0(e6.getMessage());
        } catch (C1297b0 e7) {
            if (e7.f14239a) {
                throw new C1297b0(e7.getMessage(), e7);
            }
            throw e7;
        } catch (IOException e8) {
            if (e8.getCause() instanceof C1297b0) {
                throw ((C1297b0) e8.getCause());
            }
            throw new C1297b0(e8.getMessage(), e8);
        } catch (RuntimeException e9) {
            if (e9.getCause() instanceof C1297b0) {
                throw ((C1297b0) e9.getCause());
            }
            throw e9;
        }
    }

    public static <T extends L> void registerDefaultInstance(Class<T> cls, T t6) {
        t6.markImmutable();
        defaultInstanceMap.put(cls, t6);
    }

    public Object buildMessageInfo() {
        return dynamicMethod(K.f14201c);
    }

    public void clearMemoizedHashCode() {
        this.memoizedHashCode = 0;
    }

    public void clearMemoizedSerializedSize() {
        setMemoizedSerializedSize(Integer.MAX_VALUE);
    }

    public int computeHashCode() {
        D0 d02 = D0.f14169c;
        d02.getClass();
        return d02.a(getClass()).g(this);
    }

    public final <MessageType extends L, BuilderType extends G> BuilderType createBuilder() {
        return (BuilderType) dynamicMethod(K.f14203e);
    }

    public Object dynamicMethod(K k6, Object obj) {
        return dynamicMethod(k6, obj, null);
    }

    public abstract Object dynamicMethod(K k6, Object obj, Object obj2);

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        D0 d02 = D0.f14169c;
        d02.getClass();
        return d02.a(getClass()).i(this, (L) obj);
    }

    public int getMemoizedHashCode() {
        return this.memoizedHashCode;
    }

    public int getMemoizedSerializedSize() {
        return this.memoizedSerializedSize & Integer.MAX_VALUE;
    }

    @Override // com.google.protobuf.InterfaceC1332t0
    public final B0 getParserForType() {
        return (B0) dynamicMethod(K.f14205j);
    }

    @Override // com.google.protobuf.AbstractC1298c
    public int getSerializedSize(J0 j02) {
        int iH;
        int iH2;
        if (isMutable()) {
            if (j02 == null) {
                D0 d02 = D0.f14169c;
                d02.getClass();
                iH2 = d02.a(getClass()).h(this);
            } else {
                iH2 = j02.h(this);
            }
            if (iH2 >= 0) {
                return iH2;
            }
            throw new IllegalStateException(Z0.o.l("serialized size must be non-negative, was ", iH2));
        }
        if (getMemoizedSerializedSize() != Integer.MAX_VALUE) {
            return getMemoizedSerializedSize();
        }
        if (j02 == null) {
            D0 d03 = D0.f14169c;
            d03.getClass();
            iH = d03.a(getClass()).h(this);
        } else {
            iH = j02.h(this);
        }
        setMemoizedSerializedSize(iH);
        return iH;
    }

    public int hashCode() {
        if (isMutable()) {
            return computeHashCode();
        }
        if (hashCodeIsNotMemoized()) {
            setMemoizedHashCode(computeHashCode());
        }
        return getMemoizedHashCode();
    }

    public boolean hashCodeIsNotMemoized() {
        return getMemoizedHashCode() == 0;
    }

    @Override // com.google.protobuf.InterfaceC1334u0
    public final boolean isInitialized() {
        return isInitialized(this, true);
    }

    public boolean isMutable() {
        return (this.memoizedSerializedSize & Integer.MIN_VALUE) != 0;
    }

    public void makeImmutable() {
        D0 d02 = D0.f14169c;
        d02.getClass();
        d02.a(getClass()).b(this);
        markImmutable();
    }

    public void markImmutable() {
        this.memoizedSerializedSize &= Integer.MAX_VALUE;
    }

    public void mergeLengthDelimitedField(int i6, AbstractC1320n abstractC1320n) {
        if (this.unknownFields == T0.f14225f) {
            this.unknownFields = new T0();
        }
        T0 t02 = this.unknownFields;
        t02.a();
        if (i6 == 0) {
            throw new IllegalArgumentException("Zero is not a valid field number.");
        }
        t02.f((i6 << 3) | 2, abstractC1320n);
    }

    public final void mergeUnknownFields(T0 t02) {
        this.unknownFields = T0.e(this.unknownFields, t02);
    }

    public void mergeVarintField(int i6, int i7) {
        if (this.unknownFields == T0.f14225f) {
            this.unknownFields = new T0();
        }
        T0 t02 = this.unknownFields;
        t02.a();
        if (i6 == 0) {
            throw new IllegalArgumentException("Zero is not a valid field number.");
        }
        t02.f(i6 << 3, Long.valueOf(i7));
    }

    public L newMutableInstance() {
        return (L) dynamicMethod(K.f14202d);
    }

    public boolean parseUnknownField(int i6, AbstractC1329s abstractC1329s) {
        if ((i6 & 7) == 4) {
            return false;
        }
        if (this.unknownFields == T0.f14225f) {
            this.unknownFields = new T0();
        }
        return this.unknownFields.d(i6, abstractC1329s);
    }

    public void setMemoizedHashCode(int i6) {
        this.memoizedHashCode = i6;
    }

    public void setMemoizedSerializedSize(int i6) {
        if (i6 < 0) {
            throw new IllegalStateException(Z0.o.l("serialized size must be non-negative, was ", i6));
        }
        this.memoizedSerializedSize = (i6 & Integer.MAX_VALUE) | (this.memoizedSerializedSize & Integer.MIN_VALUE);
    }

    public String toString() {
        String string = super.toString();
        char[] cArr = AbstractC1336v0.f14364a;
        StringBuilder sb = new StringBuilder();
        sb.append("# ");
        sb.append(string);
        AbstractC1336v0.c(this, sb, 0);
        return sb.toString();
    }

    @Override // com.google.protobuf.InterfaceC1332t0
    public void writeTo(AbstractC1335v abstractC1335v) {
        D0 d02 = D0.f14169c;
        d02.getClass();
        J0 j0A = d02.a(getClass());
        C1317l0 c1317l0 = abstractC1335v.f14363c;
        if (c1317l0 == null) {
            c1317l0 = new C1317l0(abstractC1335v);
        }
        j0A.e(this, c1317l0);
    }

    public static final <T extends L> boolean isInitialized(T t6, boolean z6) {
        byte bByteValue = ((Byte) t6.dynamicMethod(K.f14199a)).byteValue();
        if (bByteValue == 1) {
            return true;
        }
        if (bByteValue == 0) {
            return false;
        }
        D0 d02 = D0.f14169c;
        d02.getClass();
        boolean zC = d02.a(t6.getClass()).c(t6);
        if (z6) {
            t6.dynamicMethod(K.f14200b, zC ? t6 : null);
        }
        return zC;
    }

    public final <MessageType extends L, BuilderType extends G> BuilderType createBuilder(MessageType messagetype) {
        return (BuilderType) createBuilder().mergeFrom((L) messagetype);
    }

    public Object dynamicMethod(K k6) {
        return dynamicMethod(k6, null, null);
    }

    @Override // com.google.protobuf.InterfaceC1334u0
    public final L getDefaultInstanceForType() {
        return (L) dynamicMethod(K.f14204f);
    }

    @Override // com.google.protobuf.InterfaceC1332t0
    public final G newBuilderForType() {
        return (G) dynamicMethod(K.f14203e);
    }

    /* JADX INFO: renamed from: toBuilder, reason: merged with bridge method [inline-methods] */
    public final G m367toBuilder() {
        return ((G) dynamicMethod(K.f14203e)).mergeFrom(this);
    }

    public static <T extends L> T parseDelimitedFrom(T t6, InputStream inputStream, C1343z c1343z) throws C1297b0 {
        T t7 = (T) d(t6, inputStream, c1343z);
        c(t7);
        return t7;
    }

    public static X mutableCopy(X x6) {
        C1313j0 c1313j0 = (C1313j0) x6;
        int i6 = c1313j0.f14284c;
        int i7 = i6 == 0 ? 10 : i6 * 2;
        if (i7 >= i6) {
            return new C1313j0(Arrays.copyOf(c1313j0.f14283b, i7), c1313j0.f14284c, true);
        }
        throw new IllegalArgumentException();
    }

    public static V mutableCopy(V v3) {
        E e6 = (E) v3;
        int i6 = e6.f14174c;
        int i7 = i6 == 0 ? 10 : i6 * 2;
        if (i7 >= i6) {
            return new E(Arrays.copyOf(e6.f14173b, i7), e6.f14174c, true);
        }
        throw new IllegalArgumentException();
    }

    public static <T extends L> T parseFrom(T t6, ByteBuffer byteBuffer) {
        return (T) parseFrom(t6, byteBuffer, C1343z.a());
    }

    public static S mutableCopy(S s6) {
        C1337w c1337w = (C1337w) s6;
        int i6 = c1337w.f14367c;
        int i7 = i6 == 0 ? 10 : i6 * 2;
        if (i7 >= i6) {
            return new C1337w(Arrays.copyOf(c1337w.f14366b, i7), c1337w.f14367c, true);
        }
        throw new IllegalArgumentException();
    }

    public static <T extends L> T parseFrom(T t6, AbstractC1320n abstractC1320n) throws C1297b0 {
        T t7 = (T) parseFrom(t6, abstractC1320n, C1343z.a());
        c(t7);
        return t7;
    }

    public static <T extends L> T parseFrom(T t6, AbstractC1320n abstractC1320n, C1343z c1343z) throws C1297b0 {
        AbstractC1329s abstractC1329sS = abstractC1320n.s();
        T t7 = (T) parsePartialFrom(t6, abstractC1329sS, c1343z);
        abstractC1329sS.a(0);
        c(t7);
        return t7;
    }

    public static Q mutableCopy(Q q6) {
        C1308h c1308h = (C1308h) q6;
        int i6 = c1308h.f14276c;
        int i7 = i6 == 0 ? 10 : i6 * 2;
        if (i7 >= i6) {
            return new C1308h(Arrays.copyOf(c1308h.f14275b, i7), c1308h.f14276c, true);
        }
        throw new IllegalArgumentException();
    }

    public static <T extends L> T parseFrom(T t6, byte[] bArr) throws C1297b0 {
        T t7 = (T) e(t6, bArr, 0, bArr.length, C1343z.a());
        c(t7);
        return t7;
    }

    public static <E> Y mutableCopy(Y y6) {
        int size = y6.size();
        return y6.a(size == 0 ? 10 : size * 2);
    }

    public static <T extends L> T parseFrom(T t6, byte[] bArr, C1343z c1343z) throws C1297b0 {
        T t7 = (T) e(t6, bArr, 0, bArr.length, c1343z);
        c(t7);
        return t7;
    }

    @Override // com.google.protobuf.InterfaceC1332t0
    public int getSerializedSize() {
        return getSerializedSize(null);
    }

    public static <T extends L> T parsePartialFrom(T t6, AbstractC1329s abstractC1329s) {
        return (T) parsePartialFrom(t6, abstractC1329s, C1343z.a());
    }

    public static <T extends L> T parseFrom(T t6, InputStream inputStream) throws C1297b0 {
        T t7 = (T) parsePartialFrom(t6, AbstractC1329s.g(inputStream), C1343z.a());
        c(t7);
        return t7;
    }

    public static <T extends L> T parseFrom(T t6, InputStream inputStream, C1343z c1343z) throws C1297b0 {
        T t7 = (T) parsePartialFrom(t6, AbstractC1329s.g(inputStream), c1343z);
        c(t7);
        return t7;
    }

    public static <T extends L> T parseFrom(T t6, AbstractC1329s abstractC1329s) {
        return (T) parseFrom(t6, abstractC1329s, C1343z.a());
    }

    public static <T extends L> T parseFrom(T t6, AbstractC1329s abstractC1329s, C1343z c1343z) throws C1297b0 {
        T t7 = (T) parsePartialFrom(t6, abstractC1329s, c1343z);
        c(t7);
        return t7;
    }
}