Kaspi.kz v5.85.1 - providesFirebasePerformance.java 源代码

package o;

import androidx.datastore.preferences.protobuf.CodedOutputStream;
import androidx.datastore.preferences.protobuf.InvalidProtocolBufferException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import o.DependencyCycleException;
import o.FirebasePerfRegistrar;
import o.FirebaseRemoteConfigFetchThrottledException;
import o.isLastFetchFailed;
import o.providesFirebasePerformance;
import o.providesFirebasePerformance.setBackground;
import o.r8lambda5PSoDbsAOSc7vMtr9P22GdjNQw;
import o.r8lambdagIko9kgvZihcrkYfHloMTUCUsQE;

public abstract class providesFirebasePerformance<MessageType extends providesFirebasePerformance<MessageType, BuilderType>, BuilderType extends setBackground<MessageType, BuilderType>> extends DependencyCycleException<MessageType, BuilderType> {
    private static Map<Object, providesFirebasePerformance<?, ?>> defaultInstanceMap = new ConcurrentHashMap();
    protected stopCollectingGauges unknownFields = stopCollectingGauges.setBackground();
    protected int memoizedSerializedSize = -1;

    public enum IconCompatParcelizer {
        GET_MEMOIZED_IS_INITIALIZED,
        SET_MEMOIZED_IS_INITIALIZED,
        BUILD_MESSAGE_INFO,
        NEW_MUTABLE_INSTANCE,
        NEW_BUILDER,
        GET_DEFAULT_INSTANCE,
        GET_PARSER
    }

    public interface setLabel<MessageType extends setOptions<MessageType, BuilderType>, BuilderType extends setError<MessageType, BuilderType>> extends FirebasePerformanceModule {
        <Type> boolean setError(FirebaseMessagingKtxRegistrar<MessageType, Type> firebaseMessagingKtxRegistrar);

        <Type> Type setFieldValue(FirebaseMessagingKtxRegistrar<MessageType, Type> firebaseMessagingKtxRegistrar);

        <Type> int setLabel(FirebaseMessagingKtxRegistrar<MessageType, List<Type>> firebaseMessagingKtxRegistrar);

        <Type> Type setLabel(FirebaseMessagingKtxRegistrar<MessageType, List<Type>> firebaseMessagingKtxRegistrar, int i);
    }

    protected abstract Object setError(IconCompatParcelizer iconCompatParcelizer, Object obj, Object obj2);

    @Override
    public final putMetric<MessageType> onBackPressedDispatcherlambda1() {
        return (putMetric) setLabel(IconCompatParcelizer.GET_PARSER);
    }

    @Override
    public final MessageType getOnBackPressedDispatcher() {
        return (MessageType) setLabel(IconCompatParcelizer.GET_DEFAULT_INSTANCE);
    }

    @Override
    public final BuilderType initializeViewTreeOwners() {
        return (BuilderType) setLabel(IconCompatParcelizer.NEW_BUILDER);
    }

    public String toString() {
        return setFirebaseRemoteConfigProvider.setOptions(this, super.toString());
    }

    public int hashCode() {
        int i = this.memoizedHashCode;
        if (i != 0) {
            return i;
        }
        int background = FirebasePerfUrlConnection.setError().setBackground(this).setBackground(this);
        this.memoizedHashCode = background;
        return background;
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (getOnBackPressedDispatcher().getClass().isInstance(obj)) {
            return FirebasePerfUrlConnection.setError().setBackground(this).setFieldValue(this, (providesFirebasePerformance) obj);
        }
        return false;
    }

    private final void setError() {
        if (this.unknownFields == stopCollectingGauges.setBackground()) {
            this.unknownFields = stopCollectingGauges.setOptions();
        }
    }

    protected boolean setFieldValue(int i, FirebaseNoSignedInUserException firebaseNoSignedInUserException) throws IOException {
        if (FirebaseRemoteConfigFetchThrottledException.setLabel(i) == 4) {
            return false;
        }
        setError();
        return this.unknownFields.setBackground(i, firebaseNoSignedInUserException);
    }

    protected void setFieldValue(int i, int i2) {
        setError();
        this.unknownFields.setError(i, i2);
    }

    protected void setOptions(int i, FirebaseInstallationsKtxRegistrar firebaseInstallationsKtxRegistrar) {
        setError();
        this.unknownFields.setError(i, firebaseInstallationsKtxRegistrar);
    }

    protected void getOnBackPressedDispatcherannotations() {
        FirebasePerfUrlConnection.setError().setBackground(this).setFieldValue(this);
    }

    public final <MessageType extends providesFirebasePerformance<MessageType, BuilderType>, BuilderType extends setBackground<MessageType, BuilderType>> BuilderType r8lambdaqrzmfDOyDuplJFtpJLozn3P9EZI() {
        return (BuilderType) setLabel(IconCompatParcelizer.NEW_BUILDER);
    }

    public final <MessageType extends providesFirebasePerformance<MessageType, BuilderType>, BuilderType extends setBackground<MessageType, BuilderType>> BuilderType setError(MessageType messagetype) {
        return (BuilderType) r8lambdaqrzmfDOyDuplJFtpJLozn3P9EZI().setFieldValue(messagetype);
    }

    @Override
    public final boolean getLifecycle() {
        return setOptions(this, true);
    }

    @Override
    public final BuilderType onBackPressed() {
        BuilderType buildertype = (BuilderType) setLabel(IconCompatParcelizer.NEW_BUILDER);
        buildertype.setFieldValue(this);
        return buildertype;
    }

    protected Object setLabel(IconCompatParcelizer iconCompatParcelizer, Object obj) {
        return setError(iconCompatParcelizer, obj, (Object) null);
    }

    protected Object setLabel(IconCompatParcelizer iconCompatParcelizer) {
        return setError(iconCompatParcelizer, (Object) null, (Object) null);
    }

    @Override
    int RatingCompat() {
        return this.memoizedSerializedSize;
    }

    @Override
    void setLabel(int i) {
        this.memoizedSerializedSize = i;
    }

    @Override
    public void setLabel(CodedOutputStream codedOutputStream) throws IOException {
        FirebasePerfUrlConnection.setError().setBackground(this).setError((r8lambdaB4EZpGOcGV8Pbms2hfENARWWl40) this, (FirebaseRemoteConfigKtxRegistrar) FirebaseCommonLegacyRegistrar.setError(codedOutputStream));
    }

    @Override
    public int addContentView() {
        if (this.memoizedSerializedSize == -1) {
            this.memoizedSerializedSize = FirebasePerfUrlConnection.setError().setBackground(this).setLabel(this);
        }
        return this.memoizedSerializedSize;
    }

    Object ComponentActivity3() throws Exception {
        return setLabel(IconCompatParcelizer.BUILD_MESSAGE_INFO);
    }

    static <T extends providesFirebasePerformance<?, ?>> T setOptions(Class<T> cls) {
        providesFirebasePerformance<?, ?> providesfirebaseperformance = defaultInstanceMap.get(cls);
        if (providesfirebaseperformance == null) {
            try {
                Class.forName(cls.getName(), true, cls.getClassLoader());
                providesfirebaseperformance = defaultInstanceMap.get(cls);
            } catch (ClassNotFoundException e) {
                throw new IllegalStateException("Class initialization cannot fail.", e);
            }
        }
        if (providesfirebaseperformance == null) {
            providesfirebaseperformance = (T) ((providesFirebasePerformance) initializeGaugeMetadataManager.setFieldValue(cls)).getOnBackPressedDispatcher();
            if (providesfirebaseperformance == null) {
                throw new IllegalStateException();
            }
            defaultInstanceMap.put(cls, providesfirebaseperformance);
        }
        return (T) providesfirebaseperformance;
    }

    public static <T extends providesFirebasePerformance<?, ?>> void setLabel(Class<T> cls, T t) {
        defaultInstanceMap.put(cls, t);
    }

    public static Object setOptions(isLastFetchFailed islastfetchfailed, String str, Object[] objArr) {
        return new SessionManager(islastfetchfailed, str, objArr);
    }

    protected final void setLabel(stopCollectingGauges stopcollectinggauges) {
        this.unknownFields = stopCollectingGauges.setError(this.unknownFields, stopcollectinggauges);
    }

    public static abstract class setBackground<MessageType extends providesFirebasePerformance<MessageType, BuilderType>, BuilderType extends setBackground<MessageType, BuilderType>> extends DependencyCycleException.setError<MessageType, BuilderType> {
        private final MessageType setFieldValue;
        protected boolean setLabel = false;
        public MessageType setOptions;

        public setBackground(MessageType messagetype) {
            this.setFieldValue = messagetype;
            this.setOptions = (MessageType) messagetype.setLabel(IconCompatParcelizer.NEW_MUTABLE_INSTANCE);
        }

        public void addContentView() {
            if (this.setLabel) {
                MessageType messagetype = (MessageType) this.setOptions.setLabel(IconCompatParcelizer.NEW_MUTABLE_INSTANCE);
                setError(messagetype, this.setOptions);
                this.setOptions = messagetype;
                this.setLabel = false;
            }
        }

        @Override
        public final boolean getLifecycle() {
            return providesFirebasePerformance.setOptions(this.setOptions, false);
        }

        @Override
        public final BuilderType r8lambdaqrzmfDOyDuplJFtpJLozn3P9EZI() {
            this.setOptions = (MessageType) this.setOptions.setLabel(IconCompatParcelizer.NEW_MUTABLE_INSTANCE);
            return this;
        }

        @Override
        public BuilderType clone() {
            BuilderType buildertype = (BuilderType) getOnBackPressedDispatcher().initializeViewTreeOwners();
            buildertype.setFieldValue(ComponentActivity6());
            return buildertype;
        }

        @Override
        public MessageType ComponentActivity6() {
            if (this.setLabel) {
                return this.setOptions;
            }
            this.setOptions.getOnBackPressedDispatcherannotations();
            this.setLabel = true;
            return this.setOptions;
        }

        @Override
        public final MessageType ComponentActivity3() {
            MessageType ComponentActivity6 = ComponentActivity6();
            if (ComponentActivity6.getLifecycle()) {
                return ComponentActivity6;
            }
            throw DependencyCycleException.setError.setBackground((isLastFetchFailed) ComponentActivity6);
        }

        @Override
        public BuilderType setBackground(MessageType messagetype) {
            return setFieldValue((setBackground<MessageType, BuilderType>) messagetype);
        }

        public BuilderType setFieldValue(MessageType messagetype) {
            addContentView();
            setError(this.setOptions, messagetype);
            return this;
        }

        private void setError(MessageType messagetype, MessageType messagetype2) {
            FirebasePerfUrlConnection.setError().setBackground(messagetype).setError(messagetype, messagetype2);
        }

        @Override
        public MessageType getOnBackPressedDispatcher() {
            return this.setFieldValue;
        }

        @Override
        public BuilderType setFieldValue(byte[] bArr, int i, int i2, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
            addContentView();
            try {
                FirebasePerfUrlConnection.setError().setBackground(this.setOptions).setError(this.setOptions, bArr, i, i + i2, new r8lambda5PSoDbsAOSc7vMtr9P22GdjNQw.setLabel(handlemessageintent));
                return this;
            } catch (InvalidProtocolBufferException e) {
                throw e;
            } catch (IOException e2) {
                throw new RuntimeException("Reading from byte array should not throw IOException.", e2);
            } catch (IndexOutOfBoundsException unused) {
                throw InvalidProtocolBufferException.setElement();
            }
        }

        @Override
        public BuilderType setLabel(byte[] bArr, int i, int i2) throws InvalidProtocolBufferException {
            return setError(bArr, i, i2, handleMessageIntent.setFieldValue());
        }

        @Override
        public BuilderType setOptions(FirebaseNoSignedInUserException firebaseNoSignedInUserException, handleMessageIntent handlemessageintent) throws IOException {
            addContentView();
            try {
                FirebasePerfUrlConnection.setError().setBackground(this.setOptions).setError(this.setOptions, r8lambdavJ_ijnislX2JLJx5rFvt8ObqNeg.setBackground(firebaseNoSignedInUserException), handlemessageintent);
                return this;
            } catch (RuntimeException e) {
                if (e.getCause() instanceof IOException) {
                    throw ((IOException) e.getCause());
                }
                throw e;
            }
        }
    }

    public static abstract class setOptions<MessageType extends setOptions<MessageType, BuilderType>, BuilderType extends setError<MessageType, BuilderType>> extends providesFirebasePerformance<MessageType, BuilderType> implements setLabel<MessageType, BuilderType> {
        protected FirebasePerfRegistrar<RemoteActionCompatParcelizer> extensions = FirebasePerfRegistrar.setBackground();

        @Override
        public isLastFetchFailed getOnBackPressedDispatcher() {
            return super.getOnBackPressedDispatcher();
        }

        @Override
        public isLastFetchFailed.setFieldValue initializeViewTreeOwners() {
            return super.initializeViewTreeOwners();
        }

        @Override
        public isLastFetchFailed.setFieldValue onBackPressed() {
            return super.onBackPressed();
        }

        protected final void setFieldValue(MessageType messagetype) {
            if (this.extensions.AudioAttributesCompatParcelizer()) {
                this.extensions = this.extensions.clone();
            }
            this.extensions.setError(messagetype.extensions);
        }

        protected <MessageType extends isLastFetchFailed> boolean setBackground(MessageType messagetype, FirebaseNoSignedInUserException firebaseNoSignedInUserException, handleMessageIntent handlemessageintent, int i) throws IOException {
            int error = FirebaseRemoteConfigFetchThrottledException.setError(i);
            return setBackground(firebaseNoSignedInUserException, handlemessageintent, handlemessageintent.setError(messagetype, error), i, error);
        }

        private boolean setBackground(o.FirebaseNoSignedInUserException r6, o.handleMessageIntent r7, o.providesFirebasePerformance.setElement<?, ?> r8, int r9, int r10) throws java.io.IOException {
            throw new UnsupportedOperationException("Method not decompiled: o.providesFirebasePerformance.setOptions.setBackground(o.FirebaseNoSignedInUserException, o.handleMessageIntent, o.providesFirebasePerformance$setElement, int, int):boolean");
        }

        protected <MessageType extends isLastFetchFailed> boolean setOptions(MessageType messagetype, FirebaseNoSignedInUserException firebaseNoSignedInUserException, handleMessageIntent handlemessageintent, int i) throws IOException {
            if (i == FirebaseRemoteConfigFetchThrottledException.read) {
                setOptions((setOptions<MessageType, BuilderType>) messagetype, firebaseNoSignedInUserException, handlemessageintent);
                return true;
            }
            if (FirebaseRemoteConfigFetchThrottledException.setLabel(i) == 2) {
                return setBackground(messagetype, firebaseNoSignedInUserException, handlemessageintent, i);
            }
            return firebaseNoSignedInUserException.setElement(i);
        }

        private <MessageType extends isLastFetchFailed> void setOptions(MessageType messagetype, FirebaseNoSignedInUserException firebaseNoSignedInUserException, handleMessageIntent handlemessageintent) throws IOException {
            int i = 0;
            FirebaseInstallationsKtxRegistrar firebaseInstallationsKtxRegistrar = null;
            setElement<?, ?> setelement = null;
            while (true) {
                int PlaybackStateCompat = firebaseNoSignedInUserException.PlaybackStateCompat();
                if (PlaybackStateCompat == 0) {
                    break;
                }
                if (PlaybackStateCompat == FirebaseRemoteConfigFetchThrottledException.AudioAttributesImplApi21Parcelizer) {
                    i = firebaseNoSignedInUserException.PlaybackStateCompatCustomAction();
                    if (i != 0) {
                        setelement = handlemessageintent.setError(messagetype, i);
                    }
                } else if (PlaybackStateCompat == FirebaseRemoteConfigFetchThrottledException.setElement) {
                    if (i != 0 && setelement != null) {
                        setOptions(firebaseNoSignedInUserException, setelement, handlemessageintent, i);
                        firebaseInstallationsKtxRegistrar = null;
                    } else {
                        firebaseInstallationsKtxRegistrar = firebaseNoSignedInUserException.setElement();
                    }
                } else if (!firebaseNoSignedInUserException.setElement(PlaybackStateCompat)) {
                    break;
                }
            }
            firebaseNoSignedInUserException.setOptions(FirebaseRemoteConfigFetchThrottledException.write);
            if (firebaseInstallationsKtxRegistrar == null || i == 0) {
                return;
            }
            if (setelement != null) {
                setOptions(firebaseInstallationsKtxRegistrar, handlemessageintent, setelement);
            } else {
                setOptions(i, firebaseInstallationsKtxRegistrar);
            }
        }

        private void setOptions(FirebaseNoSignedInUserException firebaseNoSignedInUserException, setElement<?, ?> setelement, handleMessageIntent handlemessageintent, int i) throws IOException {
            setBackground(firebaseNoSignedInUserException, handlemessageintent, setelement, FirebaseRemoteConfigFetchThrottledException.setLabel(i, 2), i);
        }

        private void setOptions(FirebaseInstallationsKtxRegistrar firebaseInstallationsKtxRegistrar, handleMessageIntent handlemessageintent, setElement<?, ?> setelement) throws IOException {
            isLastFetchFailed islastfetchfailed = (isLastFetchFailed) this.extensions.setBackground((FirebasePerfRegistrar<RemoteActionCompatParcelizer>) setelement.setOptions);
            isLastFetchFailed.setFieldValue onBackPressed = islastfetchfailed != null ? islastfetchfailed.onBackPressed() : null;
            if (onBackPressed == null) {
                onBackPressed = setelement.setFieldValue().initializeViewTreeOwners();
            }
            onBackPressed.setLabel(firebaseInstallationsKtxRegistrar, handlemessageintent);
            setOptions().setLabel(setelement.setOptions, setelement.setFieldValue(onBackPressed.ComponentActivity3()));
        }

        FirebasePerfRegistrar<RemoteActionCompatParcelizer> setOptions() {
            if (this.extensions.AudioAttributesCompatParcelizer()) {
                this.extensions = this.extensions.clone();
            }
            return this.extensions;
        }

        private void setLabel(setElement<MessageType, ?> setelement) {
            if (setelement.setElement() != getOnBackPressedDispatcher()) {
                throw new IllegalArgumentException("This extension is for a different message type.  Please make sure that you are not suppressing any generics type warnings.");
            }
        }

        @Override
        public final <Type> boolean setError(FirebaseMessagingKtxRegistrar<MessageType, Type> firebaseMessagingKtxRegistrar) {
            setElement<MessageType, ?> options = providesFirebasePerformance.setOptions(firebaseMessagingKtxRegistrar);
            setLabel((setElement) options);
            return this.extensions.setLabel((FirebasePerfRegistrar<RemoteActionCompatParcelizer>) options.setOptions);
        }

        @Override
        public final <Type> int setLabel(FirebaseMessagingKtxRegistrar<MessageType, List<Type>> firebaseMessagingKtxRegistrar) {
            setElement<MessageType, ?> options = providesFirebasePerformance.setOptions(firebaseMessagingKtxRegistrar);
            setLabel((setElement) options);
            return this.extensions.setFieldValue((FirebasePerfRegistrar<RemoteActionCompatParcelizer>) options.setOptions);
        }

        @Override
        public final <Type> Type setFieldValue(FirebaseMessagingKtxRegistrar<MessageType, Type> firebaseMessagingKtxRegistrar) {
            setElement<MessageType, ?> options = providesFirebasePerformance.setOptions(firebaseMessagingKtxRegistrar);
            setLabel((setElement) options);
            Object background = this.extensions.setBackground((FirebasePerfRegistrar<RemoteActionCompatParcelizer>) options.setOptions);
            if (background == null) {
                return options.setBackground;
            }
            return (Type) options.setLabel(background);
        }

        @Override
        public final <Type> Type setLabel(FirebaseMessagingKtxRegistrar<MessageType, List<Type>> firebaseMessagingKtxRegistrar, int i) {
            setElement<MessageType, ?> options = providesFirebasePerformance.setOptions(firebaseMessagingKtxRegistrar);
            setLabel((setElement) options);
            return (Type) options.setOptions(this.extensions.setBackground((FirebasePerfRegistrar<RemoteActionCompatParcelizer>) options.setOptions, i));
        }

        protected boolean setError() {
            return this.extensions.MediaBrowserCompatCustomActionResultReceiver();
        }

        protected class setBackground {
            private final boolean setBackground;
            private Map.Entry<RemoteActionCompatParcelizer, Object> setError;
            private final Iterator<Map.Entry<RemoteActionCompatParcelizer, Object>> setFieldValue;

            setBackground(setOptions setoptions, boolean z, AnonymousClass5 anonymousClass5) {
                this(z);
            }

            private setBackground(boolean z) {
                Iterator<Map.Entry<RemoteActionCompatParcelizer, Object>> AudioAttributesImplBaseParcelizer = setOptions.this.extensions.AudioAttributesImplBaseParcelizer();
                this.setFieldValue = AudioAttributesImplBaseParcelizer;
                if (AudioAttributesImplBaseParcelizer.hasNext()) {
                    this.setError = AudioAttributesImplBaseParcelizer.next();
                }
                this.setBackground = z;
            }

            public void setOptions(int i, CodedOutputStream codedOutputStream) throws IOException {
                while (true) {
                    Map.Entry<RemoteActionCompatParcelizer, Object> entry = this.setError;
                    if (entry == null || entry.getKey().setLabel() >= i) {
                        return;
                    }
                    RemoteActionCompatParcelizer key = this.setError.getKey();
                    if (this.setBackground && key.setBackground() == FirebaseRemoteConfigFetchThrottledException.setError.MESSAGE && !key.read()) {
                        codedOutputStream.read(key.setLabel(), (isLastFetchFailed) this.setError.getValue());
                    } else {
                        FirebasePerfRegistrar.setError(key, this.setError.getValue(), codedOutputStream);
                    }
                    if (this.setFieldValue.hasNext()) {
                        this.setError = this.setFieldValue.next();
                    } else {
                        this.setError = null;
                    }
                }
            }
        }

        protected setOptions<MessageType, BuilderType>.setBackground setLabel() {
            return new setBackground(this, false, null);
        }

        protected setOptions<MessageType, BuilderType>.setBackground setElement() {
            return new setBackground(this, true, null);
        }

        protected int setBackground() {
            return this.extensions.IconCompatParcelizer();
        }

        protected int setFieldValue() {
            return this.extensions.write();
        }
    }

    static class AnonymousClass5 {
        static final int[] setBackground;

        static {
            int[] iArr = new int[FirebaseRemoteConfigFetchThrottledException.setError.values().length];
            setBackground = iArr;
            try {
                iArr[FirebaseRemoteConfigFetchThrottledException.setError.MESSAGE.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                setBackground[FirebaseRemoteConfigFetchThrottledException.setError.ENUM.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
        }
    }

    public static abstract class setError<MessageType extends setOptions<MessageType, BuilderType>, BuilderType extends setError<MessageType, BuilderType>> extends setBackground<MessageType, BuilderType> implements setLabel<MessageType, BuilderType> {
        protected setError(MessageType messagetype) {
            super(messagetype);
        }

        void setBackground(FirebasePerfRegistrar<RemoteActionCompatParcelizer> firebasePerfRegistrar) {
            addContentView();
            ((setOptions) this.setOptions).extensions = firebasePerfRegistrar;
        }

        @Override
        public void addContentView() {
            if (this.setLabel) {
                super.addContentView();
                setOptions setoptions = (setOptions) this.setOptions;
                setoptions.extensions = setoptions.extensions.clone();
            }
        }

        private FirebasePerfRegistrar<RemoteActionCompatParcelizer> setError() {
            FirebasePerfRegistrar<RemoteActionCompatParcelizer> firebasePerfRegistrar = ((setOptions) this.setOptions).extensions;
            if (!firebasePerfRegistrar.AudioAttributesCompatParcelizer()) {
                return firebasePerfRegistrar;
            }
            FirebasePerfRegistrar<RemoteActionCompatParcelizer> clone = firebasePerfRegistrar.clone();
            ((setOptions) this.setOptions).extensions = clone;
            return clone;
        }

        @Override
        public final MessageType ComponentActivity6() {
            if (this.setLabel) {
                return (MessageType) this.setOptions;
            }
            ((setOptions) this.setOptions).extensions.AudioAttributesImplApi21Parcelizer();
            return (MessageType) super.ComponentActivity6();
        }

        private void setLabel(setElement<MessageType, ?> setelement) {
            if (setelement.setElement() != getOnBackPressedDispatcher()) {
                throw new IllegalArgumentException("This extension is for a different message type.  Please make sure that you are not suppressing any generics type warnings.");
            }
        }

        @Override
        public final <Type> boolean setError(FirebaseMessagingKtxRegistrar<MessageType, Type> firebaseMessagingKtxRegistrar) {
            return ((setOptions) this.setOptions).setError(firebaseMessagingKtxRegistrar);
        }

        @Override
        public final <Type> int setLabel(FirebaseMessagingKtxRegistrar<MessageType, List<Type>> firebaseMessagingKtxRegistrar) {
            return ((setOptions) this.setOptions).setLabel(firebaseMessagingKtxRegistrar);
        }

        @Override
        public final <Type> Type setFieldValue(FirebaseMessagingKtxRegistrar<MessageType, Type> firebaseMessagingKtxRegistrar) {
            return (Type) ((setOptions) this.setOptions).setFieldValue(firebaseMessagingKtxRegistrar);
        }

        @Override
        public final <Type> Type setLabel(FirebaseMessagingKtxRegistrar<MessageType, List<Type>> firebaseMessagingKtxRegistrar, int i) {
            return (Type) ((setOptions) this.setOptions).setLabel(firebaseMessagingKtxRegistrar, i);
        }

        public final <Type> BuilderType setFieldValue(FirebaseMessagingKtxRegistrar<MessageType, Type> firebaseMessagingKtxRegistrar, Type type) {
            setElement<MessageType, ?> options = providesFirebasePerformance.setOptions(firebaseMessagingKtxRegistrar);
            setLabel((setElement) options);
            addContentView();
            setError().setLabel(options.setOptions, options.setBackground(type));
            return this;
        }

        public final <Type> BuilderType setOptions(FirebaseMessagingKtxRegistrar<MessageType, List<Type>> firebaseMessagingKtxRegistrar, int i, Type type) {
            setElement<MessageType, ?> options = providesFirebasePerformance.setOptions(firebaseMessagingKtxRegistrar);
            setLabel((setElement) options);
            addContentView();
            setError().setBackground(options.setOptions, i, options.setFieldValue(type));
            return this;
        }

        public final <Type> BuilderType setError(FirebaseMessagingKtxRegistrar<MessageType, List<Type>> firebaseMessagingKtxRegistrar, Type type) {
            setElement<MessageType, ?> options = providesFirebasePerformance.setOptions(firebaseMessagingKtxRegistrar);
            setLabel((setElement) options);
            addContentView();
            setError().setFieldValue((FirebasePerfRegistrar<RemoteActionCompatParcelizer>) options.setOptions, options.setFieldValue(type));
            return this;
        }

        public final <Type> BuilderType setBackground(FirebaseMessagingKtxRegistrar<MessageType, ?> firebaseMessagingKtxRegistrar) {
            setElement<MessageType, ?> options = providesFirebasePerformance.setOptions(firebaseMessagingKtxRegistrar);
            setLabel((setElement) options);
            addContentView();
            setError().setOptions((FirebasePerfRegistrar<RemoteActionCompatParcelizer>) options.setOptions);
            return this;
        }
    }

    public static <ContainingType extends isLastFetchFailed, Type> setElement<ContainingType, Type> setFieldValue(ContainingType containingtype, Type type, isLastFetchFailed islastfetchfailed, r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setFieldValue<?> setfieldvalue, int i, FirebaseRemoteConfigFetchThrottledException.setLabel setlabel, Class cls) {
        return new setElement<>(containingtype, type, islastfetchfailed, new RemoteActionCompatParcelizer(setfieldvalue, i, setlabel, false, false), cls);
    }

    public static <ContainingType extends isLastFetchFailed, Type> setElement<ContainingType, Type> setLabel(ContainingType containingtype, isLastFetchFailed islastfetchfailed, r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setFieldValue<?> setfieldvalue, int i, FirebaseRemoteConfigFetchThrottledException.setLabel setlabel, boolean z, Class cls) {
        return new setElement<>(containingtype, Collections.emptyList(), islastfetchfailed, new RemoteActionCompatParcelizer(setfieldvalue, i, setlabel, true, z), cls);
    }

    static final class RemoteActionCompatParcelizer implements FirebasePerfRegistrar.setLabel<RemoteActionCompatParcelizer> {
        final boolean setBackground;
        final int setError;
        final FirebaseRemoteConfigFetchThrottledException.setLabel setFieldValue;
        final boolean setLabel;
        final r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setFieldValue<?> setOptions;

        RemoteActionCompatParcelizer(r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setFieldValue<?> setfieldvalue, int i, FirebaseRemoteConfigFetchThrottledException.setLabel setlabel, boolean z, boolean z2) {
            this.setOptions = setfieldvalue;
            this.setError = i;
            this.setFieldValue = setlabel;
            this.setBackground = z;
            this.setLabel = z2;
        }

        @Override
        public int setLabel() {
            return this.setError;
        }

        @Override
        public FirebaseRemoteConfigFetchThrottledException.setLabel setFieldValue() {
            return this.setFieldValue;
        }

        @Override
        public FirebaseRemoteConfigFetchThrottledException.setError setBackground() {
            return this.setFieldValue.setOptions();
        }

        @Override
        public boolean read() {
            return this.setBackground;
        }

        @Override
        public boolean setError() {
            return this.setLabel;
        }

        @Override
        public r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setFieldValue<?> setOptions() {
            return this.setOptions;
        }

        @Override
        public isLastFetchFailed.setFieldValue setFieldValue(isLastFetchFailed.setFieldValue setfieldvalue, isLastFetchFailed islastfetchfailed) {
            return ((setBackground) setfieldvalue).setFieldValue((setBackground) islastfetchfailed);
        }

        @Override
        public int compareTo(RemoteActionCompatParcelizer remoteActionCompatParcelizer) {
            return this.setError - remoteActionCompatParcelizer.setError;
        }
    }

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

    static Object setError(Method method, Object obj, Object... objArr) {
        try {
            return method.invoke(obj, objArr);
        } catch (IllegalAccessException e) {
            throw new RuntimeException("Couldn't use Java reflection to implement protocol message reflection.", e);
        } catch (InvocationTargetException e2) {
            Throwable cause = e2.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 class setElement<ContainingType extends isLastFetchFailed, Type> extends FirebaseMessagingKtxRegistrar<ContainingType, Type> {
        final Type setBackground;
        final isLastFetchFailed setFieldValue;
        final ContainingType setLabel;
        final RemoteActionCompatParcelizer setOptions;

        setElement(ContainingType containingtype, Type type, isLastFetchFailed islastfetchfailed, RemoteActionCompatParcelizer remoteActionCompatParcelizer, Class cls) {
            if (containingtype == null) {
                throw new IllegalArgumentException("Null containingTypeDefaultInstance");
            }
            if (remoteActionCompatParcelizer.setFieldValue() == FirebaseRemoteConfigFetchThrottledException.setLabel.AudioAttributesImplBaseParcelizer && islastfetchfailed == null) {
                throw new IllegalArgumentException("Null messageDefaultInstance");
            }
            this.setLabel = containingtype;
            this.setBackground = type;
            this.setFieldValue = islastfetchfailed;
            this.setOptions = remoteActionCompatParcelizer;
        }

        public ContainingType setElement() {
            return this.setLabel;
        }

        @Override
        public int setBackground() {
            return this.setOptions.setLabel();
        }

        @Override
        public isLastFetchFailed setFieldValue() {
            return this.setFieldValue;
        }

        Object setLabel(Object obj) {
            if (this.setOptions.read()) {
                if (this.setOptions.setBackground() != FirebaseRemoteConfigFetchThrottledException.setError.ENUM) {
                    return obj;
                }
                ArrayList arrayList = new ArrayList();
                Iterator it = ((List) obj).iterator();
                while (it.hasNext()) {
                    arrayList.add(setOptions(it.next()));
                }
                return arrayList;
            }
            return setOptions(obj);
        }

        Object setOptions(Object obj) {
            return this.setOptions.setBackground() == FirebaseRemoteConfigFetchThrottledException.setError.ENUM ? this.setOptions.setOptions.setFieldValue(((Integer) obj).intValue()) : obj;
        }

        Object setBackground(Object obj) {
            if (this.setOptions.read()) {
                if (this.setOptions.setBackground() != FirebaseRemoteConfigFetchThrottledException.setError.ENUM) {
                    return obj;
                }
                ArrayList arrayList = new ArrayList();
                Iterator it = ((List) obj).iterator();
                while (it.hasNext()) {
                    arrayList.add(setFieldValue(it.next()));
                }
                return arrayList;
            }
            return setFieldValue(obj);
        }

        Object setFieldValue(Object obj) {
            return this.setOptions.setBackground() == FirebaseRemoteConfigFetchThrottledException.setError.ENUM ? Integer.valueOf(((r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setOptions) obj).setError()) : obj;
        }

        @Override
        public FirebaseRemoteConfigFetchThrottledException.setLabel setError() {
            return this.setOptions.setFieldValue();
        }

        @Override
        public boolean IconCompatParcelizer() {
            return this.setOptions.setBackground;
        }

        @Override
        public Type setLabel() {
            return this.setBackground;
        }
    }

    protected static final class read implements Serializable {
        private static final long setFieldValue = 0;
        private final Class<?> setBackground;
        private final String setLabel;
        private final byte[] setOptions;

        public static read setBackground(isLastFetchFailed islastfetchfailed) {
            return new read(islastfetchfailed);
        }

        read(isLastFetchFailed islastfetchfailed) {
            Class<?> cls = islastfetchfailed.getClass();
            this.setBackground = cls;
            this.setLabel = cls.getName();
            this.setOptions = islastfetchfailed.MediaSessionCompatQueueItem();
        }

        protected Object readResolve() throws ObjectStreamException {
            try {
                Field declaredField = setOptions().getDeclaredField("DEFAULT_INSTANCE");
                declaredField.setAccessible(true);
                return ((isLastFetchFailed) declaredField.get(null)).initializeViewTreeOwners().setOptions(this.setOptions).ComponentActivity6();
            } catch (InvalidProtocolBufferException e) {
                throw new RuntimeException("Unable to understand proto buffer", e);
            } catch (ClassNotFoundException e2) {
                throw new RuntimeException("Unable to find proto buffer class: " + this.setLabel, e2);
            } catch (IllegalAccessException e3) {
                throw new RuntimeException("Unable to call parsePartialFrom", e3);
            } catch (NoSuchFieldException unused) {
                return setFieldValue();
            } catch (SecurityException e4) {
                throw new RuntimeException("Unable to call DEFAULT_INSTANCE in " + this.setLabel, e4);
            }
        }

        @Deprecated
        private Object setFieldValue() throws ObjectStreamException {
            try {
                Field declaredField = setOptions().getDeclaredField("defaultInstance");
                declaredField.setAccessible(true);
                return ((isLastFetchFailed) declaredField.get(null)).initializeViewTreeOwners().setOptions(this.setOptions).ComponentActivity6();
            } catch (InvalidProtocolBufferException e) {
                throw new RuntimeException("Unable to understand proto buffer", e);
            } catch (ClassNotFoundException e2) {
                throw new RuntimeException("Unable to find proto buffer class: " + this.setLabel, e2);
            } catch (IllegalAccessException e3) {
                throw new RuntimeException("Unable to call parsePartialFrom", e3);
            } catch (NoSuchFieldException e4) {
                throw new RuntimeException("Unable to find defaultInstance in " + this.setLabel, e4);
            } catch (SecurityException e5) {
                throw new RuntimeException("Unable to call defaultInstance in " + this.setLabel, e5);
            }
        }

        private Class<?> setOptions() throws ClassNotFoundException {
            Class<?> cls = this.setBackground;
            return cls != null ? cls : Class.forName(this.setLabel);
        }
    }

    public static <MessageType extends setOptions<MessageType, BuilderType>, BuilderType extends setError<MessageType, BuilderType>, T> setElement<MessageType, T> setOptions(FirebaseMessagingKtxRegistrar<MessageType, T> firebaseMessagingKtxRegistrar) {
        if (!firebaseMessagingKtxRegistrar.setOptions()) {
            throw new IllegalArgumentException("Expected a lite extension.");
        }
        return (setElement) firebaseMessagingKtxRegistrar;
    }

    protected static final <T extends providesFirebasePerformance<T, ?>> boolean setOptions(T t, boolean z) {
        byte byteValue = ((Byte) t.setLabel(IconCompatParcelizer.GET_MEMOIZED_IS_INITIALIZED)).byteValue();
        if (byteValue == 1) {
            return true;
        }
        if (byteValue == 0) {
            return false;
        }
        boolean options = FirebasePerfUrlConnection.setError().setBackground(t).setOptions(t);
        if (z) {
            t.setLabel(IconCompatParcelizer.SET_MEMOIZED_IS_INITIALIZED, options ? t : null);
        }
        return options;
    }

    protected static r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.read PlaybackStateCompatCustomAction() {
        return registerForAppState.setLabel();
    }

    protected static r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.read setError(r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.read readVar) {
        int size = readVar.size();
        return readVar.setBackground(size == 0 ? 10 : size * 2);
    }

    protected static r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.IconCompatParcelizer getLifecycleRegistry() {
        return hasLastFetchBecomeStale.setFieldValue();
    }

    protected static r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.IconCompatParcelizer setOptions(r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.IconCompatParcelizer iconCompatParcelizer) {
        int size = iconCompatParcelizer.size();
        return iconCompatParcelizer.setBackground(size == 0 ? 10 : size * 2);
    }

    protected static r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.RemoteActionCompatParcelizer PlaybackStateCompat() {
        return FirebasePerfKtxRegistrar.setFieldValue();
    }

    protected static r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.RemoteActionCompatParcelizer setFieldValue(r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.RemoteActionCompatParcelizer remoteActionCompatParcelizer) {
        int size = remoteActionCompatParcelizer.size();
        return remoteActionCompatParcelizer.setBackground(size == 0 ? 10 : size * 2);
    }

    protected static r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setError setContentView() {
        return r8lambda9b4qTh6k1amVzUe1kAE6oojA28.setFieldValue();
    }

    protected static r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setError setLabel(r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setError seterror) {
        int size = seterror.size();
        return seterror.setBackground(size == 0 ? 10 : size * 2);
    }

    protected static r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setBackground ParcelableVolumeInfo() {
        return r8lambdaQkqDNTnBQvxCK9qVVo8puvSQXG0.setLabel();
    }

    protected static r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setBackground setBackground(r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.setBackground setbackground) {
        int size = setbackground.size();
        return setbackground.setBackground(size == 0 ? 10 : size * 2);
    }

    public static <E> r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.AudioAttributesImplBaseParcelizer<E> ComponentActivity4() {
        return getContent.setLabel();
    }

    public static <E> r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.AudioAttributesImplBaseParcelizer<E> setFieldValue(r8lambdagIko9kgvZihcrkYfHloMTUCUsQE.AudioAttributesImplBaseParcelizer<E> audioAttributesImplBaseParcelizer) {
        int size = audioAttributesImplBaseParcelizer.size();
        return audioAttributesImplBaseParcelizer.setBackground(size == 0 ? 10 : size * 2);
    }

    public static class setFieldValue<T extends providesFirebasePerformance<T, ?>> extends ComponentRegistrar<T> {
        private final T setOptions;

        public setFieldValue(T t) {
            this.setOptions = t;
        }

        @Override
        public T setLabel(FirebaseNoSignedInUserException firebaseNoSignedInUserException, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
            return (T) providesFirebasePerformance.setOptions(this.setOptions, firebaseNoSignedInUserException, handlemessageintent);
        }

        @Override
        public T setLabel(byte[] bArr, int i, int i2, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
            return (T) providesFirebasePerformance.setLabel(this.setOptions, bArr, i, i2, handlemessageintent);
        }
    }

    static <T extends providesFirebasePerformance<T, ?>> T setOptions(T t, FirebaseNoSignedInUserException firebaseNoSignedInUserException, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        T t2 = (T) t.setLabel(IconCompatParcelizer.NEW_MUTABLE_INSTANCE);
        try {
            r8lambdaB4EZpGOcGV8Pbms2hfENARWWl40 background = FirebasePerfUrlConnection.setError().setBackground(t2);
            background.setError(t2, r8lambdavJ_ijnislX2JLJx5rFvt8ObqNeg.setBackground(firebaseNoSignedInUserException), handlemessageintent);
            background.setFieldValue(t2);
            return t2;
        } catch (IOException e) {
            if (e.getCause() instanceof InvalidProtocolBufferException) {
                throw ((InvalidProtocolBufferException) e.getCause());
            }
            throw new InvalidProtocolBufferException(e.getMessage()).setError(t2);
        } catch (RuntimeException e2) {
            if (e2.getCause() instanceof InvalidProtocolBufferException) {
                throw ((InvalidProtocolBufferException) e2.getCause());
            }
            throw e2;
        }
    }

    static <T extends providesFirebasePerformance<T, ?>> T setLabel(T t, byte[] bArr, int i, int i2, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        T t2 = (T) t.setLabel(IconCompatParcelizer.NEW_MUTABLE_INSTANCE);
        try {
            r8lambdaB4EZpGOcGV8Pbms2hfENARWWl40 background = FirebasePerfUrlConnection.setError().setBackground(t2);
            background.setError(t2, bArr, i, i + i2, new r8lambda5PSoDbsAOSc7vMtr9P22GdjNQw.setLabel(handlemessageintent));
            background.setFieldValue(t2);
            if (t2.memoizedHashCode == 0) {
                return t2;
            }
            throw new RuntimeException();
        } catch (IOException e) {
            if (e.getCause() instanceof InvalidProtocolBufferException) {
                throw ((InvalidProtocolBufferException) e.getCause());
            }
            throw new InvalidProtocolBufferException(e.getMessage()).setError(t2);
        } catch (IndexOutOfBoundsException unused) {
            throw InvalidProtocolBufferException.setElement().setError(t2);
        }
    }

    protected static <T extends providesFirebasePerformance<T, ?>> T setLabel(T t, FirebaseNoSignedInUserException firebaseNoSignedInUserException) throws InvalidProtocolBufferException {
        return (T) setOptions(t, firebaseNoSignedInUserException, handleMessageIntent.setFieldValue());
    }

    private static <T extends providesFirebasePerformance<T, ?>> T setBackground(T t) throws InvalidProtocolBufferException {
        if (t == null || t.getLifecycle()) {
            return t;
        }
        throw t.MediaSessionCompatToken().setBackground().setError(t);
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setBackground(T t, ByteBuffer byteBuffer, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        return (T) setBackground(setFieldValue(t, FirebaseNoSignedInUserException.setLabel(byteBuffer), handlemessageintent));
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setBackground(T t, ByteBuffer byteBuffer) throws InvalidProtocolBufferException {
        return (T) setBackground(t, byteBuffer, handleMessageIntent.setFieldValue());
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setOptions(T t, FirebaseInstallationsKtxRegistrar firebaseInstallationsKtxRegistrar) throws InvalidProtocolBufferException {
        return (T) setBackground(setFieldValue(t, firebaseInstallationsKtxRegistrar, handleMessageIntent.setFieldValue()));
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setFieldValue(T t, FirebaseInstallationsKtxRegistrar firebaseInstallationsKtxRegistrar, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        return (T) setBackground(setOptions(t, firebaseInstallationsKtxRegistrar, handlemessageintent));
    }

    private static <T extends providesFirebasePerformance<T, ?>> T setOptions(T t, FirebaseInstallationsKtxRegistrar firebaseInstallationsKtxRegistrar, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        FirebaseNoSignedInUserException read2 = firebaseInstallationsKtxRegistrar.read();
        T t2 = (T) setOptions(t, read2, handlemessageintent);
        try {
            read2.setOptions(0);
            return t2;
        } catch (InvalidProtocolBufferException e) {
            throw e.setError(t2);
        }
    }

    private static <T extends providesFirebasePerformance<T, ?>> T setOptions(T t, byte[] bArr, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        return (T) setBackground(setLabel(t, bArr, 0, bArr.length, handlemessageintent));
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setError(T t, byte[] bArr) throws InvalidProtocolBufferException {
        return (T) setBackground(setLabel(t, bArr, 0, bArr.length, handleMessageIntent.setFieldValue()));
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setFieldValue(T t, byte[] bArr, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        return (T) setBackground(setLabel(t, bArr, 0, bArr.length, handlemessageintent));
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setFieldValue(T t, InputStream inputStream) throws InvalidProtocolBufferException {
        return (T) setBackground(setOptions(t, FirebaseNoSignedInUserException.setError(inputStream), handleMessageIntent.setFieldValue()));
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setBackground(T t, InputStream inputStream, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        return (T) setBackground(setOptions(t, FirebaseNoSignedInUserException.setError(inputStream), handlemessageintent));
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setFieldValue(T t, FirebaseNoSignedInUserException firebaseNoSignedInUserException) throws InvalidProtocolBufferException {
        return (T) setFieldValue(t, firebaseNoSignedInUserException, handleMessageIntent.setFieldValue());
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setFieldValue(T t, FirebaseNoSignedInUserException firebaseNoSignedInUserException, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        return (T) setBackground(setOptions(t, firebaseNoSignedInUserException, handlemessageintent));
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setOptions(T t, InputStream inputStream) throws InvalidProtocolBufferException {
        return (T) setBackground(setOptions(t, inputStream, handleMessageIntent.setFieldValue()));
    }

    public static <T extends providesFirebasePerformance<T, ?>> T setFieldValue(T t, InputStream inputStream, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        return (T) setBackground(setOptions(t, inputStream, handlemessageintent));
    }

    private static <T extends providesFirebasePerformance<T, ?>> T setOptions(T t, InputStream inputStream, handleMessageIntent handlemessageintent) throws InvalidProtocolBufferException {
        try {
            int read2 = inputStream.read();
            if (read2 == -1) {
                return null;
            }
            FirebaseNoSignedInUserException error = FirebaseNoSignedInUserException.setError(new DependencyCycleException.setError.setOptions(inputStream, FirebaseNoSignedInUserException.setBackground(read2, inputStream)));
            T t2 = (T) setOptions(t, error, handlemessageintent);
            try {
                error.setOptions(0);
                return t2;
            } catch (InvalidProtocolBufferException e) {
                throw e.setError(t2);
            }
        } catch (IOException e2) {
            throw new InvalidProtocolBufferException(e2.getMessage());
        }
    }
}