package androidx.navigation;

import android.os.Bundle;
import com.revenuecat.purchases.subscriberattributes.SubscriberAttributeKt;
import java.util.Arrays;
import x4.AbstractC3250p;

/* JADX INFO: loaded from: classes.dex */
public final class M extends U {

    /* JADX INFO: renamed from: k, reason: collision with root package name */
    public final /* synthetic */ int f12714k;

    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
    public /* synthetic */ M(boolean z6, int i6) {
        super(z6);
        this.f12714k = i6;
    }

    public static float[] g(String str) {
        return new float[]{Float.valueOf(Float.parseFloat(str)).floatValue()};
    }

    public static int[] h(String str) {
        return new int[]{((Number) U.f12720a.d(str)).intValue()};
    }

    public static long[] i(String str) {
        return new long[]{((Number) U.f12722c.d(str)).longValue()};
    }

    public static boolean[] j(String str) {
        return new boolean[]{((Boolean) U.f12726g.d(str)).booleanValue()};
    }

    @Override // androidx.navigation.U
    public final Object a(Bundle bundle, String str) {
        switch (this.f12714k) {
            case 0:
                return (boolean[]) Z0.o.h(bundle, "bundle", str, SubscriberAttributeKt.JSON_NAME_KEY, str);
            case 1:
                return (float[]) Z0.o.h(bundle, "bundle", str, SubscriberAttributeKt.JSON_NAME_KEY, str);
            case 2:
                return (int[]) Z0.o.h(bundle, "bundle", str, SubscriberAttributeKt.JSON_NAME_KEY, str);
            case 3:
                return (long[]) Z0.o.h(bundle, "bundle", str, SubscriberAttributeKt.JSON_NAME_KEY, str);
            default:
                return (String[]) Z0.o.h(bundle, "bundle", str, SubscriberAttributeKt.JSON_NAME_KEY, str);
        }
    }

    @Override // androidx.navigation.U
    public final String b() {
        switch (this.f12714k) {
            case 0:
                return "boolean[]";
            case 1:
                return "float[]";
            case 2:
                return "integer[]";
            case 3:
                return "long[]";
            default:
                return "string[]";
        }
    }

    @Override // androidx.navigation.U
    public final Object c(Object obj, String str) {
        switch (this.f12714k) {
            case 0:
                boolean[] zArr = (boolean[]) obj;
                if (zArr == null) {
                    return j(str);
                }
                boolean[] zArrJ = j(str);
                int length = zArr.length;
                boolean[] zArrCopyOf = Arrays.copyOf(zArr, length + 1);
                System.arraycopy(zArrJ, 0, zArrCopyOf, length, 1);
                kotlin.jvm.internal.o.e(zArrCopyOf);
                return zArrCopyOf;
            case 1:
                float[] fArr = (float[]) obj;
                if (fArr == null) {
                    return g(str);
                }
                float[] fArrG = g(str);
                int length2 = fArr.length;
                float[] fArrCopyOf = Arrays.copyOf(fArr, length2 + 1);
                System.arraycopy(fArrG, 0, fArrCopyOf, length2, 1);
                kotlin.jvm.internal.o.e(fArrCopyOf);
                return fArrCopyOf;
            case 2:
                int[] iArr = (int[]) obj;
                if (iArr == null) {
                    return h(str);
                }
                int[] iArrH = h(str);
                int length3 = iArr.length;
                int[] iArrCopyOf = Arrays.copyOf(iArr, length3 + 1);
                System.arraycopy(iArrH, 0, iArrCopyOf, length3, 1);
                kotlin.jvm.internal.o.e(iArrCopyOf);
                return iArrCopyOf;
            case 3:
                long[] jArr = (long[]) obj;
                if (jArr == null) {
                    return i(str);
                }
                long[] jArrI = i(str);
                int length4 = jArr.length;
                long[] jArrCopyOf = Arrays.copyOf(jArr, length4 + 1);
                System.arraycopy(jArrI, 0, jArrCopyOf, length4, 1);
                kotlin.jvm.internal.o.e(jArrCopyOf);
                return jArrCopyOf;
            default:
                String[] strArr = (String[]) obj;
                if (strArr == null) {
                    return new String[]{str};
                }
                int length5 = strArr.length;
                Object[] objArrCopyOf = Arrays.copyOf(strArr, length5 + 1);
                System.arraycopy(new String[]{str}, 0, objArrCopyOf, length5, 1);
                kotlin.jvm.internal.o.e(objArrCopyOf);
                return (String[]) objArrCopyOf;
        }
    }

    @Override // androidx.navigation.U
    public final Object d(String str) {
        switch (this.f12714k) {
            case 0:
                return j(str);
            case 1:
                return g(str);
            case 2:
                return h(str);
            case 3:
                return i(str);
            default:
                return new String[]{str};
        }
    }

    @Override // androidx.navigation.U
    public final void e(Bundle bundle, String key, Object obj) {
        switch (this.f12714k) {
            case 0:
                kotlin.jvm.internal.o.h(key, "key");
                bundle.putBooleanArray(key, (boolean[]) obj);
                break;
            case 1:
                kotlin.jvm.internal.o.h(key, "key");
                bundle.putFloatArray(key, (float[]) obj);
                break;
            case 2:
                kotlin.jvm.internal.o.h(key, "key");
                bundle.putIntArray(key, (int[]) obj);
                break;
            case 3:
                kotlin.jvm.internal.o.h(key, "key");
                bundle.putLongArray(key, (long[]) obj);
                break;
            default:
                kotlin.jvm.internal.o.h(key, "key");
                bundle.putStringArray(key, (String[]) obj);
                break;
        }
    }

    @Override // androidx.navigation.U
    public final boolean f(Object obj, Object obj2) {
        Boolean[] boolArr;
        Float[] fArr;
        Integer[] numArr;
        Long[] lArr;
        switch (this.f12714k) {
            case 0:
                boolean[] zArr = (boolean[]) obj;
                boolean[] zArr2 = (boolean[]) obj2;
                Boolean[] boolArr2 = null;
                if (zArr != null) {
                    boolArr = new Boolean[zArr.length];
                    int length = zArr.length;
                    for (int i6 = 0; i6 < length; i6++) {
                        boolArr[i6] = Boolean.valueOf(zArr[i6]);
                    }
                } else {
                    boolArr = null;
                }
                if (zArr2 != null) {
                    boolArr2 = new Boolean[zArr2.length];
                    int length2 = zArr2.length;
                    for (int i7 = 0; i7 < length2; i7++) {
                        boolArr2[i7] = Boolean.valueOf(zArr2[i7]);
                    }
                }
                return AbstractC3250p.w(boolArr, boolArr2);
            case 1:
                float[] fArr2 = (float[]) obj;
                float[] fArr3 = (float[]) obj2;
                Float[] fArr4 = null;
                if (fArr2 != null) {
                    fArr = new Float[fArr2.length];
                    int length3 = fArr2.length;
                    for (int i8 = 0; i8 < length3; i8++) {
                        fArr[i8] = Float.valueOf(fArr2[i8]);
                    }
                } else {
                    fArr = null;
                }
                if (fArr3 != null) {
                    fArr4 = new Float[fArr3.length];
                    int length4 = fArr3.length;
                    for (int i9 = 0; i9 < length4; i9++) {
                        fArr4[i9] = Float.valueOf(fArr3[i9]);
                    }
                }
                return AbstractC3250p.w(fArr, fArr4);
            case 2:
                int[] iArr = (int[]) obj;
                int[] iArr2 = (int[]) obj2;
                Integer[] numArr2 = null;
                if (iArr != null) {
                    numArr = new Integer[iArr.length];
                    int length5 = iArr.length;
                    for (int i10 = 0; i10 < length5; i10++) {
                        numArr[i10] = Integer.valueOf(iArr[i10]);
                    }
                } else {
                    numArr = null;
                }
                if (iArr2 != null) {
                    numArr2 = new Integer[iArr2.length];
                    int length6 = iArr2.length;
                    for (int i11 = 0; i11 < length6; i11++) {
                        numArr2[i11] = Integer.valueOf(iArr2[i11]);
                    }
                }
                return AbstractC3250p.w(numArr, numArr2);
            case 3:
                long[] jArr = (long[]) obj;
                long[] jArr2 = (long[]) obj2;
                Long[] lArr2 = null;
                if (jArr != null) {
                    lArr = new Long[jArr.length];
                    int length7 = jArr.length;
                    for (int i12 = 0; i12 < length7; i12++) {
                        lArr[i12] = Long.valueOf(jArr[i12]);
                    }
                } else {
                    lArr = null;
                }
                if (jArr2 != null) {
                    lArr2 = new Long[jArr2.length];
                    int length8 = jArr2.length;
                    for (int i13 = 0; i13 < length8; i13++) {
                        lArr2[i13] = Long.valueOf(jArr2[i13]);
                    }
                }
                return AbstractC3250p.w(lArr, lArr2);
            default:
                return AbstractC3250p.w((String[]) obj, (String[]) obj2);
        }
    }
}