package com.google.crypto.tink.shaded.protobuf;

import defpackage.AbstractC1130;
import defpackage.AbstractC2251;
import defpackage.AbstractC2638;
import defpackage.AbstractC2704;
import defpackage.AbstractC4613;
import defpackage.AbstractC4615;
import defpackage.C0168;
import defpackage.C1236;
import defpackage.C1379;
import defpackage.C2082;
import defpackage.C4449;
import defpackage.C4935;
import defpackage.InterfaceC2421;
import defpackage.InterfaceC2623;
import j$.util.concurrent.ConcurrentHashMap;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;

/* JADX INFO: renamed from: com.google.crypto.tink.shaded.protobuf.ᵨᵣ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes3.dex */
public abstract class AbstractC0021 extends AbstractC0024 {
    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<Class<?>, AbstractC0021> defaultInstanceMap = new ConcurrentHashMap();
    private int memoizedSerializedSize;
    protected C0026 unknownFields;

    public AbstractC0021() {
        this.memoizedHashCode = UNINITIALIZED_HASH_CODE;
        this.memoizedSerializedSize = -1;
        this.unknownFields = C0026.f1104;
    }

    /* JADX INFO: renamed from: ˊᵨᵧ, reason: contains not printable characters */
    public static AbstractC0021 m871(AbstractC0021 abstractC0021, byte[] bArr, C2082 c2082) throws InvalidProtocolBufferException {
        int length = bArr.length;
        if (length != 0) {
            AbstractC0021 abstractC0021M880 = abstractC0021.m880();
            try {
                C0168 c0168 = C0168.f1587;
                c0168.getClass();
                InterfaceC2623 interfaceC2623M1318 = c0168.m1318(abstractC0021M880.getClass());
                C4449 c4449 = new C4449();
                c2082.getClass();
                interfaceC2623M1318.mo853(abstractC0021M880, bArr, UNINITIALIZED_HASH_CODE, length, c4449);
                interfaceC2623M1318.mo849(abstractC0021M880);
                abstractC0021 = abstractC0021M880;
            } catch (InvalidProtocolBufferException e) {
                if (e.f1070) {
                    throw new InvalidProtocolBufferException(e.getMessage(), e);
                }
                throw e;
            } catch (UninitializedMessageException e2) {
                throw new InvalidProtocolBufferException(e2.getMessage());
            } catch (IOException e3) {
                if (e3.getCause() instanceof InvalidProtocolBufferException) {
                    throw ((InvalidProtocolBufferException) e3.getCause());
                }
                throw new InvalidProtocolBufferException(e3.getMessage(), e3);
            } catch (IndexOutOfBoundsException unused) {
                throw InvalidProtocolBufferException.m839();
            }
        }
        m872(abstractC0021);
        return abstractC0021;
    }

    /* JADX INFO: renamed from: ˊᵫᵗ, reason: contains not printable characters */
    public static void m872(AbstractC0021 abstractC0021) throws InvalidProtocolBufferException {
        if (abstractC0021 != null && !m877(abstractC0021, true)) {
            throw new InvalidProtocolBufferException(new UninitializedMessageException().getMessage());
        }
    }

    /* JADX INFO: renamed from: ˋˈ, reason: contains not printable characters */
    public static Object m873(Method method, AbstractC0021 abstractC0021, Object... objArr) {
        try {
            return method.invoke(abstractC0021, objArr);
        } catch (IllegalAccessException e) {
            ᵷᵝˎ.ᵪᵹᵥᵻ("Couldn't use Java reflection to implement protocol message reflection.", e);
            return null;
        } catch (InvocationTargetException e2) {
            Throwable cause = e2.getCause();
            if (cause instanceof RuntimeException) {
                throw ((RuntimeException) cause);
            }
            if (cause instanceof Error) {
                throw ((Error) cause);
            }
            ᵷᵝˎ.ᵪᵹᵥᵻ("Unexpected exception thrown by generated accessor method.", cause);
            return null;
        }
    }

    /* JADX INFO: renamed from: ˌᴵ, reason: contains not printable characters */
    public static AbstractC0021 m874(AbstractC0021 abstractC0021, AbstractC2638 abstractC2638, C2082 c2082) throws InvalidProtocolBufferException {
        AbstractC0021 abstractC0021M880 = abstractC0021.m880();
        try {
            C0168 c0168 = C0168.f1587;
            c0168.getClass();
            InterfaceC2623 interfaceC2623M1318 = c0168.m1318(abstractC0021M880.getClass());
            C0027 c0027 = (C0027) abstractC2638.f10241;
            if (c0027 == null) {
                c0027 = new C0027(abstractC2638);
            }
            interfaceC2623M1318.mo852(abstractC0021M880, c0027, c2082);
            interfaceC2623M1318.mo849(abstractC0021M880);
            return abstractC0021M880;
        } catch (InvalidProtocolBufferException e) {
            if (e.f1070) {
                throw new InvalidProtocolBufferException(e.getMessage(), e);
            }
            throw e;
        } catch (UninitializedMessageException e2) {
            throw new InvalidProtocolBufferException(e2.getMessage());
        } catch (IOException e3) {
            if (e3.getCause() instanceof InvalidProtocolBufferException) {
                throw ((InvalidProtocolBufferException) e3.getCause());
            }
            throw new InvalidProtocolBufferException(e3.getMessage(), e3);
        } catch (RuntimeException e4) {
            if (e4.getCause() instanceof InvalidProtocolBufferException) {
                throw ((InvalidProtocolBufferException) e4.getCause());
            }
            throw e4;
        }
    }

    /* JADX INFO: renamed from: ˏːˆ, reason: contains not printable characters */
    public static AbstractC0021 m875(AbstractC0021 abstractC0021, AbstractC4613 abstractC4613, C2082 c2082) throws InvalidProtocolBufferException {
        C1236 c1236 = (C1236) abstractC4613;
        C0018 c0018M6407 = AbstractC2638.m6407(c1236.f5209, c1236.mo3721(), c1236.size(), true);
        AbstractC0021 abstractC0021M874 = m874(abstractC0021, c0018M6407, c2082);
        c0018M6407.mo99(UNINITIALIZED_HASH_CODE);
        m872(abstractC0021M874);
        return abstractC0021M874;
    }

    /* JADX INFO: renamed from: ᵜᵪʾ, reason: contains not printable characters */
    public static void m876(Class cls, AbstractC0021 abstractC0021) {
        abstractC0021.m887();
        defaultInstanceMap.put(cls, abstractC0021);
    }

    /* JADX INFO: renamed from: ᵪᵹᵥᵻ, reason: contains not printable characters */
    public static final boolean m877(AbstractC0021 abstractC0021, boolean z) {
        byte bByteValue = ((Byte) abstractC0021.mo888(1)).byteValue();
        if (bByteValue == 1) {
            return true;
        }
        if (bByteValue == 0) {
            return false;
        }
        C0168 c0168 = C0168.f1587;
        c0168.getClass();
        boolean zMo851 = c0168.m1318(abstractC0021.getClass()).mo851(abstractC0021);
        if (z) {
            abstractC0021.mo888(2);
        }
        return zMo851;
    }

    /* JADX INFO: renamed from: ᵶᵥᵝ, reason: contains not printable characters */
    public static AbstractC0021 m878(Class cls) {
        AbstractC0021 abstractC0021 = defaultInstanceMap.get(cls);
        if (abstractC0021 == null) {
            try {
                Class.forName(cls.getName(), true, cls.getClassLoader());
                abstractC0021 = defaultInstanceMap.get(cls);
            } catch (ClassNotFoundException e) {
                C4935.m10239("Class initialization cannot fail.", e);
                return null;
            }
        }
        if (abstractC0021 != null) {
            return abstractC0021;
        }
        AbstractC0021 abstractC0021Mo879 = ((AbstractC0021) AbstractC4615.m9731(cls)).mo879();
        if (abstractC0021Mo879 != null) {
            defaultInstanceMap.put(cls, abstractC0021Mo879);
            return abstractC0021Mo879;
        }
        ᵷᵝˎ.ᵱʡˏ();
        return null;
    }

    public final boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        C0168 c0168 = C0168.f1587;
        c0168.getClass();
        return c0168.m1318(getClass()).mo858(this, (AbstractC0021) obj);
    }

    public final int hashCode() {
        if (m884()) {
            C0168 c0168 = C0168.f1587;
            c0168.getClass();
            return c0168.m1318(getClass()).mo855(this);
        }
        if (this.memoizedHashCode == 0) {
            C0168 c01682 = C0168.f1587;
            c01682.getClass();
            this.memoizedHashCode = c01682.m1318(getClass()).mo855(this);
        }
        return this.memoizedHashCode;
    }

    public final String toString() {
        String string = super.toString();
        char[] cArr = AbstractC0029.f1117;
        StringBuilder sb = new StringBuilder();
        sb.append("# ");
        sb.append(string);
        AbstractC0029.m990(this, sb, UNINITIALIZED_HASH_CODE);
        return sb.toString();
    }

    /* JADX INFO: renamed from: ˉᵲ, reason: contains not printable characters */
    public final AbstractC0021 m880() {
        return (AbstractC0021) mo888(4);
    }

    @Override // com.google.crypto.tink.shaded.protobuf.AbstractC0024
    /* JADX INFO: renamed from: ˊᵙᵾᵲ, reason: contains not printable characters and merged with bridge method [inline-methods] */
    public final AbstractC2251 mo891() {
        return (AbstractC2251) mo888(5);
    }

    /* JADX INFO: renamed from: ᵔᵖᵹᵫ, reason: contains not printable characters */
    public final void m882(int i) {
        if (i < 0) {
            ᵕᵩʽᵲ.ᵪᵹᵥᵻ(AbstractC2704.m6517(i, "serialized size must be non-negative, was "));
        } else {
            this.memoizedSerializedSize = (i & Integer.MAX_VALUE) | (this.memoizedSerializedSize & MUTABLE_FLAG_MASK);
        }
    }

    /* JADX INFO: renamed from: ᵝᵶ, reason: contains not printable characters */
    public final InterfaceC2421 m883() {
        return (InterfaceC2421) mo888(7);
    }

    /* JADX INFO: renamed from: ᵟᵹᵙ, reason: contains not printable characters */
    public final boolean m884() {
        return (this.memoizedSerializedSize & MUTABLE_FLAG_MASK) != 0;
    }

    /* JADX INFO: renamed from: ᵨᵼⁱ, reason: contains not printable characters */
    public final AbstractC2251 m885() {
        AbstractC2251 abstractC2251 = (AbstractC2251) mo888(5);
        abstractC2251.m5860(this);
        return abstractC2251;
    }

    @Override // defpackage.InterfaceC2321
    /* JADX INFO: renamed from: ᵮᵣᵗˈ, reason: contains not printable characters and merged with bridge method [inline-methods] */
    public final AbstractC0021 mo879() {
        return (AbstractC0021) mo888(6);
    }

    /* JADX INFO: renamed from: ᵱʡˏ, reason: contains not printable characters */
    public final void m887() {
        this.memoizedSerializedSize &= Integer.MAX_VALUE;
    }

    /* JADX INFO: renamed from: ᵱᵽʡᵚ, reason: contains not printable characters */
    public abstract Object mo888(int i);

    @Override // com.google.crypto.tink.shaded.protobuf.AbstractC0024
    /* JADX INFO: renamed from: ᵲᵶᵳˈ, reason: contains not printable characters */
    public final int mo889(InterfaceC2623 interfaceC2623) {
        int iMo850;
        int iMo8502;
        if (m884()) {
            if (interfaceC2623 == null) {
                C0168 c0168 = C0168.f1587;
                c0168.getClass();
                iMo8502 = c0168.m1318(getClass()).mo850(this);
            } else {
                iMo8502 = interfaceC2623.mo850(this);
            }
            if (iMo8502 >= 0) {
                return iMo8502;
            }
            ᵕᵩʽᵲ.ᵪᵹᵥᵻ(AbstractC2704.m6517(iMo8502, "serialized size must be non-negative, was "));
            return UNINITIALIZED_HASH_CODE;
        }
        int i = this.memoizedSerializedSize;
        if ((i & Integer.MAX_VALUE) != Integer.MAX_VALUE) {
            return i & Integer.MAX_VALUE;
        }
        if (interfaceC2623 == null) {
            C0168 c01682 = C0168.f1587;
            c01682.getClass();
            iMo850 = c01682.m1318(getClass()).mo850(this);
        } else {
            iMo850 = interfaceC2623.mo850(this);
        }
        m882(iMo850);
        return iMo850;
    }

    @Override // com.google.crypto.tink.shaded.protobuf.AbstractC0024
    /* JADX INFO: renamed from: ᵵᵽ, reason: contains not printable characters */
    public final void mo890(C1379 c1379) {
        C0168 c0168 = C0168.f1587;
        c0168.getClass();
        InterfaceC2623 interfaceC2623M1318 = c0168.m1318(getClass());
        ᵟˑʽ r1 = c1379.f5717;
        if (r1 == null) {
            r1 = new ᵟˑʽ();
            AbstractC1130.m3619(c1379, "output");
            r1.ˌᴵ = c1379;
            c1379.f5717 = r1;
        }
        interfaceC2623M1318.mo857(this, r1);
    }

    /* JADX INFO: renamed from: ᵻʽᵯ, reason: contains not printable characters */
    public final AbstractC2251 m892() {
        return (AbstractC2251) mo888(5);
    }
}